PyTorch - Guida rapida

PyTorch è definita come una libreria di machine learning open source per Python. Viene utilizzato per applicazioni come l'elaborazione del linguaggio naturale. È inizialmente sviluppato dal gruppo di ricerca sull'intelligenza artificiale di Facebook e dal software Pyro di Uber per la programmazione probabilistica che è costruito su di esso.

In origine, PyTorch è stato sviluppato da Hugh Perkins come wrapper Python per LusJIT basato sul framework Torch. Esistono due varianti di PyTorch.

PyTorch riprogetta e implementa Torch in Python condividendo le stesse librerie C di base per il codice di backend. Gli sviluppatori di PyTorch hanno ottimizzato questo codice di back-end per eseguire Python in modo efficiente. Hanno anche mantenuto l'accelerazione hardware basata su GPU e le funzionalità di estensibilità che hanno reso Torch basato su Lua.

Caratteristiche

Le caratteristiche principali di PyTorch sono menzionate di seguito:

Easy Interface- PyTorch offre API facili da usare; quindi è considerato molto semplice da usare e gira su Python. L'esecuzione del codice in questo framework è abbastanza semplice.

Python usage- Questa libreria è considerata Pythonic che si integra perfettamente con lo stack di data science di Python. Pertanto, può sfruttare tutti i servizi e le funzionalità offerti dall'ambiente Python.

Computational graphs- PyTorch fornisce un'eccellente piattaforma che offre grafici computazionali dinamici. Pertanto un utente può modificarli durante il runtime. Ciò è molto utile quando uno sviluppatore non ha idea di quanta memoria è richiesta per creare un modello di rete neurale.

PyTorch è noto per avere tre livelli di astrazione come indicato di seguito:

• Tensore: matrice n-dimensionale imperativa che gira su GPU.

• Variabile - Nodo nel grafico computazionale. Memorizza dati e gradiente.

• Modulo: livello di rete neurale che memorizzerà pesi di stato o apprendibili.

Vantaggi di PyTorch

I seguenti sono i vantaggi di PyTorch:

• È facile eseguire il debug e comprendere il codice.

• Include molti strati come Torcia.

• Include molte funzioni di perdita.

• Può essere considerato come un'estensione NumPy alle GPU.

• Permette di costruire reti la cui struttura dipende dal calcolo stesso.

TensorFlow contro PyTorch

Di seguito esamineremo le principali differenze tra TensorFlow e PyTorch:

PyTorch	TensorFlow
PyTorch è strettamente correlato al framework Torch basato su lua che viene utilizzato attivamente in Facebook.	TensorFlow è sviluppato da Google Brain e utilizzato attivamente da Google.
PyTorch è relativamente nuovo rispetto ad altre tecnologie competitive.	TensorFlow non è nuovo ed è considerato uno strumento da portare via da molti ricercatori e professionisti del settore.
PyTorch include tutto in modo imperativo e dinamico.	TensorFlow include grafici statici e dinamici come una combinazione.
Il grafico di calcolo in PyTorch viene definito durante il runtime.	TensorFlow non include alcuna opzione di runtime.
PyTorch include la distribuzione in primo piano per framework mobili e incorporati.	TensorFlow funziona meglio per i framework incorporati.

PyTorch è un popolare framework di apprendimento profondo. In questo tutorial, consideriamo "Windows 10" come il nostro sistema operativo. I passaggi per una configurazione ambientale di successo sono i seguenti:

Passo 1

Il seguente collegamento include un elenco di pacchetti che include pacchetti adatti per PyTorch.

https://drive.google.com/drive/folders/0B-X0-FlSGfCYdTNldW02UGl4MXM

Tutto quello che devi fare è scaricare i rispettivi pacchetti e installarli come mostrato negli screenshot seguenti:

Passo 2

Implica la verifica dell'installazione del framework PyTorch utilizzando Anaconda Framework.

Il seguente comando viene utilizzato per verificare lo stesso:

conda list

"Conda list" mostra l'elenco dei framework installati.

La parte evidenziata mostra che PyTorch è stato installato con successo nel nostro sistema.

La matematica è vitale in qualsiasi algoritmo di apprendimento automatico e include vari concetti fondamentali della matematica per ottenere il giusto algoritmo progettato in un modo specifico.

L'importanza degli argomenti di matematica per l'apprendimento automatico e la scienza dei dati è menzionata di seguito:

Ora, concentriamoci sui principali concetti matematici dell'apprendimento automatico che è importante dal punto di vista dell'elaborazione del linguaggio naturale:

Vettori

Il vettore è considerato un array di numeri che è continuo o discreto e lo spazio che consiste di vettori è chiamato spazio vettoriale. Le dimensioni spaziali dei vettori possono essere finite o infinite, ma è stato osservato che i problemi di apprendimento automatico e scienza dei dati si occupano di vettori di lunghezza fissa.

La rappresentazione vettoriale viene visualizzata come indicato di seguito:

temp = torch.FloatTensor([23,24,24.5,26,27.2,23.0])
temp.size()
Output - torch.Size([6])

Nell'apprendimento automatico, ci occupiamo di dati multidimensionali. Quindi i vettori diventano molto cruciali e sono considerati come caratteristiche di input per qualsiasi dichiarazione di problema di previsione.

Scalari

Gli scalari sono definiti per avere zero dimensioni contenenti un solo valore. Quando si tratta di PyTorch, non include un tensore speciale con dimensioni zero; quindi la dichiarazione sarà resa come segue -

x = torch.rand(10)
x.size()
Output - torch.Size([10])

Matrici

La maggior parte dei dati strutturati è solitamente rappresentata sotto forma di tabelle o una matrice specifica. Useremo un set di dati chiamato Boston House Price, che è prontamente disponibile nella libreria di machine learning scikit-learn di Python.

