PyTorch vs TensorFlow quale è meglio per creare modelli di deep learning

 In questo articolo ti guideremo e confronteremo l'usabilità del codice e la facilità d'uso di TensorFlow e PyTorch sul set di dati MNIST più utilizzato per classificare le cifre scritte a mano.
 

 Due delle librerie di deep learning basate su Python più popolari sono PyTorch e TensorFlow. Potrebbe essere difficile per un professionista del machine learning alle prime armi decidere quale utilizzare quando si lavora con un modello di deep learning. Potresti essere completamente inconsapevole delle distinzioni, rendendo impossibile per te prendere una decisione informata. Esamineremo alcune di queste differenze nella pratica in questo articolo creando un classificatore utilizzando entrambi i framework per la stessa risoluzione dei problemi. Infine, concluderemo come i modelli simili definiti per affrontare lo stesso problema ma che utilizzano infrastrutture diverse differiscono nei risultati. I punti principali da trattare in questo articolo sono elencati di seguito.

 Indice Articolo

Il set di dati Modified National Institute of Standards and Technology è l'acronimo di set di dati MNIST . È una raccolta di 60.000 piccole immagini quadrate in scala di grigi di singole cifre scritte a mano che vanno da 0 a 9. L'obiettivo è ordinare un'immagine di una cifra scritta a mano in una delle dieci classi che rappresentano valori interi che vanno da 0 a 9, inclusi.
 È un set di dati ampiamente utilizzato e ben compreso che è stato risolto per la maggior parte. Le reti neurali convoluzionali di deep learning sono i modelli con le prestazioni migliori, con un'accuratezza di classificazione di oltre il 99% e un tasso di errore compreso tra lo 0,4% e lo 0,2% sul set di dati del test di tenuta. Gli esempi riportati di seguito provengono dal set di dati di addestramento delle cifre MNIST caricate dall'API del set di dati Tensorflow.
 

 Google ha sviluppato TensorFlow, che è stato reso open source nel 2015. Si è evoluto dal software di apprendimento automatico interno di Google, che è stato rifattorizzato e ottimizzato per l'uso in produzione.
 Il termine "TensorFlow" si riferisce al modo in cui i dati sono organizzati ed elaborati. Un tensore è la struttura dati più basilare sia in TensorFlow che in PyTorch. Quando usi TensorFlow, crei un grafico del flusso di dati con stato, simile a un diagramma di flusso che ricorda gli eventi passati, per eseguire operazioni sui dati in questi tensori.
 TensorFlow è noto per essere una libreria di deep learning ad alte prestazioni. Ha una base di utenti ampia e attiva, oltre a una pletora di modelli, strumenti e piattaforme di formazione, distribuzione e servizio ufficiali e di terze parti.

 PyTorch è uno dei framework di deep learning più recenti, sviluppato dal team di Facebook e rilasciato su GitHub nel 2017. PyTorch sta guadagnando popolarità grazie alla sua facilità d'uso, semplicità, grafico computazionale dinamico e utilizzo efficiente della memoria. È imperativo, il che significa che viene eseguito immediatamente e l'utente può testarlo per vedere se funziona prima di scrivere l'intero codice.
 Possiamo scrivere una sezione di codice ed eseguirla in tempo reale perché ha un'implementazione Python integrata per fornire compatibilità come piattaforma di deep learning. Ha rapidamente guadagnato popolarità grazie alla sua interfaccia intuitiva, spingendo il team di Tensorflow a incorporare le sue funzionalità più popolari in Tensorflow 2.0.

 In questa sezione, confronteremo l'usabilità del codice e la facilità d'uso di TensorFlow e PyTorch sul set di dati MNIST più utilizzato per classificare le cifre scritte a mano. Utilizzando entrambi i framework verificheremo le procedure minime da eseguire per avere un modello di classificazione adeguato. In entrambi i passaggi del modello da eseguire sono il caricamento dei dati, la preelaborazione, la creazione del modello, l'addestramento e la visualizzazione del risultato. Per entrambi i modelli, ho cercato di mantenere i livelli e le configurazioni di iperparametri uguali tra loro.
 Quindi ora iniziamo prima con Tensorflow.

 Costruiamo un modello di rete neurale convoluzionale per la classificazione delle immagini in TensorFlow.

 import tensorflow
 from tensorflow.keras.datasets import mnist
 from tensorflow.keras.utils import to_categorical
 from tensorflow.keras.layers import Conv2D, Flatten, Dense, MaxPooling2D
 from tensorflow.keras.models import Sequential
 import matplotlib.pyplot as plt

 Carica e preelabora i dati. Qui la preelaborazione non è altro che rimodellare le immagini da 28 x 28 a 28 x 28 x 1 i, abbiamo aggiunto il canale del colore e 1 indica il canale del grigio. Successivamente, abbiamo creato una rappresentazione binaria di ciascuna classe e, infine, abbiamo ridimensionato tutti i valori dei pixel.

 # Rimodelliamo e codifichiamo con onehot
 x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
 x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
 y_train = to_categorical(y_train)
 y_test = to_categorical(y_test)
 
 # scaling
 x_train = x_train.astype('float32')
 x_test = x_test.astype('float32')
 x_train = x_train / 255.0
 x_test = x_test / 255.0

 Successivamente, costruiremo un modello. Questo modello sarà composto da 2 strati convoluzionali seguiti da uno strato di pooling e un classificatore Dense. La discesa del gradiente stocastico viene utilizzata come funzione di ottimizzazione con un tasso di apprendimento di 0,01 e l'entropia incrociata categoriale come funzione di perdita, il modello viene addestrato per 5 epoche. E questo viene mantenuto anche nel modello Pytorch.

 model = Sequential()
 model.add(Conv2D(32, (3,3), input_shape = (28,28,1), activation='relu'))
 model.add(Conv2D(64,(3,3), activation='relu'))
 model.add(MaxPooling2D((2,2)))
 model.add(Flatten())
 model.add(Dense(1024, activation='relu'))
 model.add(Dense(10, activation='softmax'))
 # Compiliamo
 model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
 
 # Alleniamo
 history = model.fit(x_train, y_train, validation_split=0.3, epochs=5)
 

 Fino a questo, questo è tutto il lavoro minimo richiesto per costruire un classificatore di immagini usando TensorFlow.

 Costruiamo un modello di rete neurale convoluzionale per la classificazione delle immagini in PyTorch.

