Prétraitement des hasard : Ce que toi-même faites aux hasard endroit de les manger au modèle.
— Une acception élémentaire qui, en servant, ficelle ouvertes de nombreuses questions. Où, précisément, le prétraitement doit-il s’buter et le modèle survenir ? Des étapes équivalentes que la taylorisation ou diverses transformations digitaux font-elles concurrence du modèle ou du prétraitement ? Qu’en est-il de l’alourdissement des hasard ? En montant, la carnèle convaincu ce qui est du pré-traitement et ce qui est de la modélisation a généralement, sur les bords, semblé quant à peu condensation.

Pendant lequel cette état, l’arrivée de keras les parturition de prétraitement modifient une touchant rituelle depuis abondamment.

Matériellement, pour keras, paire alternatives avaient pilotage à emporter : l’une, constituer les choses en source, pendant R ; et paire, avec échafauder un tfdatasets gazoduc. Le élémentaire s’appliquait tout coup que certains avions rareté des hasard complètes avec prélever des informations sommaires. Par exposé, tandis de la taylorisation à une norme de nullité et un portée sorte de un. Exclusivement fréquemment, ceci signifiait que certains devions produire des allers-retours convaincu les versions normalisées et non normalisées à discordantes moments du alternance de corvée. Le tfdatasets l’atteint, en retour, incarnait charmante ; néanmoins, ceci pourrait dette d’exposer copieusement de bas étape tensorflow légalité.

Délivrance de prétraitement, disponibles à abruptement de keras interprétation 2.6.1, supprime le rareté d’ouvrages R raccourci et s’droit angéliquement pour tfdatasets. Exclusivement ce n’est pas intégral. Pendant lequel cet éditorial, certains voulons marquer quatre aspects obligatoires :

  1. Les parturition de prétraitement réduisent profusément l’attention de codification. Toi pourrait compter ces ouvrages toi-même ; purement ne pas empressé à le constituer permet de tondre du époque, favorise le légalité modulaire et gratifié à sauter les errata.
  2. Les parturition de prétraitement – un sous-ensemble d’convaincu elles-mêmes, avec entité concret – peuvent procréer des informations récapitulatives endroit la initiation hygiéniquement dite et prétexter un inventaire immatriculé lorsqu’elles-mêmes sont appelées derrière.
  3. Les parturition de prétraitement peuvent renforcer la initiation.
  4. Les parturition de prétraitement font ou peuvent entité intégrées au modèle, éliminant donc la exigence d’réaliser des procédures de prétraitement indépendantes pendant l’contexte de déploiement.

Alors une rapide initiation, certains développerons chaque personne de ces points. Quelques-uns concluons pour paire exemples de terminaison en terminaison (impliquant respectivement des images et du législation) qui illustrent diligent ces quatre aspects.

Les parturition de prétraitement en diminué

Puis les divergentes keras parturition, celles lesquels certains parlons ici commencent toutes par layer_, et peuvent entité instanciés outre du modèle et du gazoduc de hasard. Ici, certains créons un transcription qui fera biaiser les images de pédant acyclique oscillant l’modèle, jusqu’à 45 échelons pendant les paire acception :

library(keras)
aug_layer <- layer_random_rotation(factor = 0.125)

Une coup que certains avons une semblable gisant, certains pouvons illico la sonder sur une touchant outré.

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.)), shape=(5, 5), dtype=float32)

“Interroger la gisant” signifie désormais précisément l’beugler pendant une emploi:

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.        )), shape=(5, 5), dtype=float32)

Une coup instanciée, une gisant peut entité utilisée de paire manières. Total d’entour, pendant le conteneur du gazoduc d’crise.

En pseudo-code :

# pseudocode
library(tfdatasets)
 
train_ds <- ... # define dataset
preprocessing_layer <- ... # instantiate layer

train_ds <- train_ds %>%
  dataset_map(function(x, y) list(preprocessing_layer(x), y))

Secundo, la pédant qui semble la surtout naturelle, avec un gisant: en autant que gisant à l’civil du modèle. En gros :

# pseudocode
input <- layer_input(shape = input_shape)

produit <- input %>%
  preprocessing_layer() %>%
  rest_of_the_model()

model <- keras_model(input, produit)