boston_tensor = torch.from_numpy(boston.data)
boston_tensor.size()
Output: torch.Size([506, 13])
boston_tensor[:2]
Output:
Columns 0 to 7
0.0063 18.0000 2.3100 0.0000 0.5380 6.5750 65.2000 4.0900
0.0273 0.0000 7.0700 0.0000 0.4690 6.4210 78.9000 4.9671
Columns 8 to 12
1.0000 296.0000 15.3000 396.9000 4.9800
2.0000 242.0000 17.8000 396.9000 9.1400

Il principio principale della rete neurale include una raccolta di elementi di base, vale a dire, neurone artificiale o perceptron. Include diversi ingressi di base come x1, x2… .. xn che produce un'uscita binaria se la somma è maggiore del potenziale di attivazione.

La rappresentazione schematica del neurone campione è menzionata di seguito:

L'output generato può essere considerato come la somma ponderata con potenziale di attivazione o bias.

$$ Output = \ sum_jw_jx_j + Bias $$

La tipica architettura di rete neurale è descritta di seguito:

I livelli tra input e output sono indicati come livelli nascosti e la densità e il tipo di connessioni tra i livelli sono la configurazione. Ad esempio, una configurazione completamente connessa ha tutti i neuroni dello strato L collegati a quelli di L + 1. Per una localizzazione più pronunciata, possiamo collegare solo un quartiere locale, diciamo nove neuroni, allo strato successivo. La Figura 1-9 illustra due livelli nascosti con connessioni dense.

I vari tipi di reti neurali sono i seguenti:

Reti neurali feedforward

Le reti neurali feedforward includono unità di base della famiglia di reti neurali. Il movimento dei dati in questo tipo di rete neurale è dal livello di input al livello di output, attraverso gli attuali livelli nascosti. L'output di un livello funge da livello di input con restrizioni su qualsiasi tipo di loop nell'architettura di rete.

Reti neurali ricorrenti

Le reti neurali ricorrenti si verificano quando il modello di dati cambia di conseguenza in un periodo. In RNN, lo stesso layer viene applicato per accettare i parametri di input e visualizzare i parametri di output nella rete neurale specificata.

Le reti neurali possono essere costruite utilizzando il pacchetto torch.nn.

È una semplice rete feed-forward. Prende l'input, lo alimenta attraverso diversi livelli uno dopo l'altro e infine fornisce l'output.

Con l'aiuto di PyTorch, possiamo utilizzare i seguenti passaggi per la tipica procedura di addestramento per una rete neurale:

• Definisci la rete neurale che ha alcuni parametri (o pesi) apprendibili.
• Itera su un set di dati di input.
• Elaborare l'input attraverso la rete.
• Calcola la perdita (quanto è lontano l'output dall'essere corretto).
• Propaga i gradienti nei parametri della rete.
• Aggiorna i pesi della rete, in genere utilizzando un semplice aggiornamento come indicato di seguito

rule: weight = weight -learning_rate * gradient

L'intelligenza artificiale è di tendenza al giorno d'oggi in misura maggiore. L'apprendimento automatico e l'apprendimento profondo costituiscono l'intelligenza artificiale. Il diagramma di Venn menzionato di seguito spiega la relazione tra machine learning e deep learning.

Apprendimento automatico

L'apprendimento automatico è l'arte della scienza che consente ai computer di agire secondo gli algoritmi progettati e programmati. Molti ricercatori pensano che l'apprendimento automatico sia il modo migliore per progredire verso l'IA a livello umano. Include vari tipi di modelli come -

• Modello di apprendimento supervisionato
• Modello di apprendimento senza supervisione

Apprendimento approfondito

L'apprendimento profondo è un sottocampo dell'apprendimento automatico in cui gli algoritmi interessati sono ispirati dalla struttura e dalla funzione del cervello chiamate reti neurali artificiali.

L'apprendimento profondo ha acquisito molta importanza attraverso l'apprendimento supervisionato o l'apprendimento da dati e algoritmi etichettati. Ogni algoritmo nell'apprendimento profondo segue lo stesso processo. Include la gerarchia della trasformazione non lineare dell'input e utilizza per creare un modello statistico come output.

Il processo di apprendimento automatico viene definito utilizzando i seguenti passaggi:

• Identifica i set di dati rilevanti e li prepara per l'analisi.
• Sceglie il tipo di algoritmo da utilizzare.
• Costruisce un modello analitico basato sull'algoritmo utilizzato.
• Addestra il modello su set di dati di test, rivedendolo secondo necessità.
• Esegue il modello per generare i punteggi dei test.

In questo capitolo, discuteremo la principale differenza tra i concetti di Machine e Deep learning.

Quantità di dati

L'apprendimento automatico funziona con diverse quantità di dati e viene utilizzato principalmente per piccole quantità di dati. Il deep learning, invece, funziona in modo efficiente se la quantità di dati aumenta rapidamente. Il diagramma seguente illustra il funzionamento del machine learning e del deep learning rispetto alla quantità di dati:

Dipendenze hardware

Gli algoritmi di deep learning sono progettati per dipendere fortemente da macchine di fascia alta, al contrario dei tradizionali algoritmi di machine learning. Gli algoritmi di deep learning eseguono una grande quantità di operazioni di moltiplicazione di matrici che richiedono un enorme supporto hardware.

Feature Engineering

L'ingegnerizzazione delle caratteristiche è il processo di inserimento della conoscenza del dominio in caratteristiche specifiche per ridurre la complessità dei dati e creare modelli visibili agli algoritmi di apprendimento.

Ad esempio, i modelli di apprendimento automatico tradizionali si concentrano sui pixel e su altri attributi necessari per il processo di progettazione delle funzionalità. Gli algoritmi di deep learning si concentrano su funzionalità di alto livello dai dati. Riduce il compito di sviluppare un nuovo estrattore di funzionalità per ogni nuovo problema.