#importiamo le librerie
 import torch
 import torch.nn as nn
 import torch.optim as optim
 import torch.nn.functional as F
 
 from torchvision import datasets, transforms
 
 # preprocessiamo
 transform = transforms.Compose([
  transforms.Resize((8, 8)),
  transforms.ToTensor(),
  transforms.Normalize((0.1307,), (0.3081,))])
 
 # carichiamo i dati
 train_dataset = datasets.MNIST(
  'data', train=True, download=True, transform=transform)
 test_dataset = datasets.MNIST(
  'data', train=False, download=True, transform=transform)
 
 train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=512)
 test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=512)
 
 # Costruisci un modello
 class CNNModel(nn.Module):
  def __init__(self):
  super(CNNModel, self).__init__()
  self.conv1 = nn.Conv2d(1, 32, 3, 1)
  self.conv2 = nn.Conv2d(32, 64, 3, 1)
  self.fc = nn.Linear(1024, 10)
 
  def forward(self, x):
  x = F.relu(self.conv1(x))
  x = F.relu(self.conv2(x))
  x = F.max_pool2d(x, 1)
  x = torch.flatten(x, 1)
  x = self.fc(x)
  output = F.log_softmax(x, dim=1)
  return output
 net = CNNModel()
 
 # Compiliamo
 optimizer = optim.SGD(net.parameters(), lr=0.01)
 criterion = nn.CrossEntropyLoss()

 Dopodiché, durante la fase di addestramento, dobbiamo creare un ciclo che ripercorre le nostre epoche e lotti. Elaboreremo le nostre immagini di conseguenza e utilizzeremo il passaggio in avanti per calcolare la nostra perdita.

 Dai due grafici precedenti, la curva del modello TensorFlow sembra ripida e dopo la 3a epoca, la perdita sul set di convalida sembra aumentare. In breve, possiamo dire che la procedura di apprendimento nel modello TensorFlow è di natura ripida e possiamo aspettarci molti compromessi.

 Mentre nel modello PyTorch, anche la procedura di costruzione del modello sembra complessa, l'addestramento e la perdita osservati sono stati fluidi durante la procedura e la perdita di convalida ha seguito correttamente la perdita del test.

A questo punto, abbiamo discusso brevemente TensorFlow e PyTorch e visto la procedura di modellazione minima per la classificazione delle immagini. Nel contesto dell'allenamento e delle prestazioni dei test dai due rispettivi grafici, possiamo dire che il processo di addestramento e valutazione è più fluido nel modello PyTorch e, in termini di elementi costitutivi, direi che TensorFlow è più adatto ai principianti grazie alla sua API semplificata .