En incident, lui-même semble si indéniable que toi-même toi-même demandez probablement : Conséquemment même accepter un tfdatasets-alternative intégrée ? Quelques-uns développerons ceci inférieurement peu, alors certains parlerons de performances.

Puis inventaire les parturition – qui sont assez spéciales avec obliger à eux partisane fraction – peuvent puisque entité utilisées pendant les paire acception, purement elles-mêmes nécessitent une escale adventice. Encore à ce émettrice ci-après.

Pardon les parturition de prétraitement facilitent la vie

Des parturition dédiées existent avec une presse de impératifs de évolution de hasard. Quelques-uns pouvons les subsumer en paire grandes catégories, l’engineering des fonctionnalités et l’alourdissement des hasard.

Savoir-faire des fonctionnalités

Le rareté d’engineering des fonctionnalités peut naître pour entiers les hommes de hasard. Puis les images, certains n’utilisons évidemment pas ce résultat avec les ouvrages “piétonnes” qui sont principaux avec qu’un modèle les entente : redimensionnement, recadrage, etc. Toutefois, il y a des hypothèses cachées pendant chaque personne de ces ouvrages , certains certains sentons ainsi justifiés pendant à nous classification. Desquels qu’il en sinon, les parturition de ce massé incluent layer_resizing(), layer_rescaling()et layer_center_crop().

Puis le législation, la personnelle fonctionnalité lesquels certains ne pourrions pas certains tromper est la vectorisation. layer_text_vectorization() s’en occupe avec certains. Quelques-uns rencontrerons cette gisant pendant la fraction suivante, donc que pendant le moindre exposé de légalité plein.

Passons gardant à ce qui est évidemment envisagé pendant le bien de l’engineering des fonctionnalités : hasard digitaux et catégorielles (on pourrait affirmation : “gazette de arrière-pensée”).

Originellement, les hasard digitaux doivent fréquemment entité normalisées avec que les réseaux de neurones fonctionnent diligent – avec y finir, utilisez layer_normalization(). Ou probablement y a-t-il une discernement avec auquel certains aimerions appuyer des possibilités continues pendant des catégories discrètes. Ce serait une tâche avec layer_discretization().

Secundo, les hasard catégorielles se présentent inférieurement contradictoires formats (chaînes, nombres complets…), et il y a généralement quant à machin ceci doit entité incident contre de les inviter de pédant vigoureuse. Généralement, toi-même souhaiterez les assimiler pendant un étendue de profondeur abbesse, en utilisant layer_embedding(). Désormais, les parturition d’inclusion s’attendent à ce que à eux zakouski soient des nombres complets ; avec entité concret : complets consécutifs. Ici, les parturition à approfondir sont layer_integer_lookup() et layer_string_lookup(): Ils convertiront des complets aléatoires (chaînes, respectivement) en possibilités entières consécutives. Pendant lequel un découpage distinct, il pourrait y empressé follement de catégories avec agréer l’éradication d’informations utiles. Pendant lequel de pareils cas, utilisez layer_hashing() avec fouir les hasard. Et bref, il y a layer_category_encoding() avec procréer les peintures classiques one-hot ou multi-hot.

Agrandissement des hasard

Pendant lequel la moindre variété, on trouve des parturition qui exécutent (configurable) ouvrages aléatoires sur les images. Dans n’en adopter que nous : layer_random_crop(), layer_random_translation(), layer_random_rotation() … Ceux-là-ci sont besognes non malheureusement en ce qu’ils implémentent les fonctionnalités de bas étape requises ; lorsqu’ils sont intégrés pendant un modèle, ils sont puisque sensibles au alternance de corvée : toutes les ouvrages aléatoires seront exécutées néanmoins oscillant la initiation.

Ce jour que certains avons une prénotion de ce que ces parturition font avec certains, concentrons-nous sur le cas entier des parturition préservant l’inventaire.

Délivrance de prétraitement qui conservent l’inventaire

Une gisant qui obscur problématiquement les images n’a pas rareté de érudition duquel que ce sinon sur les hasard. Il doit moulant protéger une gouverné : pour prévisibilité (p)constituer (X). Un transcription censé vectoriser du législation, en retour, doit empressé une tertre de voisinage, chanteur coïncider les chaînes de manuscrit aux complets. Il en va itou avec une gisant qui mappe des complets contingents à un rassemblement aligné. Et pendant les paire cas, la tertre de affecté doit entité créée à l’hâtif.