PyTorch include una funzionalità speciale per la creazione e l'implementazione di reti neurali. In questo capitolo creeremo una semplice rete neurale con uno strato nascosto che sviluppa una singola unità di output.

Useremo i seguenti passaggi per implementare la prima rete neurale utilizzando PyTorch:

Passo 1

Innanzitutto, dobbiamo importare la libreria PyTorch utilizzando il comando seguente:

import torch 
import torch.nn as nn

Passo 2

Definisci tutti i livelli e la dimensione del batch per avviare l'esecuzione della rete neurale come mostrato di seguito:

# Defining input size, hidden layer size, output size and batch size respectively
n_in, n_h, n_out, batch_size = 10, 5, 1, 10

Passaggio 3

Poiché la rete neurale include una combinazione di dati di input per ottenere i rispettivi dati di output, seguiremo la stessa procedura indicata di seguito:

# Create dummy input and target tensors (data)
x = torch.randn(batch_size, n_in)
y = torch.tensor([[1.0], [0.0], [0.0], 
[1.0], [1.0], [1.0], [0.0], [0.0], [1.0], [1.0]])

Passaggio 4

Crea un modello sequenziale con l'aiuto di funzioni integrate. Utilizzando le seguenti righe di codice, crea un modello sequenziale -

# Create a model
model = nn.Sequential(nn.Linear(n_in, n_h),
   nn.ReLU(),
   nn.Linear(n_h, n_out),
   nn.Sigmoid())

Passaggio 5

Costruisci la funzione di perdita con l'aiuto dell'ottimizzatore Gradient Descent come mostrato di seguito -

Construct the loss function
criterion = torch.nn.MSELoss()
# Construct the optimizer (Stochastic Gradient Descent in this case)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

Passaggio 6

Implementa il modello di discesa del gradiente con il ciclo iterativo con le righe di codice fornite -

# Gradient Descent
for epoch in range(50):
   # Forward pass: Compute predicted y by passing x to the model
   y_pred = model(x)

   # Compute and print loss
   loss = criterion(y_pred, y)
   print('epoch: ', epoch,' loss: ', loss.item())

   # Zero gradients, perform a backward pass, and update the weights.
   optimizer.zero_grad()

   # perform a backward pass (backpropagation)
   loss.backward()

   # Update the parameters
   optimizer.step()

Passaggio 7

L'output generato è il seguente:

epoch: 0 loss: 0.2545787990093231
epoch: 1 loss: 0.2545052170753479
epoch: 2 loss: 0.254431813955307
epoch: 3 loss: 0.25435858964920044
epoch: 4 loss: 0.2542854845523834
epoch: 5 loss: 0.25421255826950073
epoch: 6 loss: 0.25413978099823
epoch: 7 loss: 0.25406715273857117
epoch: 8 loss: 0.2539947032928467
epoch: 9 loss: 0.25392240285873413
epoch: 10 loss: 0.25385022163391113
epoch: 11 loss: 0.25377824902534485
epoch: 12 loss: 0.2537063956260681
epoch: 13 loss: 0.2536346912384033
epoch: 14 loss: 0.25356316566467285
epoch: 15 loss: 0.25349172949790955
epoch: 16 loss: 0.25342053174972534
epoch: 17 loss: 0.2533493936061859
epoch: 18 loss: 0.2532784342765808
epoch: 19 loss: 0.25320762395858765
epoch: 20 loss: 0.2531369626522064
epoch: 21 loss: 0.25306645035743713
epoch: 22 loss: 0.252996027469635
epoch: 23 loss: 0.2529257833957672
epoch: 24 loss: 0.25285571813583374
epoch: 25 loss: 0.25278574228286743
epoch: 26 loss: 0.25271597504615784
epoch: 27 loss: 0.25264623761177063
epoch: 28 loss: 0.25257670879364014
epoch: 29 loss: 0.2525072991847992
epoch: 30 loss: 0.2524380087852478
epoch: 31 loss: 0.2523689270019531
epoch: 32 loss: 0.25229987502098083
epoch: 33 loss: 0.25223103165626526
epoch: 34 loss: 0.25216227769851685
epoch: 35 loss: 0.252093642950058
epoch: 36 loss: 0.25202515721321106
epoch: 37 loss: 0.2519568204879761
epoch: 38 loss: 0.251888632774353
epoch: 39 loss: 0.25182053446769714
epoch: 40 loss: 0.2517525553703308
epoch: 41 loss: 0.2516847252845764
epoch: 42 loss: 0.2516169846057892
epoch: 43 loss: 0.2515493929386139
epoch: 44 loss: 0.25148195028305054
epoch: 45 loss: 0.25141456723213196
epoch: 46 loss: 0.2513473629951477
epoch: 47 loss: 0.2512802183628082
epoch: 48 loss: 0.2512132525444031
epoch: 49 loss: 0.2511464059352875

L'addestramento di un algoritmo di deep learning prevede i seguenti passaggi:

• Costruire una pipeline di dati
• Costruire un'architettura di rete
• Valutazione dell'architettura utilizzando una funzione di perdita
• L'ottimizzazione dei pesi dell'architettura di rete utilizzando un algoritmo di ottimizzazione

L'addestramento di uno specifico algoritmo di apprendimento profondo è il requisito esatto per convertire una rete neurale in blocchi funzionali come mostrato di seguito:

Rispetto al diagramma sopra, qualsiasi algoritmo di deep learning implica l'acquisizione dei dati di input, la costruzione della rispettiva architettura che include un gruppo di livelli incorporati in essi.

Se si osserva il diagramma sopra, l'accuratezza viene valutata utilizzando una funzione di perdita rispetto all'ottimizzazione dei pesi della rete neurale.

In questo capitolo discuteremo alcuni dei termini più comunemente usati in PyTorch.

PyTorch NumPy

Un tensore PyTorch è identico a un array NumPy. Un tensore è un array n-dimensionale e rispetto a PyTorch fornisce molte funzioni per operare su questi tensori.

