Keras 3 fournit une interface Python facile pour les réseaux de neurones artificiels

**Anthony** · 29/11/2023, 12h36

Keras 3, une API open-source d'apprentissage profond, fournit une interface Python facile pour les réseaux neuronaux artificiels, et peut fonctionner au-dessus de JAX, TensorFlow ou PyTorch

Après plusieurs mois de bêta-test public intensif, l'équipe de Keras est heureuse d'annoncer la sortie officielle de Keras 3.0. Keras 3 est une réécriture complète de Keras qui vous permet d'exécuter vos workflows Keras au-dessus de JAX, TensorFlow ou PyTorch, et qui débloque de toutes nouvelles capacités d'entraînement et de déploiement de modèles à grande échelle. Vous pouvez choisir le framework qui vous convient le mieux, et passer de l'un à l'autre en fonction de vos objectifs actuels. Vous pouvez également utiliser Keras comme un langage inter-framework de bas niveau pour développer des composants personnalisés tels que des couches, des modèles ou des métriques qui peuvent être utilisés dans des flux de travail natifs dans JAX, TensorFlow ou PyTorch - avec une seule base de code.

Keras est une API d'apprentissage profond écrite en Python et capable de fonctionner au-dessus de JAX, TensorFlow ou PyTorch. Keras est :

Simple - mais pas simpliste. Keras réduit la charge cognitive du développeur pour lui permettre de se concentrer sur les parties du problème qui comptent vraiment.
Flexible - Keras adopte le principe de divulgation progressive de la complexité : les flux de travail simples doivent être rapides et faciles, tandis que les flux de travail arbitrairement avancés doivent être possibles via un chemin clair qui s'appuie sur ce que vous avez déjà appris.
Puissant - Keras offre des performances et une évolutivité à la hauteur de l'industrie : il est utilisé par des organisations telles que la NASA, YouTube ou Waymo.

Keras 3 est une API d'apprentissage profond multi-framework

En tant qu'API multi-framework, Keras peut être utilisé pour développer des composants modulaires compatibles avec n'importe quel framework - JAX, TensorFlow, ou PyTorch. Cette approche présente plusieurs avantages majeurs :

Obtenez toujours les meilleures performances pour vos modèles. Dans les benchmarks, l'équipe de Keras a constaté que JAX fournit généralement les meilleures performances de formation et d'inférence sur GPU, TPU et CPU - mais les résultats varient d'un modèle à l'autre, car TensorFlow non-XLA est parfois plus rapide sur GPU. La possibilité de sélectionner dynamiquement le backend qui fournira la meilleure performance pour votre modèle sans avoir à modifier quoi que ce soit à votre code signifie que vous êtes toujours assuré de former et de servir avec la plus grande efficacité possible.
Maximisez la surface de l'écosystème disponible pour vos modèles. Tout modèle Keras peut être instancié en tant que module PyTorch, exporté en tant que SavedModel TensorFlow ou instancié en tant que fonction JAX sans état. Cela signifie que vous pouvez utiliser vos modèles Keras avec les packages de l'écosystème PyTorch, avec la gamme complète d'outils de déploiement et de production TensorFlow, et avec l'infrastructure d'entraînement TPU à grande échelle JAX. Écrivez un model.py en utilisant les API Keras et accédez à tout ce que le monde du ML a à offrir.
Optimisez la distribution de vos modèles open-source. Vous souhaitez publier un modèle pré-entraîné ? Vous voulez que le plus grand nombre possible de personnes puissent l'utiliser ? Si vous l'implémentez en TensorFlow ou PyTorch pur, il sera utilisable par environ la moitié du marché. Si vous l'implémentez dans Keras, il sera instantanément utilisable par n'importe qui, quel que soit le framework choisi (même s'il ne s'agit pas d'utilisateurs de Keras). Deux fois plus d'impact sans coût de développement supplémentaire.
Utilisez des pipelines de données provenant de n'importe quelle source. Les routines Keras fit()/evaluate()/predict() sont compatibles avec les objets tf.data.Dataset, avec les objets PyTorch DataLoader, avec les tableaux NumPy, les dataframes Pandas - quel que soit le backend que vous utilisez. Vous pouvez entraîner un modèle Keras + TensorFlow sur un DataLoader PyTorch ou entraîner un modèle Keras + PyTorch sur un Dataset tf.data.Dataset.

Premier contact avec Keras

Les structures de données centrales de Keras sont les couches et les modèles. Le type de modèle le plus simple est le modèle séquentiel, une pile linéaire de couches. Pour des architectures plus complexes, vous devriez utiliser l'API fonctionnelle de Keras, qui permet de construire des graphes arbitraires de couches, ou d'écrire des modèles entièrement à partir de zéro via la sous-classification.

Voici le modèle séquentiel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
import keras
 
model = keras.Sequential()

L'empilement des couches est aussi simple que .add() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
from keras import layers
 
model.add(layers.Dense(units=64, activation='relu'))
model.add(layers.Dense(units=10, activation='softmax'))

Une fois que votre modèle semble bon, configurez son processus d'apprentissage avec .compile() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
model.compile(loss='categorical_crossentropy',
              optimizer='sgd',
              metrics=['accuracy'])

Si nécessaire, vous pouvez configurer davantage votre optimiseur. La philosophie de Keras est de garder les choses simples, tout en permettant à l'utilisateur d'avoir un contrôle total lorsqu'il en a besoin (le contrôle ultime étant l'extensibilité facile du code source via la sous-classification).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.SGD(learning_rate=0.01, momentum=0.9, nesterov=True))