Puis les parturition pour inventaire, cette agrégat d’informations est déclenchée en appelant adapt() sur une prière de gisant froidement créée. Par exposé, ici, certains instancions et “conditionnons” une gisant qui mappe des chaînes sur des complets consécutifs :

colors <- c("bleu-vert", "turquoise", "celeste");

layer <- layer_string_lookup()
layer %>% adapt(colors)

Quelques-uns pouvons établir ce qu’il y a pendant la tertre de affecté :

(1) "(UNK)"     "turquoise" "bleu-vert"      "celeste"  

Postérieurement, l’signal de la gisant encodera les arguments :

layer(c("azure", "bleu-vert"))
tf.Tensor((0 2), shape=(2,), dtype=int64)

layer_string_lookup() fonctionne sur des chaînes de manuscrit individuelles et, par logique, est la évolution adéquate avec les caractéristiques catégorielles à sang-froid de barrière. Dans chiffrer des phrases entières (ou des paragraphes, ou des bouts de législation) toi-même utiliseriez layer_text_vectorization() préférablement. Quelques-uns verrons hein ceci fonctionne pendant à nous moindre exposé de terminaison en terminaison.

Manutention des parturition de prétraitement avec les performances

Plus haut, certains avons dit que les parturition de prétraitement pouvaient entité utilisées de paire manières : pendant le conteneur du modèle ou pendant le conteneur du gazoduc d’crise de hasard. Si ce sont parturitionconséquemment même accepter la moindre intercession ?

La discernement responsable est la réussite. Les GPU sont imposants avec les ouvrages matricielles régulières, équivalentes que celles impliquées pendant la pression d’images et les transformations de hasard digitaux de exercé livrée. Par logique, si toi-même avez un GPU sur léproserie toi-même mener, il est corrigé d’empressé des parturition de continuité d’touchant, ou des parturition équivalentes que layer_normalization()constituer concurrence du modèle (qui est tout à fait expérimenté sur GPU).

D’changé acte, les ouvrages impliquant du législation, équivalentes que layer_text_vectorization(), sont encore exécutés sur le CPU. Il en va itou si annulé GPU n’est vacant avec l’modèle. Pendant lequel ces cas, toi-même déplaceriez les parturition pied le gazoduc d’crise et toi-même toi-même efforceriez de posséder d’un continuité ressemblance – sur le microprocesseur. Par exposé:

# pseudocode

preprocessing_layer <- ... # instantiate layer

dataset <- dataset %>%
  dataset_map(~list(text_vectorizer(.x), .y),
              num_parallel_calls = tf$data$AUTOTUNE) %>%
  dataset_prefetch()
model %>% fit(dataset)

En corollaire, pendant les exemples de terminaison en terminaison ci-après, toi-même verrez l’alourdissement des hasard d’touchant se procréer pendant le conteneur du modèle, et la vectorisation du législation, pendant le conteneur du gazoduc d’crise.

Expédition d’un modèle, plein pour prétraitement

Supposons que avec l’modèle de votre modèle, toi-même avez trouvé que le tfdatasets layon incarnait le bonifié. Ce jour, toi-même le déployez sur un steward sur léproserie R n’est pas installé. Il semblerait que toi-même deviez réaliser le prétraitement pendant une changé technologie vacant. Successivement, toi-même devrez épargner sur les utilisateurs qui accommodement des hasard déjà prétraitées.

Bien, toi-même pouvez constituer changé machin. Créez un débours modèle précisément avec l’induction, pendant cela :

# pseudocode

input <- layer_input(shape = input_shape)

produit <- input %>%
  preprocessing_layer(input) %>%
  training_model()

inference_model <- keras_model(input, produit)

Cette système utilise l’API fonctionnelle avec inciter un débours modèle qui ajoute la gisant de prétraitement au modèle parangon rien prétraitement.

Alors s’entité appliqué sur différents petites choses singulièrement « bonnes à érudition », on conclut gardant pour les exemples amoureux.

Résumé 1 : Agrandissement des hasard d’touchant

À nous élémentaire exposé expliqué l’alourdissement des hasard d’touchant. Trio hommes de transformations sont regroupés, ce qui les incident résulter explicitement pendant la acception globale du modèle. Ce massé de calques sera empressé oscillant l’modèle néanmoins.

library(keras)
library(tfdatasets)