I tensori PyTorch di solito utilizzano le GPU per accelerare i loro calcoli numerici. Questi tensori creati in PyTorch possono essere utilizzati per adattare una rete a due strati a dati casuali. L'utente può implementare manualmente i passaggi avanti e indietro attraverso la rete.

Variabili e Autograd

Quando si utilizza autograd, il passaggio in avanti della rete definirà un file computational graph - i nodi nel grafico saranno Tensori e gli archi saranno funzioni che producono Tensori di output dai Tensori di input.

I tensori PyTorch possono essere creati come oggetti variabili in cui una variabile rappresenta un nodo nel grafo computazionale.

Grafici dinamici

I grafici statici sono utili perché l'utente può ottimizzare il grafico in anticipo. Se i programmatori stanno riutilizzando lo stesso grafico più e più volte, questa ottimizzazione iniziale potenzialmente costosa può essere mantenuta mentre lo stesso grafico viene rieseguito più e più volte.

La principale differenza tra loro è che i grafici computazionali di Tensor Flow sono statici e PyTorch utilizza grafici computazionali dinamici.

Pacchetto Optim

Il pacchetto optim in PyTorch astrae l'idea di un algoritmo di ottimizzazione implementato in molti modi e fornisce illustrazioni di algoritmi di ottimizzazione comunemente usati. Questo può essere chiamato all'interno dell'istruzione import.

Multiprocessing

Il multiprocessing supporta le stesse operazioni, in modo che tutti i tensori funzionino su più processori. La coda avrà i propri dati spostati nella memoria condivisa e invierà solo un handle a un altro processo.

PyTorch include un pacchetto chiamato torchvision che viene utilizzato per caricare e preparare il set di dati. Include due funzioni di base, ovvero Dataset e DataLoader, che aiuta nella trasformazione e nel caricamento del set di dati.

Set di dati

Il set di dati viene utilizzato per leggere e trasformare un punto dati dal set di dati specificato. La sintassi di base da implementare è menzionata di seguito:

trainset = torchvision.datasets.CIFAR10(root = './data', train = True,
   download = True, transform = transform)

DataLoader viene utilizzato per mescolare e raggruppare i dati. Può essere utilizzato per caricare i dati in parallelo con i worker multiprocessing.

trainloader = torch.utils.data.DataLoader(trainset, batch_size = 4,
   shuffle = True, num_workers = 2)

Esempio: caricamento del file CSV

