Tutorial PyTorch con regressione lineare

PyTorch è un pacchetto scientifico basato su Python che fornisce una sostituzione di NumPy ndarray come Tensors che sfrutta al massimo le GPU. Un altro punto positivo del framework PyTorch è la velocità e la flessibilità che fornisce durante l'elaborazione. PyTorch è un'alternativa efficiente per lavorare con i tensori usando Tensorflow di cui abbiamo studiato in precedenza.

PyTorch ha alcuni grandi vantaggi come pacchetto di calcolo, come ad esempio:

È possibile costruire grafici di calcolo mentre procediamo. Ciò significa che non è necessario conoscere in anticipo i requisiti di memoria del grafico. Possiamo creare liberamente una rete neurale e valutarla durante il runtime.
API facile da Python che è facilmente integrabile
Supportato da Facebook, quindi il supporto della community è molto forte
Fornisce supporto multi-GPU in modo nativo

PyTorch è abbracciato principalmente dalla comunità di Data Science grazie alla sua capacità di definire convenientemente le reti neurali. Vediamo questo pacchetto di calcolo in azione in questa lezione.

Installazione di PyTorch

Solo una nota prima di iniziare, puoi utilizzare un ambiente virtuale per questa lezione che possiamo creare con il seguente comando:

python -m virtualenv pytorch
sorgente pytorch/bin/activate

Una volta che l'ambiente virtuale è attivo, puoi installare la libreria PyTorch all'interno dell'ambiente virtuale in modo che gli esempi che creeremo in seguito possano essere eseguiti:

pip installa pytorch

In questa lezione faremo uso di Anaconda e Jupyter. Se vuoi installarlo sul tuo computer, guarda la lezione che descrive “Come installare Anaconda Python su Ubuntu 18.04 LTS" e condividi il tuo feedback in caso di problemi. Per installare PyTorch con Anaconda, usa il seguente comando nel terminale da Anaconda:

conda install -c pytorch pytorch

Vediamo qualcosa di simile quando eseguiamo il comando precedente:

Una volta installati e completati tutti i pacchetti necessari, possiamo iniziare a utilizzare la libreria PyTorch con la seguente istruzione di importazione:

importare la torcia

Iniziamo con gli esempi di base di PyTorch ora che abbiamo installato i pacchetti dei prerequisiti.

Iniziare con PyTorch

Poiché sappiamo che le reti neurali possono essere fondamentalmente strutturate poiché Tensors e PyTorch è costruito attorno ai tensori, tende ad esserci un significativo aumento delle prestazioni. Inizieremo con PyTorch esaminando prima il tipo di tensori che fornisce. Per iniziare, importa i pacchetti richiesti:

importare la torcia

Successivamente, possiamo definire un tensore non inizializzato con una dimensione definita:

x = torcia.vuoto(4, 4)
print("Tipo matrice: ".formato(x.tipo)) # tipo
print("Forma matrice: ".formato(x.forma)) # forma
stampa(x)

Vediamo qualcosa di simile quando eseguiamo lo script sopra:

Abbiamo appena creato un tensore non inizializzato con una dimensione definita nello script sopra. Per ribadire dalla nostra lezione Tensorflow, i tensori possono essere definiti come array n-dimensionali che ci permette di rappresentare i dati in una dimensione complessa.

Eseguiamo un altro esempio in cui inizializziamo un tensore Torched con valori casuali:

random_tensor = torcia.rand(5, 4)
print(random_tensor)

Quando eseguiamo il codice sopra, vedremo stampato un oggetto tensore casuale:

Si prega di notare che l'output per Tensor casuale sopra può essere diverso per te perché, beh, è casuale !

Conversione tra NumPy e PyTorch

NumPy e PyTorch sono completamente compatibili tra loro. Ecco perché è facile trasformare gli array NumPy in tensori e viceversa. A parte la facilità fornita dall'API, è probabilmente più facile visualizzare i tensori sotto forma di array NumPy invece di Tensors, o semplicemente chiamarlo il mio amore per NumPy!

Ad esempio, importeremo NumPy nel nostro script e definiremo un semplice array casuale:

importa numpy come np
array = np.casuale.rand(4, 3)
trasformato_tensore = torcia.from_numpy(array)
print("\n".formato(trasformato_tensore))

Quando eseguiamo il codice sopra, vedremo stampato l'oggetto tensore trasformato:

Ora, proviamo a riconvertire questo tensore in un array NumPy:

numpy_arr = trasformato_tensore.insensibile()
print(" \n".format(type(numpy_arr), numpy_arr))

Quando eseguiamo il codice sopra, vedremo stampato l'array NumPy trasformato:

Se osserviamo da vicino, anche la precisione della conversione viene mantenuta mentre si converte l'array in un tensore e poi lo si riconverte in un array NumPy.