Vous pouvez maintenant itérer par lots sur vos données d'entraînement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
# x_train and y_train are Numpy arrays
model.fit(x_train, y_train, epochs=5, batch_size=32)

Évaluer votre perte de test et les métriques en une seule ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

Ou générer des prédictions sur de nouvelles données :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

classes = model.predict(x_test, batch_size=128)

Ce que vous venez de voir est la manière la plus élémentaire d'utiliser Keras.

Cependant, Keras est également un framework très flexible qui permet d'itérer sur des idées de recherche à la pointe de l'état de l'art. Keras suit le principe de la divulgation progressive de la complexité : il est facile de commencer, mais il permet de traiter des cas d'utilisation arbitrairement avancés, en ne nécessitant qu'un apprentissage incrémental à chaque étape.

De la même manière que vous avez pu former et évaluer un réseau neuronal simple en quelques lignes, vous pouvez utiliser Keras pour développer rapidement de nouvelles procédures de formation ou des architectures de modèles à la pointe de la technologie.

Voici un exemple de couche Keras personnalisée, qui peut être utilisée dans des flux de travail de bas niveau dans JAX, TensorFlow ou PyTorch, de manière interchangeable :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import keras
from keras import ops
 
class TokenAndPositionEmbedding(keras.Layer):
    def __init__(self, max_length, vocab_size, embed_dim):
        super().__init__()
        self.token_embed = self.add_weight(
            shape=(vocab_size, embed_dim),
            initializer="random_uniform",
            trainable=True,
        )
        self.position_embed = self.add_weight(
            shape=(max_length, embed_dim),
            initializer="random_uniform",
            trainable=True,
        )
 
    def call(self, token_ids):
        # Embed positions
        length = token_ids.shape[-1]
        positions = ops.arange(0, length, dtype="int32")
        positions_vectors = ops.take(self.position_embed, positions, axis=0)
        # Embed tokens
        token_ids = ops.cast(token_ids, dtype="int32")
        token_vectors = ops.take(self.token_embed, token_ids, axis=0)
        # Sum both
        embed = token_vectors + positions_vectors
        # Normalize embeddings
        power_sum = ops.sum(ops.square(embed), axis=-1, keepdims=True)
        return embed / ops.sqrt(ops.maximum(power_sum, 1e-7))