Pytorch ou Keras: quelles différences?

Mis à jour le Oct. 2, 2022, 7:26 a.m.

Il n'y a pas de vainqueur incontestable entre Pytorch et Keras. Les deux frameworks ont leurs avantages et leurs inconvénients. Pytorch est plus flexible et plus facile à déboguer, tandis que Keras est plus simple et plus facile à utiliser. Il est important de choisir le bon framework pour la tâche à accomplir.

1- Pytorch vs Keras
2- Un réseau de neurone en Keras
3- Un réseau de neurone en Pytorch
4- En résumé

Pytorch vs Keras

Si vous commencez à explorer l'apprentissage profond, vous devriez d'abord apprendre PyTorch en raison de sa popularité dans la communauté des chercheurs. Cependant, si vous êtes familier avec l'apprentissage automatique et l'apprentissage profond et que vous souhaitez obtenir un emploi dans le secteur le plus rapidement possible, apprenez d'abord TensorFlow.

Examinons maintenant les différences entre PyTorch et Keras.

Keras est une bibliothèque de haut niveau qui s'appuie sur TensorFlow, Theano et CNTK. Elle est conçue pour simplifier la création de modèles d'apprentissage profond.
Pytorch, quant à elle, est une bibliothèque de plus bas niveau qui vous permet de créer des architectures personnalisées avec plus de flexibilité.

Keras et PyTorch diffèrent par le niveau d'abstraction auquel ils opèrent.
Keras est une librairie de plus haut niveau qui regroupe les couches et les opérations d'apprentissage profond couramment utilisées dans des blocs de construction, ce qui permet d'abstraire les complexités de l'apprentissage profond.
PyTorch offre un environnement d'expérimentation de plus bas niveau, donnant à l'utilisateur plus de liberté pour écrire des couches personnalisées et regarder sous le capot des tâches d'optimisation numérique. Le développement d'architectures plus complexes est plus simple lorsque vous pouvez utiliser toute la puissance de Python et accéder aux entrailles de toutes les fonctions utilisées. Naturellement, cela se fait au prix de la verbosité.

Réseau de neurone avec Keras:

model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(MaxPool2D())
model.add(Conv2D(16, (3, 3), activation='relu'))
model.add(MaxPool2D())
model.add(Flatten())
model.add(Dense(10, activation='softmax'))

Petite explication:

La première ligne instancie un modèle. Cela signifie que nous allons ajouter des couches au modèle séquentiellement. Un modèle séquentiel est une pile (stack) de couches de reseaux de neurones, où chaque couche a exactement un tenseur d'entrée et un tenseur de sortie. Chaque couche reçoit le tenseur de sortie de la couche précédente comme entrée et produit un tenseur de sortie qui est ensuite utilisé comme entrée pour la couche suivante. Cela fonctionne bien lorsque le flux de données suit une séquence linéaire, où chaque couche traite les informations provenant de la couche précédente sans qu'il y ait de branchements ou de connexions complexes entre les différentes couches. Nous verrons qu'il existe d'autres type d'implémentations possibles pour les réseaux de neurones.

Avec la deuxieme ligne nous ajoutons une couche Conv2D avec 32 filtres, une taille de kernel de (3, 3) et une fonction d'activation 'RELU'. Cette couche est utilisée pour extraire les caractéristiques des images d'entrée. L'argument input_shape=(32, 32, 3) spécifie la taille attendue des images d'entrée.

Ensuite, nous ajoutons une couche MaxPool2D qui effectue une opération de pooling pour réduire la dimensionnalité des caractéristiques extraites par la couche précédente.

Puis nous ajoutons une autre couche Conv2D avec 16 filtres et une taille de noyau de (3, 3) avec une fonction d'activation 'relu'. Cette couche continue d'extraire des caractéristiques plus complexes des données.

Nous ajoutons ensuite une autre couche MaxPool2D pour réduire davantage la dimensionnalité des caractéristiques.