Operazioni tensoriali

Prima di iniziare la nostra discussione sulle reti neurali, dovremmo conoscere le operazioni che possono essere eseguite sui tensori durante l'addestramento delle reti neurali. Faremo ampio uso anche del modulo NumPy.

Affettare un tensore

Abbiamo già visto come creare un nuovo Tensore, facciamone uno ora e fetta esso:

vettore = torcia.tensore([1, 2, 3, 4, 5, 6])
print(vettore[1:4])

Il frammento di codice sopra ci fornirà il seguente output:

tensore([2, 3, 4])

Possiamo ignorare l'ultimo indice:

stampa(vettore[1:])

E torneremo anche a ciò che ci si aspetta con un elenco Python:

tensore([2, 3, 4, 5, 6])

Creare un tensore fluttuante

Facciamo ora un tensore fluttuante:

float_vector = torcia.Tensore mobile([1, 2, 3, 4, 5, 6])
print(vettore_mobile)

Il frammento di codice sopra ci fornirà il seguente output:

tensore([1., 2., 3., 4., 5., 6.])

Il tipo di questo tensore sarà:

print(float_vector.dtype)

Restituisce:

torcia.float32

Operazioni aritmetiche sui tensori

Possiamo aggiungere due tensori proprio come qualsiasi elemento matematico, come:

tensore_1 = torcia.tensore([2, 3, 4])
tensor_2 = torcia.tensore([3, 4, 5])
tensore_1 + tensore_2

Il frammento di codice sopra ci darà:

Noi possiamo moltiplicare un tensore con uno scalare:

tensore_1 * 5

Questo ci darà:

Possiamo eseguire un prodotto scalare anche tra due tensori:

d_product = torcia.punto(tensore_1, tensore_2)
d_prodotto

Il frammento di codice sopra ci fornirà il seguente output:

Nella prossima sezione, esamineremo la dimensione maggiore di tensori e matrici.

Moltiplicazione di matrici

In questa sezione vedremo come possiamo definire le metriche come tensori e moltiplicarle, proprio come facevamo alle scuole superiori di matematica.

Definiremo una matrice da cui partire:

matrice = torcia.tensore([1, 3, 5, 6, 8, 0]).vista(2, 3)

Nel frammento di codice sopra, abbiamo definito una matrice con la funzione tensore e quindi specificata con funzione di visualizzazione che dovrebbe essere realizzato come un tensore bidimensionale con 2 righe e 3 colonne. Possiamo fornire più argomenti al Visualizza funzione per specificare più dimensioni. Basta notare che:

conteggio righe moltiplicato per conteggio colonne = conteggio elementi

Quando visualizziamo il tensore bidimensionale sopra, vedremo la seguente matrice:

Definiremo un'altra matrice identica con una forma diversa:

matrice_b = torcia.tensore([1, 3, 5, 6, 8, 0]).vista(3, 2)

Ora possiamo finalmente eseguire la moltiplicazione:

torcia.matmul(matrice, matrice_b)

Il frammento di codice sopra ci fornirà il seguente output:

Regressione lineare con PyTorch

La regressione lineare è un algoritmo di apprendimento automatico basato su tecniche di apprendimento supervisionato per eseguire analisi di regressione su variabili indipendenti e dipendenti. già confuso? Definiamo la regressione lineare in parole semplici.

La regressione lineare è una tecnica per scoprire la relazione tra due variabili e prevedere quanto cambiamento nella variabile indipendente provoca quanto cambiamento nella variabile dipendente. Ad esempio, l'algoritmo di regressione lineare può essere applicato per scoprire quanto aumenta il prezzo di una casa quando la sua area viene aumentata di un certo valore. Oppure, quanta potenza è presente in un'auto in base al peso del motore. Il secondo esempio potrebbe sembrare strano ma puoi sempre provare cose strane e chissà che sei in grado di stabilire una relazione tra questi parametri con la regressione lineare!

La tecnica di regressione lineare di solito utilizza l'equazione di una linea per rappresentare la relazione tra la variabile dipendente (y) e la variabile indipendente (x):

y = m * x + c

Nell'equazione sopra:

m = pendenza della curva
c = bias (punto che interseca l'asse y)

Ora che abbiamo un'equazione che rappresenta la relazione del nostro caso d'uso, proveremo a impostare alcuni dati di esempio insieme a una visualizzazione del grafico. Ecco i dati di esempio per i prezzi delle case e le loro dimensioni:

array_prezzi_casa = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.array(house_prices_array, dtype=np.galleggiante32)
prezzo_casa_np = prezzo_casa_np.rimodellare (-1,1)
house_price_tensor = Variabile(torcia.from_numpy(house_price_np))
dimensione_casa = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.array(house_size, dtype=np.galleggiante32)
house_size_np = house_size_np.rimodellare (-1, 1)
house_size_tensor = Variabile(torcia.from_numpy(house_size_np))
# visualizza i nostri dati
import matplotlib.pyplot come plt
per favore.scatter(house_prices_array, house_size_np)
per favore.xlabel("Prezzo casa $")
per favore.ylabel("Dimensioni della casa")
per favore.title("Prezzo della casa $ VS dimensione della casa")
per favore

Nota che abbiamo fatto uso di Matplotlib che è un'eccellente libreria di visualizzazione. Leggi di più a riguardo nel tutorial Matplotlib. Vedremo il seguente grafico una volta eseguito il frammento di codice sopra:

Quando tracciamo una linea attraverso i punti, potrebbe non essere perfetta ma è comunque sufficiente per il tipo di relazione che hanno le variabili. Ora che abbiamo raccolto e visualizzato i nostri dati, vogliamo fare una previsione che sarà la dimensione della casa se fosse venduta per $ 650.000.

Lo scopo dell'applicazione della regressione lineare è trovare una linea che si adatti ai nostri dati con il minimo errore. ecco i passaggi che eseguiremo per applicare l'algoritmo di regressione lineare ai nostri dati:

Costruire una classe per la regressione lineare
Definire il modello da questa classe di regressione lineare
Calcola il MSE (errore quadratico medio)
Eseguire l'ottimizzazione per ridurre l'errore (SGD i.e. discesa del gradiente stocastico)
Eseguire la retropropagazione
Infine, fai la previsione

Iniziamo ad applicare i passaggi precedenti con le importazioni corrette:

importare la torcia
dalla torcia.variabile di importazione autograd
importare la torcia.nn come nn

Successivamente, possiamo definire la nostra classe di regressione lineare che eredita dal modulo di rete neurale PyTorch:

class LinearRegression(nn.Modulo):
def __init__(self, input_size, output_size):
# super funzione eredita da nn.Modulo in modo che possiamo accedere a tutto da nn.Modulo
super(Regressione lineare, sé).__dentro__()
# Funzione lineare
se stesso.lineare = nn.Lineare(dim_input, dim_output)
def forward(self,x):
tornare da sé.lineare(x)

Ora che siamo pronti con la classe, definiamo il nostro modello con dimensioni di input e output di 1:

input_dim = 1
output_dim = 1
modello = LinearRegression(input_dim, output_dim)

Possiamo definire il MSE come:

mse = nn.MSEloss()

Siamo pronti per definire l'ottimizzazione che può essere eseguita sulla previsione del modello per le migliori prestazioni:

# Ottimizzazione (trova parametri che riducono al minimo l'errore)
tasso_di_apprendimento = 0.02
ottimizzatore = torcia.ottimale.SGD (modello.parametri(), lr=learning_rate)

Possiamo finalmente tracciare un grafico per la funzione di perdita sul nostro modello:

lista_perdite = []
numero_iterazione = 1001
per l'iterazione nell'intervallo (numero_iterazione):
# esegui l'ottimizzazione con gradiente zero
ottimizzatore.zero_grado()
risultati = modello(house_price_tensor)
perdita = mse(risultati, house_size_tensor)
# calcola la derivata facendo un passo indietro
perdita.indietro()
# Aggiornamento dei parametri
ottimizzatore.passo()
# perdita del negozio
loss_list.append(perdita.dati)
# perdita di stampa
if(iterazione % 50 == 0):
print('epoca , perdita '.format(iterazione, perdita.dati))
per favore.plot(range(iteration_number),loss_list)
per favore.xlabel("Numero di iterazioni")
per favore.ylabel("Perdita")
per favore

Abbiamo eseguito ottimizzazioni più volte sulla funzione di perdita e proviamo a visualizzare quanta perdita è aumentata o diminuita. Ecco la trama che è l'output:

Vediamo che al crescere del numero di iterazioni, la perdita tende a zero. Ciò significa che siamo pronti per fare la nostra previsione e tracciarla:

# prevedere il prezzo della nostra auto
previsto = modello(house_price_tensor).dati.insensibile()
per favore.scatter(house_prices_array, house_size, label = "dati originali", colore ="rosso")
per favore.scatter(house_prices_array, predetto, etichetta = "dati previsti", colore ="blu")
per favore.leggenda()
per favore.xlabel("Prezzo casa $")
per favore.ylabel("Dimensione casa")
per favore.title("Valori originali e valori previsti")
per favore.mostrare()

Ecco la trama che ci aiuterà a fare la previsione:

Conclusione

In questa lezione, abbiamo esaminato un eccellente pacchetto di calcolo che ci consente di fare previsioni più veloci ed efficienti e molto altro. PyTorch è popolare per il modo in cui ci consente di gestire le reti neurali in modo fondamentale con i tensori.