Usiamo il pacchetto Python Panda per caricare il file csv. Il file originale ha il seguente formato: (nome dell'immagine, 68 punti di riferimento - ogni punto di riferimento ha coordinate ax, y).

landmarks_frame = pd.read_csv('faces/face_landmarks.csv')

n = 65
img_name = landmarks_frame.iloc[n, 0]
landmarks = landmarks_frame.iloc[n, 1:].as_matrix()
landmarks = landmarks.astype('float').reshape(-1, 2)

In questo capitolo, ci concentreremo sull'esempio di base dell'implementazione della regressione lineare utilizzando TensorFlow. La regressione logistica o regressione lineare è un approccio di apprendimento automatico supervisionato per la classificazione di categorie discrete di ordine. Il nostro obiettivo in questo capitolo è costruire un modello in base al quale un utente possa prevedere la relazione tra variabili predittive e una o più variabili indipendenti.

La relazione tra queste due variabili è considerata lineare, ovvero, se y è la variabile dipendente ex è considerata la variabile indipendente, la relazione di regressione lineare di due variabili sarà simile all'equazione menzionata di seguito:

Y = Ax+b

Successivamente, progetteremo un algoritmo per la regressione lineare che ci permetta di comprendere due importanti concetti riportati di seguito:

• Funzione di costo
• Algoritmi di discesa del gradiente

La rappresentazione schematica della regressione lineare è menzionata di seguito

Interpretare il risultato

$$ Y = ax + b $$

• Il valore di a è la pendenza.

• Il valore di b è il y − intercept.

• r è il correlation coefficient.

• r² è il correlation coefficient.

La vista grafica dell'equazione della regressione lineare è menzionata di seguito:

I passaggi seguenti vengono utilizzati per implementare la regressione lineare utilizzando PyTorch -

Passo 1

Importa i pacchetti necessari per creare una regressione lineare in PyTorch utilizzando il codice seguente:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import seaborn as sns
import pandas as pd
%matplotlib inline

sns.set_style(style = 'whitegrid')
plt.rcParams["patch.force_edgecolor"] = True

Passo 2

Crea un singolo set di allenamento con il set di dati disponibile come mostrato di seguito:

m = 2 # slope
c = 3 # interceptm = 2 # slope
c = 3 # intercept
x = np.random.rand(256)

noise = np.random.randn(256) / 4

y = x * m + c + noise

df = pd.DataFrame()
df['x'] = x
df['y'] = y

sns.lmplot(x ='x', y ='y', data = df)

Passaggio 3

Implementa la regressione lineare con le librerie PyTorch come indicato di seguito -

import torch
import torch.nn as nn
from torch.autograd import Variable
x_train = x.reshape(-1, 1).astype('float32')
y_train = y.reshape(-1, 1).astype('float32')

class LinearRegressionModel(nn.Module):
   def __init__(self, input_dim, output_dim):
      super(LinearRegressionModel, self).__init__()
      self.linear = nn.Linear(input_dim, output_dim)

   def forward(self, x):
      out = self.linear(x)
      return out
input_dim = x_train.shape[1]
output_dim = y_train.shape[1]
input_dim, output_dim(1, 1)
model = LinearRegressionModel(input_dim, output_dim)
criterion = nn.MSELoss()
[w, b] = model.parameters()

def get_param_values():
   return w.data[0][0], b.data[0]

def plot_current_fit(title = ""):
plt.figure(figsize = (12,4))
plt.title(title)
plt.scatter(x, y, s = 8)
w1 = w.data[0][0]
b1 = b.data[0]
x1 = np.array([0., 1.])
y1 = x1 * w1 + b1
plt.plot(x1, y1, 'r', label = 'Current Fit ({:.3f}, {:.3f})'.format(w1, b1))
plt.xlabel('x (input)')
plt.ylabel('y (target)')
plt.legend()
plt.show()
plot_current_fit('Before training')

Il grafico generato è il seguente:

Il deep learning è una divisione dell'apprendimento automatico ed è considerato un passo cruciale compiuto dai ricercatori negli ultimi decenni. Gli esempi di implementazione del deep learning includono applicazioni come il riconoscimento delle immagini e il riconoscimento vocale.

Di seguito sono riportati i due importanti tipi di reti neurali profonde:

• Reti neurali convoluzionali
• Reti neurali ricorrenti.

In questo capitolo, ci concentreremo sul primo tipo, vale a dire, Convolutional Neural Networks (CNN).

Reti neurali convoluzionali

Le reti neurali convoluzionali sono progettate per elaborare i dati attraverso più livelli di array. Questo tipo di reti neurali vengono utilizzate in applicazioni come il riconoscimento delle immagini o il riconoscimento facciale.

La differenza principale tra la CNN e qualsiasi altra rete neurale ordinaria è che la CNN prende l'input come un array bidimensionale e opera direttamente sulle immagini piuttosto che concentrarsi sull'estrazione di caratteristiche su cui si concentrano altre reti neurali.

L'approccio dominante della CNN include la soluzione per i problemi di riconoscimento. Le migliori aziende come Google e Facebook hanno investito in progetti di ricerca e sviluppo di progetti di riconoscimento per svolgere le attività con maggiore velocità.

Ogni rete neurale convoluzionale include tre idee di base:

• Campi rispettivi locali
• Convolution
• Pooling

Cerchiamo di comprendere ciascuna di queste terminologie in dettaglio.

Campi rispettivi locali

La CNN utilizza le correlazioni spaziali che esistono all'interno dei dati di input. Ciascuno negli strati simultanei delle reti neurali connette alcuni neuroni di input. Questa regione specifica è chiamata campo ricettivo locale. Si concentra solo sui neuroni nascosti. Il neurone nascosto elaborerà i dati di input all'interno del campo menzionato non rendendosi conto dei cambiamenti al di fuori del confine specifico.

La rappresentazione del diagramma della generazione dei rispettivi campi locali è menzionata di seguito:

Convoluzione

Nella figura sopra, osserviamo che ogni connessione apprende un peso di neurone nascosto con una connessione associata con il movimento da uno strato all'altro. Qui, i singoli neuroni eseguono un cambiamento di volta in volta. Questo processo è chiamato "convoluzione".

La mappatura delle connessioni dal livello di input alla mappa degli elementi nascosti è definita come "pesi condivisi" e il bias incluso è chiamato "bias condiviso".

Pooling

Le reti neurali convoluzionali utilizzano livelli di pooling che vengono posizionati immediatamente dopo la dichiarazione della CNN. Prende l'input dell'utente come una mappa di caratteristiche che esce da reti convoluzionali e prepara una mappa di caratteristiche condensata. Il raggruppamento dei livelli aiuta a creare livelli con i neuroni dei livelli precedenti.

Implementazione di PyTorch

I passaggi seguenti vengono utilizzati per creare una rete neurale convoluzionale utilizzando PyTorch.

Passo 1

Importa i pacchetti necessari per creare una semplice rete neurale.

from torch.autograd import Variable
import torch.nn.functional as F

Passo 2

Crea una classe con la rappresentazione in batch della rete neurale convoluzionale. La nostra forma batch per l'input x è con dimensione (3, 32, 32).

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

Passaggio 3

Calcola l'attivazione delle prime modifiche alla dimensione della convoluzione da (3, 32, 32) a (18, 32, 32).

La dimensione della dimensione cambia da (18, 32, 32) a (18, 16, 16). Rimodellare la dimensione dei dati del livello di input della rete neurale a causa della quale la dimensione cambia da (18, 16, 16) a (1, 4608).

Ricorda che -1 deduce questa dimensione dall'altra dimensione data.

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)

Le reti neurali ricorrenti sono un tipo di algoritmo orientato al deep learning che segue un approccio sequenziale. Nelle reti neurali, assumiamo sempre che ogni input e output sia indipendente da tutti gli altri livelli. Questo tipo di reti neurali sono chiamate ricorrenti perché eseguono calcoli matematici in modo sequenziale completando un'attività dopo l'altra.

Il diagramma seguente specifica l'approccio completo e il funzionamento delle reti neurali ricorrenti:

Nella figura sopra, c1, c2, c3 e x1 sono considerati input che includono alcuni valori di input nascosti, vale a dire h1, h2 e h3 che forniscono il rispettivo output di o1. Ci concentreremo ora sull'implementazione di PyTorch per creare un'onda sinusoidale con l'aiuto di reti neurali ricorrenti.

Durante l'addestramento, seguiremo un approccio di addestramento al nostro modello con un punto dati alla volta. La sequenza di input x è composta da 20 punti dati e la sequenza di destinazione è considerata uguale alla sequenza di input.

Passo 1

Importa i pacchetti necessari per l'implementazione di reti neurali ricorrenti utilizzando il codice seguente:

import torch
from torch.autograd import Variable
import numpy as np
import pylab as pl
import torch.nn.init as init

Passo 2

Imposteremo i parametri iper del modello con la dimensione del livello di input impostata su 7. Ci saranno 6 neuroni di contesto e 1 neurone di input per la creazione della sequenza target.

dtype = torch.FloatTensor
input_size, hidden_size, output_size = 7, 6, 1
epochs = 300
seq_length = 20
lr = 0.1
data_time_steps = np.linspace(2, 10, seq_length + 1)
data = np.sin(data_time_steps)
data.resize((seq_length + 1, 1))

