Prétraitement des données : Ce que vous faites aux données avant de les alimenter au modèle.
— Une définition easy qui, en pratique, laisse ouvertes de nombreuses questions. Où, exactement, le prétraitement doit-il s’arrêter et le modèle commencer ? Des étapes telles que la normalisation ou diverses transformations numériques font-elles partie du modèle ou du prétraitement ? Qu’en est-il de l’augmentation des données ? En somme, la ligne entre ce qui est du pré-traitement et ce qui est de la modélisation a toujours, sur les bords, semblé quelque peu fluide.
Dans cette state of affairs, l’avènement de keras les couches de prétraitement modifient une picture familière depuis longtemps.
Concrètement, avec keras, deux options avaient tendance à prévaloir : l’une, faire les choses en amont, dans R ; et deux, pour construire un tfdatasets pipeline. Le premier s’appliquait chaque fois que nous avions besoin des données complètes pour extraire des informations sommaires. Par exemple, lors de la normalisation à une moyenne de zéro et un écart kind de un. Mais souvent, cela signifiait que nous devions effectuer des allers-retours entre les variations normalisées et non normalisées à plusieurs moments du flux de travail. Le tfdatasets l’approche, en revanche, était élégante ; cependant, cela pourrait nécessiter d’écrire beaucoup de bas niveau tensorflow code.
Couches de prétraitement, disponibles à partir de keras model 2.6.1, supprime le besoin d’opérations R initiales et s’intègre parfaitement avec tfdatasets. Mais ce n’est pas tout. Dans cet article, nous voulons souligner quatre features essentiels :
- Les couches de prétraitement réduisent considérablement l’effort de codage. Toi pourrait coder ces opérations vous-même ; mais ne pas avoir à le faire permet de gagner du temps, favorise le code modulaire et aide à éviter les erreurs.
- Les couches de prétraitement – un sous-ensemble d’entre elles, pour être précis – peuvent produire des informations récapitulatives avant la formation proprement dite et utiliser un état enregistré lorsqu’elles sont appelées ultérieurement.
- Les couches de prétraitement peuvent accélérer la formation.
- Les couches de prétraitement font ou peuvent être intégrées au modèle, éliminant ainsi la nécessité d’implémenter des procédures de prétraitement indépendantes dans l’environnement de déploiement.
Après une courte introduction, nous développerons chacun de ces factors. Nous concluons avec deux exemples de bout en bout (impliquant photos et texterespectivement) qui illustrent bien ces quatre features.
Les couches de prétraitement en bref
Comme les autres keras couches, celles dont nous parlons ici commencent toutes par layer_, et peuvent être instanciés indépendamment du modèle et du pipeline de données. Ici, nous créons un calque qui fera pivoter les photos de manière aléatoire pendant l’entraînement, jusqu’à 45 degrés dans les deux sens :
Une fois que nous avons une telle couche, nous pouvons immédiatement la tester sur une picture factice.
tf.Tensor(
((1. 0. 0. 0. 0.)
(0. 1. 0. 0. 0.)
(0. 0. 1. 0. 0.)
(0. 0. 0. 1. 0.)
(0. 0. 0. 0. 1.)), form=(5, 5), dtype=float32)« Tester la couche » signifie désormais littéralement l’appeler comme une fonction:
tf.Tensor(
((0. 0. 0. 0. 0. )
(0.44459596 0.32453176 0.05410459 0. 0. )
(0.15844001 0.4371609 1. 0.4371609 0.15844001)
(0. 0. 0.05410453 0.3245318 0.44459593)
(0. 0. 0. 0. 0. )), form=(5, 5), dtype=float32)Une fois instanciée, une couche peut être utilisée de deux manières. Tout d’abord, dans le cadre du pipeline d’entrée.
En pseudo-code :
# pseudocode
library(tfdatasets)
train_ds <- ... # outline dataset
preprocessing_layer <- ... # instantiate layer
train_ds <- train_ds %>%
dataset_map(perform(x, y) checklist(preprocessing_layer(x), y))Deuxièmement, la manière qui semble la plus naturelle, pour un couche: en tant que couche à l’intérieur du modèle. Schématiquement :
# pseudocode
enter <- layer_input(form = input_shape)
output <- enter %>%
preprocessing_layer() %>%
rest_of_the_model()
mannequin <- keras_model(enter, output)En fait, ce dernier semble si évident que vous vous demandez peut-être : Pourquoi même autoriser un tfdatasets-alternative intégrée ? Nous développerons cela sous peu, lorsque nous parlerons de efficiency.
Avec état couches – qui sont assez spéciales pour mériter leur propre rubrique – peuvent également être utilisés dans les deux sens, mais ils nécessitent une étape supplémentaire. Plus à ce sujet ci-dessous.
Remark les couches de prétraitement facilitent la vie
Des couches dédiées existent pour une multitude de tâches de transformation de données. Nous pouvons les regrouper en deux grandes catégories, l’ingénierie des fonctionnalités et l’augmentation des données.
Ingénierie des fonctionnalités
Le besoin d’ingénierie des fonctionnalités peut survenir avec tous les sorts de données. Avec les photos, nous n’utilisons normalement pas ce terme pour les opérations « piétonnes » qui sont nécessaires pour qu’un modèle les traite : redimensionnement, recadrage, and so forth. Pourtant, il y a des hypothèses cachées dans chacune de ces opérations , nous nous sentons donc justifiés dans notre catégorisation. Quoi qu’il en soit, les couches de ce groupe incluent layer_resizing(), layer_rescaling()et layer_center_crop().
Avec le texte, la seule fonctionnalité dont nous ne pourrions pas nous passer est la vectorisation. layer_text_vectorization() s’en occupe pour nous. Nous rencontrerons cette couche dans la part suivante, ainsi que dans la deuxième exemple de code complet.
Passons maintenant à ce qui est normalement considéré comme le domaine de l’ingénierie des fonctionnalités : données numériques et catégorielles (on pourrait dire : « feuille de calcul »).
Premièrement, les données numériques doivent souvent être normalisées pour que les réseaux de neurones fonctionnent bien – pour y parvenir, utilisez layer_normalization(). Ou peut-être y a-t-il une raison pour laquelle nous aimerions mettre des valeurs continues dans des catégories discrètes. Ce serait une tâche pour layer_discretization().
Deuxièmement, les données catégorielles se présentent sous différents codecs (chaînes, nombres entiers…), et il y a toujours quelque selected cela doit être fait afin de les traiter de manière significative. Souvent, vous souhaiterez les intégrer dans un espace de dimension supérieure, en utilisant layer_embedding(). Désormais, les couches d’intégration s’attendent à ce que leurs entrées soient des nombres entiers ; pour être précis : entiers consécutifs. Ici, les couches à rechercher sont layer_integer_lookup() et layer_string_lookup(): Ils convertiront des entiers aléatoires (chaînes, respectivement) en valeurs entières consécutives. Dans un scénario différent, il pourrait y avoir trop de catégories pour permettre l’extraction d’informations utiles. Dans de tels cas, utilisez layer_hashing() pour biner les données. Et enfin, il y a layer_category_encoding() pour produire les représentations classiques one-hot ou multi-hot.
Augmentation des données
Dans la deuxième catégorie, on trouve des couches qui exécutent (configurable) opérations aléatoires sur les photos. Pour n’en nommer que quelques-uns : layer_random_crop(), layer_random_translation(), layer_random_rotation() … Ceux-ci sont pratiques non seulement en ce qu’ils implémentent les fonctionnalités de bas niveau requises ; lorsqu’ils sont intégrés dans un modèle, ils sont également sensibles au flux de travail : toutes les opérations aléatoires seront exécutées uniquement pendant la formation.
Maintenant que nous avons une idée de ce que ces couches font pour nous, concentrons-nous sur le cas spécifique des couches préservant l’état.
Couches de prétraitement qui conservent l’état
Une couche qui perturbe aléatoirement les photos n’a pas besoin de savoir quoi que ce soit sur les données. Il doit juste suivre une règle : avec probabilité (p)faire (X). Un calque censé vectoriser du texte, en revanche, doit avoir une desk de correspondance, faisant correspondre les chaînes de caractères aux entiers. Il en va de même pour une couche qui mappe des entiers contingents à un ensemble ordonné. Et dans les deux cas, la desk de recherche doit être créée à l’avance.
Avec les couches avec état, cette accumulation d’informations est déclenchée en appelant adapt() sur une occasion de couche fraîchement créée. Par exemple, ici, nous instancions et « conditionnons » une couche qui mappe des chaînes sur des entiers consécutifs :
colours <- c("cyan", "turquoise", "celeste");
layer <- layer_string_lookup()
layer %>% adapt(colours)Nous pouvons vérifier ce qu’il y a dans la desk de recherche :
(1) "(UNK)" "turquoise" "cyan" "celeste" Ensuite, l’appel de la couche encodera les arguments :
layer(c("azure", "cyan"))tf.Tensor((0 2), form=(2,), dtype=int64)layer_string_lookup() fonctionne sur des chaînes de caractères individuelles et, par conséquent, est la transformation adéquate pour les caractéristiques catégorielles à valeur de chaîne. Pour encoder des phrases entières (ou des paragraphes, ou des morceaux de texte) vous utiliseriez layer_text_vectorization() plutôt. Nous verrons remark cela fonctionne dans notre deuxième exemple de bout en bout.
Utilisation des couches de prétraitement pour les performances
Ci-dessus, nous avons dit que les couches de prétraitement pouvaient être utilisées de deux manières : dans le cadre du modèle ou dans le cadre du pipeline d’entrée de données. Si ce sont couchespourquoi même autoriser la deuxième voie ?
La raison principale est la efficiency. Les GPU sont parfaits pour les opérations matricielles régulières, telles que celles impliquées dans la manipulation d’photos et les transformations de données numériques de forme uniforme. Par conséquent, si vous avez un GPU sur lequel vous entraîner, il est préférable d’avoir des couches de traitement d’picture, ou des couches telles que layer_normalization()faire partie du modèle (qui est entièrement exécuté sur GPU).
D’autre half, les opérations impliquant du texte, telles que layer_text_vectorization(), sont mieux exécutés sur le CPU. Il en va de même si aucun GPU n’est disponible pour l’entraînement. Dans ces cas, vous déplaceriez les couches vers le pipeline d’entrée et vous vous efforceriez de bénéficier d’un traitement parallèle – sur le processeur. Par exemple:
# pseudocode
preprocessing_layer <- ... # instantiate layer
dataset <- dataset %>%
dataset_map(~checklist(text_vectorizer(.x), .y),
num_parallel_calls = tf$knowledge$AUTOTUNE) %>%
dataset_prefetch()
mannequin %>% match(dataset)En conséquence, dans les exemples de bout en bout ci-dessous, vous verrez l’augmentation des données d’picture se produire dans le cadre du modèle, et la vectorisation du texte, dans le cadre du pipeline d’entrée.
Exportation d’un modèle, complet avec prétraitement
Supposons que pour l’entraînement de votre modèle, vous avez trouvé que le tfdatasets chemin était le meilleur. Maintenant, vous le déployez sur un serveur sur lequel R n’est pas installé. Il semblerait que vous deviez implémenter le prétraitement dans une autre technologie disponible. Alternativement, vous devrez compter sur les utilisateurs qui envoient des données déjà prétraitées.
Heureusement, vous pouvez faire autre selected. Créez un nouveau modèle spécifiquement pour l’inférence, comme ceci :
# pseudocode
enter <- layer_input(form = input_shape)
output <- enter %>%
preprocessing_layer(enter) %>%
training_model()
inference_model <- keras_model(enter, output)Cette approach utilise la API fonctionnelle pour créer un nouveau modèle qui ajoute la couche de prétraitement au modèle authentic sans prétraitement.
Après s’être concentré sur quelques petites choses surtout « bonnes à savoir », on conclut maintenant avec les exemples promis.
Exemple 1 : Augmentation des données d’picture
Notre premier exemple illustre l’augmentation des données d’picture. Trois sorts de transformations sont regroupés, ce qui les fait ressortir clairement dans la définition globale du modèle. Ce groupe de calques sera actif pendant l’entraînement uniquement.
library(keras)
library(tfdatasets)
# Load CIFAR-10 knowledge that include keras
c(c(x_train, y_train), ...) %<-% dataset_cifar10()
input_shape <- dim(x_train)(-1) # drop batch dim
lessons <- 10
# Create a tf_dataset pipeline
train_dataset <- tensor_slices_dataset(checklist(x_train, y_train)) %>%
dataset_batch(16)
# Use a (non-trained) ResNet structure
resnet <- application_resnet50(weights = NULL,
input_shape = input_shape,
lessons = lessons)
# Create a knowledge augmentation stage with horizontal flipping, rotations, zooms
data_augmentation <-
keras_model_sequential() %>%
layer_random_flip("horizontal") %>%
layer_random_rotation(0.1) %>%
layer_random_zoom(0.1)
enter <- layer_input(form = input_shape)
# Outline and run the mannequin
output <- enter %>%
layer_rescaling(1 / 255) %>% # rescale inputs
data_augmentation() %>%
resnet()
mannequin <- keras_model(enter, output) %>%
compile(optimizer = "rmsprop", loss = "sparse_categorical_crossentropy") %>%
match(train_dataset, steps_per_epoch = 5)Exemple 2 : vectorisation de texte
Dans le traitement du langage naturel, nous utilisons souvent des couches d’intégration pour présenter les couches « cheval de bataille » (récurrentes, convolutives, auto-attentionnelles, and so forth.) avec l’entrée proceed et dimensionnée de manière optimale dont elles ont besoin. Les couches d’intégration s’attendent à ce que les jetons soient encodés sous forme d’entiers, et transformer le texte en entiers est ce que layer_text_vectorization() fait.
Notre deuxième exemple illustre le flux de travail : vous demandez à la couche d’apprendre le vocabulaire à l’avance, puis de l’appeler dans le cadre du pipeline de prétraitement. Une fois la formation terminée, nous créons un modèle « tout compris » de déploiement.
library(tensorflow)
library(tfdatasets)
library(keras)
# Instance knowledge
textual content <- as_tensor(c(
"From every in keeping with his potential, to every in keeping with his wants!",
"Act that you just use humanity, whether or not in your personal individual or within the individual of every other, all the time similtaneously an finish, by no means merely as a way.",
"Purpose is, and ought solely to be the slave of the passions, and might by no means fake to every other workplace than to serve and obey them."
))
# Create and adapt layer
text_vectorizer <- layer_text_vectorization(output_mode="int")
text_vectorizer %>% adapt(textual content)
# Test
as.array(text_vectorizer("To every in keeping with his wants"))
# Create a easy classification mannequin
enter <- layer_input(form(NULL), dtype="int64")
output <- enter %>%
layer_embedding(input_dim = text_vectorizer$vocabulary_size(),
output_dim = 16) %>%
layer_gru(8) %>%
layer_dense(1, activation = "sigmoid")
mannequin <- keras_model(enter, output)
# Create a labeled dataset (which incorporates unknown tokens)
train_dataset <- tensor_slices_dataset(checklist(
c("From every in keeping with his potential", "There may be nothing larger than motive."),
c(1L, 0L)
))
# Preprocess the string inputs
train_dataset <- train_dataset %>%
dataset_batch(2) %>%
dataset_map(~checklist(text_vectorizer(.x), .y),
num_parallel_calls = tf$knowledge$AUTOTUNE)
# Prepare the mannequin
mannequin %>%
compile(optimizer = "adam", loss = "binary_crossentropy") %>%
match(train_dataset)
# export inference mannequin that accepts strings as enter
enter <- layer_input(form = 1, dtype="string")
output <- enter %>%
text_vectorizer() %>%
mannequin()
end_to_end_model <- keras_model(enter, output)
# Take a look at inference mannequin
test_data <- as_tensor(c(
"To every in keeping with his wants!",
"Purpose is, and ought solely to be the slave of the passions."
))
test_output <- end_to_end_model(test_data)
as.array(test_output)Conclure
Avec ce billet, notre objectif était d’attirer l’consideration sur keras‘ nouvelles couches de prétraitement, et montrer remark – et pourquoi – elles sont utiles. De nombreux autres cas d’utilisation peuvent être trouvés dans le vignette.
Merci d’avoir lu!
picture par Henning Borgersen sur Unsplash