# Load CIFAR-10 data that come with keras
c(c(x_train, y_train), ...) %<-% dataset_cifar10()
input_shape <- dim(x_train)(-1) # drop batch dim
classes <- 10

# Create a tf_dataset gazoduc 
train_dataset <- tensor_slices_dataset(list(x_train, y_train)) %>%
  dataset_batch(16) 

# Use a (non-trained) ResNet charpente
resnet <- application_resnet50(weights = NULL,
                               input_shape = input_shape,
                               classes = classes)

# Create a data alourdissement préparation with plat flipping, rotations, zooms
data_augmentation <-
  keras_model_sequential() %>%
  layer_random_flip("plat") %>%
  layer_random_rotation(0.1) %>%
  layer_random_zoom(0.1)

input <- layer_input(shape = input_shape)

# Define and run the model
produit <- input %>%
  layer_rescaling(1 / 255) %>%   # rescale inputs
  data_augmentation() %>%
  resnet()

model <- keras_model(input, produit) %>%
  compile(optimizer = "rmsprop", loss = "sparse_categorical_crossentropy") %>%
  fit(train_dataset, steps_per_epoch = 5)

Résumé 2 : vectorisation de législation

Pendant lequel le continuité du élocution facilité, certains utilisons fréquemment des parturition d’inclusion avec enfiler les parturition “bourrin de empoignade” (récurrentes, convolutives, auto-attentionnelles, etc.) pour l’crise continue et dimensionnée de pédant optimale lesquels elles-mêmes ont rareté. Les parturition d’inclusion s’attendent à ce que les jetons soient encodés inférieurement exercé d’complets, et rectifier le législation en complets est ce que layer_text_vectorization() incident.

À nous moindre exposé expliqué le alternance de corvée : toi-même demandez à la gisant d’proclamer le thesaurus à l’hâtif, après de l’beugler pendant le conteneur du gazoduc de prétraitement. Une coup la initiation terminée, certains créons un modèle « intégral saisi » de déploiement.

library(tensorflow)
library(tfdatasets)
library(keras)

# Example data
text <- as_tensor(c(
  "From each according to his ability, to each according to his needs!",
  "Act that you use humanity, whether in your own person or in the person of any other, always at the same time as an end, never merely as a means.",
  "Reason is, and ought only to be the slave of the passions, and can never pretend to any other psautier than to serve and obey them."
))

# Create and adapt layer
text_vectorizer <- layer_text_vectorization(output_mode="int")
text_vectorizer %>% adapt(text)

# Check
as.array(text_vectorizer("To each according to his needs"))

# Create a élémentaire layout model
input <- layer_input(shape(NULL), dtype="int64")

produit <- input %>%
  layer_embedding(input_dim = text_vectorizer$vocabulary_size(),
                  output_dim = 16) %>%
  layer_gru(8) %>%
  layer_dense(1, poussée = "sigmoid")

model <- keras_model(input, produit)

# Create a labeled dataset (which includes unknown tokens)
train_dataset <- tensor_slices_dataset(list(
    c("From each according to his ability", "There is nothing higher than reason."),
    c(1L, 0L)
))

# Preprocess the slip inputs
train_dataset <- train_dataset %>%
  dataset_batch(2) %>%
  dataset_map(~list(text_vectorizer(.x), .y),
              num_parallel_calls = tf$data$AUTOTUNE)

# Malle the model
model %>%
  compile(optimizer = "adam", loss = "binary_crossentropy") %>%
  fit(train_dataset)

# export inference model that accepts strings as input
input <- layer_input(shape = 1, dtype="slip")
produit <- input %>%
  text_vectorizer() %>%
  model()

end_to_end_model <- keras_model(input, produit)

# Épreuve inference model
test_data <- as_tensor(c(
  "To each according to his needs!",
  "Reason is, and ought only to be the slave of the passions."
))
test_output <- end_to_end_model(test_data)
as.array(test_output)

Parfaire

Puis ce certificat, à nous intègre incarnait d’mener l’adulation sur keras‘ nouvelles parturition de prétraitement, et produire hein – ​​et conséquemment – elles-mêmes sont utiles. De plusieurs divergentes cas d’usage peuvent entité trouvés pendant la timbre.

Remerciement d’empressé lu!

Cliché de Henning Borgersen sur Unsplash

By nsmaat