x = Variable(torch.Tensor(data[:-1]).type(dtype), requires_grad=False)
y = Variable(torch.Tensor(data[1:]).type(dtype), requires_grad=False)

Genereremo i dati di addestramento, dove x è la sequenza dei dati di input ey è la sequenza di destinazione richiesta.

Passaggio 3

I pesi vengono inizializzati nella rete neurale ricorrente utilizzando la distribuzione normale con media zero. W1 rappresenterà l'accettazione delle variabili di input e w2 rappresenterà l'output generato come mostrato di seguito -

w1 = torch.FloatTensor(input_size, 
hidden_size).type(dtype)
init.normal(w1, 0.0, 0.4)
w1 = Variable(w1, requires_grad = True)
w2 = torch.FloatTensor(hidden_size, output_size).type(dtype)
init.normal(w2, 0.0, 0.3)
w2 = Variable(w2, requires_grad = True)

Passaggio 4

Ora, è importante creare una funzione per feed forward che definisca in modo univoco la rete neurale.

def forward(input, context_state, w1, w2):
   xh = torch.cat((input, context_state), 1)
   context_state = torch.tanh(xh.mm(w1))
   out = context_state.mm(w2)
   return (out, context_state)

Passaggio 5

Il passo successivo è avviare la procedura di addestramento dell'implementazione dell'onda sinusoidale della rete neurale ricorrente. Il ciclo esterno itera su ogni ciclo e il ciclo interno itera attraverso l'elemento di sequenza. Qui, calcoleremo anche Mean Square Error (MSE) che aiuta nella previsione di variabili continue.

for i in range(epochs):
   total_loss = 0
   context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = True)
   for j in range(x.size(0)):
      input = x[j:(j+1)]
      target = y[j:(j+1)]
      (pred, context_state) = forward(input, context_state, w1, w2)
      loss = (pred - target).pow(2).sum()/2
      total_loss += loss
      loss.backward()
      w1.data -= lr * w1.grad.data
      w2.data -= lr * w2.grad.data
      w1.grad.data.zero_()
      w2.grad.data.zero_()
      context_state = Variable(context_state.data)
   if i % 10 == 0:
      print("Epoch: {} loss {}".format(i, total_loss.data[0]))

context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = False)
predictions = []

for i in range(x.size(0)):
   input = x[i:i+1]
   (pred, context_state) = forward(input, context_state, w1, w2)
   context_state = context_state
   predictions.append(pred.data.numpy().ravel()[0])

Passaggio 6

Ora è il momento di tracciare l'onda sinusoidale nel modo in cui è necessaria.

pl.scatter(data_time_steps[:-1], x.data.numpy(), s = 90, label = "Actual")
pl.scatter(data_time_steps[1:], predictions, label = "Predicted")
pl.legend()
pl.show()

Produzione

L'output per il processo di cui sopra è il seguente:

In questo capitolo, ci concentreremo maggiormente su torchvision.datasetse le sue varie tipologie. PyTorch include i seguenti caricatori di set di dati:

• MNIST
• COCO (sottotitoli e rilevamento)

Il set di dati include la maggior parte dei due tipi di funzioni indicate di seguito:

• Transform- una funzione che accetta un'immagine e restituisce una versione modificata di materiale standard. Questi possono essere composti insieme alle trasformazioni.

• Target_transform- una funzione che prende il bersaglio e lo trasforma. Ad esempio, accetta la stringa della didascalia e restituisce un tensore degli indici mondiali.

MNIST

Di seguito è riportato il codice di esempio per il set di dati MNIST:

dset.MNIST(root, train = TRUE, transform = NONE, 
target_transform = None, download = FALSE)

I parametri sono i seguenti:

• root - directory principale del set di dati in cui esistono i dati elaborati.

• train - True = Training set, False = Test set

• download - Vero = scarica il set di dati da Internet e lo inserisce nella radice.

COCO

Ciò richiede l'installazione dell'API COCO. L'esempio seguente viene utilizzato per dimostrare l'implementazione COCO del set di dati utilizzando PyTorch -

import torchvision.dataset as dset
import torchvision.transforms as transforms
cap = dset.CocoCaptions(root = ‘ dir where images are’, 
annFile = ’json annotation file’,
transform = transforms.ToTensor())
print(‘Number of samples: ‘, len(cap))
print(target)

L'output ottenuto è il seguente:

Number of samples: 82783
Image Size: (3L, 427L, 640L)

Convents si tratta di costruire da zero il modello della CNN. L'architettura di rete conterrà una combinazione dei seguenti passaggi:

• Conv2d
• MaxPool2d
• Unità lineare rettificata
• View
• Layer lineare

Formazione del modello

L'addestramento del modello è lo stesso processo come i problemi di classificazione delle immagini. Il seguente frammento di codice completa la procedura di un modello di addestramento sul set di dati fornito:

def fit(epoch,model,data_loader,phase 
= 'training',volatile = False):
   if phase == 'training':
      model.train()
   if phase == 'training':
      model.train()
   if phase == 'validation':
      model.eval()
   volatile=True
   running_loss = 0.0
   running_correct = 0
   for batch_idx , (data,target) in enumerate(data_loader):
      if is_cuda:
         data,target = data.cuda(),target.cuda()
         data , target = Variable(data,volatile),Variable(target)
      if phase == 'training':
         optimizer.zero_grad()
         output = model(data)
         loss = F.nll_loss(output,target)
         running_loss + = 
         F.nll_loss(output,target,size_average = 
         False).data[0]
         preds = output.data.max(dim = 1,keepdim = True)[1]
         running_correct + = 
         preds.eq(target.data.view_as(preds)).cpu().sum()
         if phase == 'training':
            loss.backward()
            optimizer.step()
   loss = running_loss/len(data_loader.dataset)
   accuracy = 100. * running_correct/len(data_loader.dataset)
   print(f'{phase} loss is {loss:{5}.{2}} and {phase} accuracy is {running_correct}/{len(data_loader.dataset)}{accuracy:{return loss,accuracy}})

Il metodo include una logica diversa per l'addestramento e la convalida. Ci sono due ragioni principali per l'utilizzo di modalità diverse:

• In modalità treno, il dropout rimuove una percentuale di valori, cosa che non dovrebbe verificarsi nella fase di validazione o test.

• Per la modalità di addestramento, calcoliamo i gradienti e modifichiamo il valore dei parametri del modello, ma non è richiesta la retro propagazione durante le fasi di test o convalida.

In questo capitolo ci concentreremo sulla creazione di un convento da zero. Ciò implica la creazione del rispettivo convento o rete neurale campione con la torcia.

Passo 1

Crea una classe necessaria con i rispettivi parametri. I parametri includono pesi con valore casuale.

class Neural_Network(nn.Module):
   def __init__(self, ):
      super(Neural_Network, self).__init__()
      self.inputSize = 2
      self.outputSize = 1
      self.hiddenSize = 3
      # weights
      self.W1 = torch.randn(self.inputSize, 
      self.hiddenSize) # 3 X 2 tensor
      self.W2 = torch.randn(self.hiddenSize, self.outputSize) # 3 X 1 tensor

Passo 2

Crea un modello di funzione feed-forward con funzioni sigmoide.

def forward(self, X):
   self.z = torch.matmul(X, self.W1) # 3 X 3 ".dot" 
   does not broadcast in PyTorch
   self.z2 = self.sigmoid(self.z) # activation function
   self.z3 = torch.matmul(self.z2, self.W2)
   o = self.sigmoid(self.z3) # final activation 
   function
   return o
   def sigmoid(self, s):
      return 1 / (1 + torch.exp(-s))
   def sigmoidPrime(self, s):
      # derivative of sigmoid
      return s * (1 - s)
   def backward(self, X, y, o):
      self.o_error = y - o # error in output
      self.o_delta = self.o_error * self.sigmoidPrime(o) # derivative of sig to error
      self.z2_error = torch.matmul(self.o_delta, torch.t(self.W2))
      self.z2_delta = self.z2_error * self.sigmoidPrime(self.z2)
      self.W1 + = torch.matmul(torch.t(X), self.z2_delta)
      self.W2 + = torch.matmul(torch.t(self.z2), self.o_delta)

Passaggio 3

Crea un modello di addestramento e previsione come indicato di seguito:

def train(self, X, y):
   # forward + backward pass for training
   o = self.forward(X)
   self.backward(X, y, o)
def saveWeights(self, model):
   # Implement PyTorch internal storage functions
   torch.save(model, "NN")
   # you can reload model with all the weights and so forth with:
   # torch.load("NN")
def predict(self):
   print ("Predicted data based on trained weights: ")
   print ("Input (scaled): \n" + str(xPredicted))
   print ("Output: \n" + str(self.forward(xPredicted)))

Le reti neurali convoluzionali includono una caratteristica primaria, extraction. I passaggi seguenti vengono utilizzati per implementare l'estrazione delle funzionalità della rete neurale convoluzionale.

Passo 1

Importare i rispettivi modelli per creare il modello di estrazione delle feature con "PyTorch".

import torch
import torch.nn as nn
from torchvision import models

Passo 2

Creare una classe di estrattore di funzionalità che può essere richiamata come e quando necessario.

class Feature_extractor(nn.module):
   def forward(self, input):
      self.feature = input.clone()
      return input
new_net = nn.Sequential().cuda() # the new network
target_layers = [conv_1, conv_2, conv_4] # layers you want to extract`
i = 1
for layer in list(cnn):
   if isinstance(layer,nn.Conv2d):
      name = "conv_"+str(i)
      art_net.add_module(name,layer)
      if name in target_layers:
         new_net.add_module("extractor_"+str(i),Feature_extractor())
      i+=1
   if isinstance(layer,nn.ReLU):
      name = "relu_"+str(i)
      new_net.add_module(name,layer)
   if isinstance(layer,nn.MaxPool2d):
      name = "pool_"+str(i)
      new_net.add_module(name,layer)
new_net.forward(your_image)
print (new_net.extractor_3.feature)

In questo capitolo, ci concentreremo sul modello di visualizzazione dei dati con l'aiuto dei conventi. I passaggi seguenti sono necessari per ottenere un'immagine perfetta della visualizzazione con la rete neurale convenzionale.

Passo 1

Importare i moduli necessari che è importante per la visualizzazione delle reti neurali convenzionali.

import os
import numpy as np
import pandas as pd
from scipy.misc import imread
from sklearn.metrics import accuracy_score

import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Flatten, Activation, Input
from keras.layers import Conv2D, MaxPooling2D
import torch

Passo 2

Per interrompere la potenziale casualità con i dati di addestramento e test, chiama il rispettivo set di dati come indicato nel codice seguente

seed = 128
rng = np.random.RandomState(seed)
data_dir = "../../datasets/MNIST"
train = pd.read_csv('../../datasets/MNIST/train.csv')
test = pd.read_csv('../../datasets/MNIST/Test_fCbTej3.csv')
img_name = rng.choice(train.filename)
filepath = os.path.join(data_dir, 'train', img_name)
img = imread(filepath, flatten=True)

Passaggio 3

Traccia le immagini necessarie per ottenere i dati di addestramento e test definiti in modo perfetto utilizzando il codice seguente -

pylab.imshow(img, cmap ='gray')
pylab.axis('off')
pylab.show()

L'output viene visualizzato come di seguito:

In questo capitolo, proponiamo un approccio alternativo che si basa invece su una singola rete neurale convoluzionale 2D attraverso entrambe le sequenze. Ogni strato della nostra rete ricodifica i token sorgente sulla base della sequenza di output prodotta finora. Le proprietà simili all'attenzione sono quindi pervasive in tutta la rete.

Qui ci concentreremo su creating the sequential network with specific pooling from the values included in dataset. Questo processo è anche meglio applicato nel "Modulo di riconoscimento delle immagini".

I seguenti passaggi vengono utilizzati per creare un modello di elaborazione di sequenze con conventi utilizzando PyTorch -

Passo 1

Importare i moduli necessari per l'esecuzione dell'elaborazione della sequenza utilizzando conventi.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout, Flatten 
from keras.layers import Conv2D, MaxPooling2D 
import numpy as np

Passo 2

Eseguire le operazioni necessarie per creare un modello nella rispettiva sequenza utilizzando il codice seguente:

batch_size = 128 
num_classes = 10 
epochs = 12
# input image dimensions 
img_rows, img_cols = 28, 28
# the data, split between train and test sets 
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000,28,28,1) 
x_test = x_test.reshape(10000,28,28,1)
print('x_train shape:', x_train.shape) 
print(x_train.shape[0], 'train samples') 
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, num_classes) 
y_test = keras.utils.to_categorical(y_test, num_classes)