La dernière couche, Flatten, est utilisée pour "aplatir" les caractéristiques en un vecteur 1D, de sorte qu'elles puissent être "mangées" par notre classifieur, une couche de type 'Dense'
Ensuite, nous ajoutons une couche Dense avec 10 neurones et une fonction d'activation 'softmax'. Cette couche est utilisée pour la classification des données et la fonction d'activation softmax permettra d'attribuer des probabilités à chaque classe.

Réseau de neurone avec Pytorch:

Voyons exactement le même réseau de neurone en Pytorch.

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.conv2 = nn.Conv2d(32, 16, 3)
        self.fc1 = nn.Linear(16 * 6 * 6, 10)
        self.pool = nn.MaxPool2d(2, 2)
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 6 * 6)
        x = F.log_softmax(self.fc1(x), dim=-1)
        return x
model = Net()

La première ligne définit une classe appelée "Net" qui hérite de la classe "nn.Module" de PyTorch. Cette classe représente notre modèle.

Dans la méthode "init", on initialise le modèle en définissant les différentes couches. Le modèle comprend deux couches de convolution : "conv1" qui prend en entrée 3 canaux (RVB) et produit 32 canaux en utilisant un kernel de taille 3x3, et "conv2" qui prend en entrée 32 canaux et produit 16 canaux en utilisant également un kernel de taille 3x3. On définit également une couche linéaire "fc1" qui prend en entrée les caractéristiques aplaties du dernier canal convolutif et produit 10 sorties. On utilise également une couche de pooling "pool" qui effectue une opération de pooling avec une taille de kernel de 2x2 et un pas de 2.

La méthode "forward" définit la propagation avant (forward pass) du modèle. Elle prend en entrée un tenseur "x" représentant les données d'entrée. Le tenseur "x" passe d'abord par la première couche de convolution "conv1", puis par une fonction d'activation "ReLU" et enfin par la couche de pooling "pool". Ensuite, le tenseur passe par la deuxième couche de convolution "conv2", la fonction d'activation "ReLU" et la couche de pooling "pool" à nouveau. Ensuite, le tenseur est aplati en un vecteur à l'aide de la fonction "view". Ce vecteur est ensuite alimenté dans la couche linéaire "fc1" et la fonction "log_softmax" est appliquée sur les sorties. Finalement, le tenseur résultant est renvoyé en sortie.

Enfin, en dehors de la classe, le modèle est instancié en créant un objet de la classe "Net" appelé "model".

En résumé

PyTorch est une bibliothèque populaire et puissante pour l'apprentissage en profondeur.
- Il est apprécié pour sa flexibilité et sa facilité d'utilisation, ce qui en fait un bon choix pour les projets de recherche et les tâches complexes.
- Il offre une approche dynamique de la construction de modèles, ce qui signifie que les modèles peuvent être définis et modifiés facilement pendant l'exécution.
- Il dispose également d'une grande communauté de développeurs et de chercheurs, offrant un support et une documentation solides.

C'est la librairie à apprendre si vous voulez aller en profondeur.

Keras est une bibliothèque haut niveau (un wrapper) construite sur TensorFlow, une autre bibliothèque d'apprentissage en profondeur populaire.
- Il est réputé pour sa simplicité et sa convivialité, ce qui en fait un excellent choix pour les débutants en apprentissage en profondeur.
- Keras offre une interface conviviale et abstraite pour construire des modèles d'apprentissage en profondeur, ce qui facilite la création rapide de prototypes.
- Il dispose également d'une large gamme de modèles pré-entrainés et d'outils de visualisation intégrés.

En fin de compte, le choix entre PyTorch et Keras dépend des préférences personnelles, du niveau d'expérience en apprentissage en profondeur et des exigences spécifiques d'u projet. Il peut être utile de les essayer tous les deux pour voir lequel convient le mieux.