Passaggio 3

Compilare il modello e adattare il modello nel modello di rete neurale convenzionale citato come mostrato di seguito -

model.compile(loss = 
keras.losses.categorical_crossentropy, 
optimizer = keras.optimizers.Adadelta(), metrics = 
['accuracy'])
model.fit(x_train, y_train, 
batch_size = batch_size, epochs = epochs, 
verbose = 1, validation_data = (x_test, y_test)) 
score = model.evaluate(x_test, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

L'output generato è il seguente:

In questo capitolo capiremo il famoso modello di incorporamento di parole: word2vec. Il modello Word2vec viene utilizzato per produrre word embedding con l'aiuto di un gruppo di modelli correlati. Il modello Word2vec è implementato con puro codice C e il gradiente viene calcolato manualmente.

L'implementazione del modello word2vec in PyTorch è spiegata nei passaggi seguenti:

Passo 1

Implementa le librerie nell'incorporamento di parole come indicato di seguito:

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

Passo 2

Implementa il modello Skip Gram di word embedding con la classe denominata word2vec. Includeemb_size, emb_dimension, u_embedding, v_embedding tipo di attributi.

class SkipGramModel(nn.Module):
   def __init__(self, emb_size, emb_dimension):
      super(SkipGramModel, self).__init__()
      self.emb_size = emb_size
      self.emb_dimension = emb_dimension
      self.u_embeddings = nn.Embedding(emb_size, emb_dimension, sparse=True)
      self.v_embeddings = nn.Embedding(emb_size, emb_dimension, sparse = True)
      self.init_emb()
   def init_emb(self):
      initrange = 0.5 / self.emb_dimension
      self.u_embeddings.weight.data.uniform_(-initrange, initrange)
      self.v_embeddings.weight.data.uniform_(-0, 0)
   def forward(self, pos_u, pos_v, neg_v):
      emb_u = self.u_embeddings(pos_u)
      emb_v = self.v_embeddings(pos_v)
      score = torch.mul(emb_u, emb_v).squeeze()
      score = torch.sum(score, dim = 1)
      score = F.logsigmoid(score)
      neg_emb_v = self.v_embeddings(neg_v)
      neg_score = torch.bmm(neg_emb_v, emb_u.unsqueeze(2)).squeeze()
      neg_score = F.logsigmoid(-1 * neg_score)
      return -1 * (torch.sum(score)+torch.sum(neg_score))
   def save_embedding(self, id2word, file_name, use_cuda):
      if use_cuda:
         embedding = self.u_embeddings.weight.cpu().data.numpy()
      else:
         embedding = self.u_embeddings.weight.data.numpy()
      fout = open(file_name, 'w')
      fout.write('%d %d\n' % (len(id2word), self.emb_dimension))
      for wid, w in id2word.items():
         e = embedding[wid]
         e = ' '.join(map(lambda x: str(x), e))
         fout.write('%s %s\n' % (w, e))
def test():
   model = SkipGramModel(100, 100)
   id2word = dict()
   for i in range(100):
      id2word[i] = str(i)
   model.save_embedding(id2word)

Passaggio 3

Implementa il metodo principale per visualizzare il modello di incorporamento delle parole in modo corretto.

if __name__  ==  '__main__':
   test()

Le reti neurali profonde hanno una funzione esclusiva per consentire scoperte rivoluzionarie nell'apprendimento automatico che comprende il processo del linguaggio naturale. Si è osservato che la maggior parte di questi modelli tratta il linguaggio come una sequenza piatta di parole o caratteri e utilizza un tipo di modello che viene indicato come rete neurale ricorrente o RNN.

Molti ricercatori giungono alla conclusione che il linguaggio è meglio compreso rispetto all'albero gerarchico delle frasi. Questo tipo è incluso nelle reti neurali ricorsive che tengono conto di una struttura specifica.

PyTorch ha una caratteristica specifica che aiuta a rendere molto più semplici questi complessi modelli di elaborazione del linguaggio naturale. È un framework completo per tutti i tipi di apprendimento profondo con un forte supporto per la visione artificiale.

Caratteristiche della rete neurale ricorsiva

• Una rete neurale ricorsiva viene creata in modo tale da includere l'applicazione dello stesso insieme di pesi con diverse strutture simili a grafici.

• I nodi vengono attraversati in ordine topologico.

• Questo tipo di rete è addestrato dalla modalità inversa della differenziazione automatica.

• L'elaborazione del linguaggio naturale include un caso speciale di reti neurali ricorsive.

• Questa rete di tensori neurali ricorsivi include vari nodi funzionali di composizione nell'albero.

L'esempio di rete neurale ricorsiva è dimostrato di seguito: