Transformation de données

Amazon SageMaker Data Wrangler propose de nombreuses transformations de données ML pour rationaliser le nettoyage, la transformation et la mise en valeur de vos données. Lorsque vous ajoutez une transformation, elle ajoute une étape au flux de données. Chaque transformation que vous ajoutez modifie votre jeu de données et génère un nouveau nom de données. Toutes les transformations suivantes s'appliquent au dataframe résultant.

Data Wrangler inclut des transformations intégrées, que vous pouvez utiliser pour transformer des colonnes sans code. Vous pouvez également ajouter des transformations personnalisées à l'aide PySpark de Python (fonction définie par l'utilisateur), de pandas et PySpark de SQL. Certaines transformations sont appliquées directement, tandis que d'autres créent une nouvelle colonne de sortie dans votre jeu de données.

Vous pouvez appliquer des transformations à plusieurs colonnes en même temps. Par exemple, vous pouvez supprimer plusieurs colonnes d'une seule étape.

Vous ne pouvez appliquer les transformations Process numeric (Traitement numérique) et Handle missing (Gestion des éléments manquants) qu'à une seule colonne.

Lisez cette page pour en savoir plus sur ces transformations intégrées et personnalisées.

Interface utilisateur de transformation

La plupart des transformations intégrées sont situées dans l'onglet Prepare (Préparation) de l'interface utilisateur Data Wrangler. Vous pouvez accéder aux transformations Join (Joindre) et Concatenate (Concaténer) via la vue de flux de données. Utilisez le tableau suivant pour avoir un aperçu de ces deux vues.

Joindre des jeux de données

Vous joignez des dataframes directement dans votre flux de données. Lorsque vous joignez deux jeux de données, le jeu de données joint résultant apparaît dans votre flux. Les types de jointure suivants sont pris en charge par Data Wrangler.

Utilisez la procédure suivante pour joindre deux dataframes.

Concaténer des jeux de données

Équilibrage des données

Vous pouvez équilibrer les données des jeux de données présentant une catégorie sous-représentée. L'équilibrage d'un jeu de données peut vous aider à créer de meilleurs modèles pour la classification binaire.

Vous pouvez utiliser l'opération Balance data (Équilibrer les données) pour équilibrer vos données à l'aide de l'un des opérateurs suivants :

Vous pouvez utiliser toutes les transformations pour des jeux de données contenant à la fois des fonctions numériques et non numériques. SMOTE interpole les valeurs en utilisant des échantillons voisins. Data Wrangler utilise la distance du coefficient de détermination pour déterminer le voisinage afin d'interpoler des échantillons supplémentaires. Data Wrangler utilise uniquement des fonctions numériques pour calculer les distances entre les échantillons du groupe sous-représenté.

Pour deux échantillons réels du groupe sous-représenté, Data Wrangler interpole les fonctions numériques en utilisant une moyenne pondérée. Il affecte aléatoirement un poids à ces échantillons dans la plage de [0, 1]. Pour les fonctions numériques, Data Wrangler interpole les échantillons à l'aide d'une moyenne pondérée des échantillons. Pour les échantillons A et B, Data Wrangler pourrait affecter aléatoirement un poids de 0,7 à A et de 0,3 à B. Par conséquent, l'échantillon interpolé aurait une valeur de 0,7A + 0,3B.

Data Wrangler interpole des fonctions non numériques en réalisant une copie à partir de l'un des échantillons réels interpolés. Il copie les échantillons en affectant aléatoirement une probabilité à chaque échantillon. Pour les échantillons A et B, il peut affecter les probabilités 0,8 à A et 0,2 à B. Selon les probabilités affectées, il copie A 80 % du temps.

Transformations personnalisées

Le groupe Custom Transforms vous permet d'utiliser Python (fonction définie par l'utilisateur) PySpark, pandas ou PySpark (SQL) pour définir des transformations personnalisées. Pour ces trois options, vous utilisez la variable df pour accéder au dataframe auquel vous souhaitez appliquer la transformation. Pour appliquer votre code personnalisé à votre dataframe, attribuez au dataframe les transformations que vous avez apportées à la variable df. Si vous n'utilisez pas Python (fonction définie par l'utilisateur), vous n'avez pas besoin d'inclure une instruction de retour. Cliquez sur Preview (Aperçu) pour afficher un aperçu du résultat de la transformation personnalisée. Cliquez sur Add (Ajouter) pour ajouter la transformation personnalisée à votre liste Previous steps (Étapes précédentes).

Vous pouvez importer les bibliothèques populaires suivantes à l'aide d'une instruction import dans le bloc de code de la transformation personnalisée :

df.rename(columns={"A column": "A_column", "B column": "B_column"})

Si vous incluez des instructions d'impression dans le bloc de code, le résultat apparaît lorsque vous cliquez sur Preview (Aperçu). Vous pouvez redimensionner le panneau du transformateur de code personnalisé. Le redimensionnement du panneau offre plus d'espace pour écrire du code. L'image suivante illustre le redimensionnement du panneau.

Vous trouverez ci-dessous du contexte et des exemples supplémentaires pour écrire du code de transformation personnalisé.

Python (fonction définie par l'utilisateur)

La fonction Python vous permet d'écrire des transformations personnalisées sans avoir besoin de connaître Apache Spark ou Pandas. Data Wrangler est optimisé pour exécuter rapidement votre code personnalisé. Vous obtenez des performances similaires en utilisant du code Python personnalisé et un plugin Apache Spark.

Pour utiliser le bloc de code Python (fonction définie par l'utilisateur), spécifiez ce qui suit :

L'utilisation du mode pandas offre de meilleures performances. Le mode Python facilite l'écriture de transformations en utilisant des fonctions Python pures.

La vidéo suivante présente un exemple d'utilisation de code personnalisé pour créer une transformation. Il utilise le jeu de données Titanic pour créer une colonne avec la civilité de la personne.

PySpark

L'exemple suivant extrait la date et l'heure d'un horodatage.

from pyspark.sql.functions import from_unixtime, to_date, date_format
df = df.withColumn('DATE_TIME', from_unixtime('TIMESTAMP'))
df = df.withColumn( 'EVENT_DATE', to_date('DATE_TIME')).withColumn(
'EVENT_TIME', date_format('DATE_TIME', 'HH:mm:ss'))

pandas

L'exemple suivant fournit une vue d'ensemble du dataframe auquel vous ajoutez des transformations.

df.info()

PySpark (SQL)

L'exemple suivant permet de créer un nouveau dataframe avec quatre colonnes : name (nom), fare (tarif), pclass (classe de passager), survived (survivant).

SELECT name, fare, pclass, survived FROM df

Si vous ne savez pas comment vous en servir PySpark, vous pouvez utiliser des extraits de code personnalisés pour vous aider à démarrer.

Data Wrangler possède une collection interrogeable d'extraits de code. Vous pouvez utiliser les extraits de code pour effectuer des tâches telles que la suppression de colonnes, le regroupement par colonnes ou la modélisation.

Pour utiliser un extrait de code, choisissez Search example snippets (Rechercher dans les exemples d'extraits) et spécifiez une requête dans la barre de recherche. Le texte que vous spécifiez dans la requête ne doit pas nécessairement correspondre exactement au nom de l'extrait de code.

L'exemple suivant montre un extrait de code Drop duplicate rows (Supprimer les doublons de lignes) qui peut supprimer des lignes contenant des données similaires dans votre jeu de données. Vous pouvez trouver l'extrait de code en recherchant l'un des éléments suivants :

L'extrait de code suivant contient des commentaires qui vous aident à comprendre les modifications que vous devez apporter. Pour la plupart des extraits de code, vous devez spécifier les noms de colonnes de votre jeu de données dans le code.

# Specify the subset of columns
# all rows having identical values in these columns will be dropped

subset = ["col1", "col2", "col3"]
df = df.dropDuplicates(subset)  

# to drop the full-duplicate rows run
# df = df.dropDuplicates()            
                        
        

Pour utiliser un extrait de code, copiez et collez son contenu dans le champ Custom transform (Transformation personnalisée). Vous pouvez copier et coller plusieurs extraits de code dans le champ de transformation personnalisé.

Formule personnalisée

Utilisez Custom formula (Formule personnalisée) pour définir une nouvelle colonne à l'aide d'une expression Spark SQL pour interroger des données dans le dataframe actuel. La requête doit utiliser les conventions des expressions Spark SQL.

df.rename(columns={"A column": "A_column", "B column": "B_column"})

Vous pouvez utiliser cette transformation pour effectuer des opérations sur les colonnes, en référençant les colonnes par leur nom. Par exemple, en supposant que le dataframe actuel contient des colonnes nommées col_a et col_b, vous pouvez utiliser l'opération suivante pour produire une Output column (Colonne de sortie) qui est le produit de ces deux colonnes en utilisant le code suivant :

col_a * col_b

Les autres opérations courantes sont les suivantes, en supposant qu'un dataframe contient les colonnes col_a et col_b :

Pour plus d'informations, consultez la documentation Spark sur la sélection des données.

Réduire la dimensionnalité dans un jeu de données

Réduisez la dimensionnalité de vos données à l'aide de l'analyse des composants principaux (PCA). La dimensionnalité de votre jeu de données correspond au nombre de fonctionnalités. Lorsque vous utilisez la réduction de dimensionnalité dans Data Wrangler, vous obtenez un nouvel ensemble de fonctionnalités appelées composants. Chaque composant explique une partie de la variabilité des données.

Le premier composant est à l'origine de la plus grande variation des données. Le deuxième composant est à l'origine de la deuxième plus grande variation des données, et ainsi de suite.

Vous pouvez utiliser la réduction de dimensionnalité pour réduire la taille des jeux de données que vous utilisez pour entraîner des modèles. Au lieu d'utiliser les fonctionnalités de votre jeu de données, vous pouvez utiliser les composants principaux.

Pour effectuer l'analyse PCA, Data Wrangler crée des axes pour vos données. Un axe est une combinaison affine de colonnes dans votre jeu de données. Le premier composant principal est la valeur sur l'axe qui présente la plus grande variance. Le deuxième composant principal est la valeur sur l'axe qui présente la deuxième plus grande variance. Le nième composant principal est la valeur sur l'axe qui présente la nième plus grande variance.

Vous pouvez configurer le nombre de composants principaux renvoyés par Data Wrangler. Vous pouvez soit spécifier directement le nombre de composant principaux, soit spécifier le pourcentage de seuil de variance. Chaque composant principal explique l'ampleur de la variance des données. Par exemple, vous pouvez avoir un composant principal ayant la valeur 0,5. Le composant explique alors 50 % de la variation des données. Lorsque vous spécifiez un pourcentage de seuil de variance, Data Wrangler renvoie le plus petit nombre de composants correspondant au pourcentage que vous spécifiez.

Voici des exemples de composants principaux avec le degré de variance qu'ils expliquent dans les données.

Si vous spécifiez un pourcentage de seuil de variance de 94 ou 95, Data Wrangler renvoie les composants 1 et 2. Si vous spécifiez un pourcentage de seuil de variance de 96, Data Wrangler renvoie les trois composants principaux.

Vous pouvez utiliser la procédure suivante pour exécuter l'analyse PCA sur votre jeu de données.

Encodage catégoriel

Les données catégorielles sont généralement composées d'un nombre fini de catégories, où chacune d'elles est représentée par une chaîne. Par exemple, si vous disposez d'une table de données client, une colonne indiquant le pays dans lequel vit une personne est de type catégorie. Les catégories seraient Afghanistan, Albania (Albanie), Algeria (Algérie), etc. Les données de catégorie peuvent être nominales ou ordinales. Les catégories ordinales ont un ordre inhérent, et les catégories nominales n'en ont pas. Le diplôme le plus élevé obtenu (High school (Baccalauréat), Bachelors (Licence), Masters (Maîtrise), etc.) est un exemple de catégories ordinales.

Le codage des données catégorielles est le processus de création d'une représentation numérique pour les catégories. Par exemple, si vos catégories sont Chien et Chat, vous pouvez encoder ces informations en deux vecteurs : [1,0] pour représenter Chien, et [0,1] pour représenter Chat.

Lorsque vous encodez des catégories ordinales, vous devez parfois traduire l'ordre naturel des catégories dans votre codage. Par exemple, vous pouvez représenter le degré le plus élevé obtenu avec la carte suivante : {"High school": 1, "Bachelors": 2, "Masters":3}.

Utilisez le codage catégoriel pour encoder des données catégorielles au format chaîne dans des tableaux d'entiers.

Les codeurs catégoriels Data Wrangler créent des codages pour toutes les catégories qui existent dans une colonne au moment de la définition de l'étape. Si de nouvelles catégories ont été ajoutées à une colonne lorsque vous démarrez une tâche Data Wrangler pour traiter votre jeu de données au temps t, et que cette colonne était l'entrée d'une transformation d'encodage catégoriel Data Wrangler au temps t-1, ces nouvelles catégories sont considérées comme manquantes dans la tâche Data Wrangler. L'option que vous sélectionnez pour Invalid handling strategy (Politique de gestion non valide) est appliquée à ces valeurs manquantes. Voici des exemples de cas où cela peut se produire :

Dans ces situations, ces nouvelles catégories sont considérées comme des valeurs manquantes dans la tâche Data Wrangler.

Vous pouvez choisir entre un codage ordinal ou un codage à chaud et le configurer. Utilisez les sections suivantes pour en savoir plus sur ces options.

Les deux transformations créent une nouvelle colonne nommée Output column name (Nom de colonne de sortie). Vous spécifiez le format de sortie de cette colonne avec Output style (Style de sortie) :

Encodage ordinal

Choisissez Ordinal encode (Encodage ordinal) pour encoder les catégories dans un entier compris entre 0 et le nombre total de catégories dans Input column (Colonne d'entrée) que vous sélectionnez.

Invalid handing strategy (Politique de remise non valide) : sélectionnez une méthode pour gérer les valeurs invalides ou manquantes.

Encodage à chaud

Choisissez One-hot encode (Encodage à chaud) pour Transform (Transformation) afin d'utiliser un codage à chaud. Configurez cette transformation à l'aide des éléments suivants :

Encodage des similarités

Utilisez l'encodage des similarités lorsque vous disposez des éléments suivants :

L'encodeur de similarités crée des incorporations pour les colonnes contenant des données catégorielles. Une incorporation est un mappage d'objets discrets, tels que des mots, sur des vecteurs de nombres réels. L'encodeur encode des chaînes similaires à des vecteurs contenant des valeurs similaires. Par exemple, il crée des encodages très semblables pour « Californie » et « Calfornie ».

Data Wrangler convertit chaque catégorie du jeu de données en un ensemble de jetons à l'aide d'un générateur de jetons trigramme. Il convertit les jetons en une incorporation à l'aide d'un encodage à hachage minimal.

L'exemple suivant montre comment l'encodeur de similarités crée des vecteurs à partir de chaînes.

Les encodages de similarités créés par Data Wrangler :

Pour les raisons précédentes, l'encodage des similarités est plus polyvalent qu'un encodage à chaud.

Pour ajouter l'encodage des similarités comme transformation à votre jeu de données, procédez comme suit.

Texte enrichi

Utilisez le groupe de transformation Featurize Text (Texte enrichi) pour inspecter les colonnes de type chaîne de caractères et utiliser l'encapsulation de texte pour enrichir ces colonnes.

Ce groupe d'entités contient deux fonctionnalités, Character statistics (Statistiques de caractères) et Vectorize (Vectoriser). Utilisez les sections suivantes pour en apprendre plus sur ces options. Pour les deux options, Input column (Colonne d'entrée) doit contenir des données de texte (type chaîne).

Statistiques de caractères

Utilisez Character statistics (Statistiques de caractères) pour générer des statistiques pour chaque ligne d'une colonne contenant des données textuelles.

Cette transformation calcule les ratios et les dénombrements suivants pour chaque ligne, et crée une nouvelle colonne pour signaler le résultat. La nouvelle colonne est nommée en utilisant le nom de la colonne en entrée comme préfixe et un suffixe spécifique au ratio ou au nombre.

Vectorisation

L'encapsulation de texte consiste à mettre en correspondance des mots ou des phrases d'un vocabulaire avec des vecteurs de nombres réels. Utilisez la transformation d'encapsulation de texte de Data Wrangler pour créer des jetons et vectoriser les données de texte en vecteurs TF-IDF (fréquence de document inverse).

Lorsque TF-IDF est calculé pour une colonne de données textuelles, chaque mot de chaque phrase est converti en nombre réel qui représente son importance sémantique. Des nombres plus élevés sont associés à des mots moins fréquents, qui ont tendance à être plus significatifs.

Lorsque vous définissez une étape de transformation Vectorize (Vectorisation), Data Wrangler utilise les données de votre jeu de données pour définir le vectorisateur de comptage et les méthodes TF-IDF. Ces mêmes méthodes sont utilisées lors de l'exécution d'une tâche Data Wrangler.

Vous configurez cette transformation à l'aide des éléments suivants :

Transformer les séries temporelles

Dans Data Wrangler, vous pouvez transformer les données de séries temporelles. Les valeurs d'un jeu de données de séries temporelles sont indexées à une heure spécifique. Par exemple, un jeu de données qui affiche le nombre de clients dans un magasin pour chaque heure de la journée est un jeu de données de série temporelle. Le tableau suivant présente un exemple d'un jeu de données de série temporelle.

Dans le tableau précédent, la colonne Number of Customers (Nombre de clients) contient les données en séries chronologiques. Les données de séries temporelles sont indexées aux données horaires dans la colonne Time (hour) (Heure (heure)).

Vous devrez peut-être effectuer une série de transformations sur vos données pour les obtenir dans un format que vous pouvez utiliser pour votre analyse. Utilisez le groupe de transformation Times series (Séries temporelles) pour transformer vos données de séries temporelles. Pour plus d'informations sur les transformations que vous pouvez effectuer, veuillez consulter les sections suivantes.

Grouper par série temporelle

Vous pouvez utiliser l'opération Group by (Regrouper par) afin de regrouper des données de séries temporelles pour des valeurs spécifiques dans une colonne.

Par exemple, le tableau suivant suit la consommation quotidienne moyenne d'électricité d'un ménage.

Si vous choisissez de regrouper les ménages par ID, le tableau suivant s'affiche.

Chaque entrée de la séquence des séries temporelles est classée en fonction de l'horodatage correspondant. Le premier élément de la séquence correspond au premier horodatage de la série. Pour household_0, 30 est la première valeur de la série Consommation d'électricité. La valeur de 30 correspond au premier horodatage de 1/1/2020.

Vous pouvez inclure l'horodatage de début et l'horodatage de fin. Le tableau suivant illustre la manière dont ces informations s'affichent.

Vous pouvez utiliser la procédure suivante pour regrouper par colonne de séries temporelles.

Rééchantillonner les données de séries temporelles

Les données de séries temporelles contiennent généralement des observations qui ne sont pas effectuées à intervalles réguliers. Par exemple, un jeu de données peut comporter des observations enregistrées toutes les heures et d'autres observations enregistrées toutes les deux heures.

De nombreuses analyses, telles que les algorithmes de prédiction, exigent que les observations soient effectuées à intervalles réguliers. Le rééchantillonnage vous permet d'établir des intervalles réguliers pour les observations de votre jeu de données.

Vous pouvez rééchantillonner ou sous-échantillonner une série temporelle. Le sous-échantillonnage augmente l'intervalle entre les observations dans le jeu de données. Par exemple, si vous sous-échantillonnez les observations qui sont effectuées toutes les heures ou toutes les deux heures, chaque observation de votre jeu de données est effectuée toutes les deux heures. Les observations horaires sont agrégées en une seule valeur à l'aide d'une méthode d'agrégation telle que la moyenne ou la médiane.

Le suréchantillonnage réduit l'intervalle entre les observations dans le jeu de données. Par exemple, si vous rééchantillonnez les observations effectuées toutes les deux heures en observations horaires, vous pouvez utiliser une méthode d'interpolation pour déduire les observations horaires de celles qui sont effectuées toutes les deux heures. Pour plus d'informations sur les méthodes d'interpolation, voir pandas. DataFrame.interpoler.

Vous pouvez rééchantillonner à la fois des données numériques et non numériques.

Utilisez l'opération Resample (Rééchantillonner) pour rééchantillonner vos données de séries temporelles. Si vous avez plusieurs séries temporelles dans votre jeu de données, Data Wrangler standardise l'intervalle de temps pour chaque série temporelle.

Voici un exemple de sous-échantillonnage des données de séries temporelles en utilisant la moyenne comme méthode d'agrégation. Les données sont sous-échantillonnées toutes les deux heures à toutes les heures.

Vous pouvez utiliser la procédure suivante pour rééchantillonner des données de séries temporelles.

Gestion des données de séries temporelles manquantes

Si vous ne disposez pas de valeurs dans votre jeu de données, vous pouvez effectuer l'une des actions suivantes :

L'imputation d'une valeur manquante implique le remplacement des données en spécifiant une valeur ou en utilisant une méthode inférentielle. Voici les méthodes que vous pouvez utiliser pour l'imputation :

Certaines méthodes d'imputation ne peuvent pas imputer toutes les valeurs manquantes de votre jeu de données. Par exemple, le remplissage avant ne peut pas imputer une valeur manquante qui apparaît au début de la série temporelle. Vous pouvez imputer les valeurs à l'aide d'un remplissage avant ou d'un remplissage arrière.

Vous pouvez imputer des valeurs manquantes dans une cellule ou dans une colonne.

L'exemple suivant montre comment les valeurs sont imputées dans une cellule.

L'exemple suivant montre comment les valeurs sont imputées dans une colonne.

Vous pouvez utiliser la procédure suivante pour gérer les valeurs manquantes.

Validation de l'horodatage de vos données de séries temporelles

Il se peut que certaines données d'horodatage ne soient pas valides. Vous pouvez utiliser la fonction Validate time stamp (Valider l'horodatage) pour déterminer si les horodatages de votre jeu de données sont valides. Votre horodatage peut être invalide pour une ou plusieurs des raisons suivantes :

Si vous avez des horodatages non valides dans votre jeu de données, vous ne pouvez pas effectuer votre analyse correctement. Vous pouvez utiliser Data Wrangler pour identifier les horodatages non valides et comprendre où vous devez nettoyer vos données.

La validation des séries temporelles fonctionne de l'une des deux manières suivantes :

Vous pouvez configurer Data Wrangler pour effectuer l'une des actions suivantes s'il rencontre des valeurs manquantes dans votre jeu de données :

Vous pouvez valider les horodatages sur les colonnes de type timestamp ou string. Si la colonne comporte le type string, Data Wrangler convertit le type de la colonne en timestamp et effectue la validation.

Vous pouvez utiliser la procédure suivante pour valider les horodatages dans votre jeu de données.

Standardisation de la longueur des séries temporelles

Si des données de séries temporelles sont stockées sous forme de tableaux, vous pouvez standardiser chaque série temporelle à la même longueur. La standardisation de la longueur du tableau de séries temporelles peut faciliter l'exécution de votre analyse sur les données.

Vous pouvez standardiser vos séries temporelles pour les transformations de données nécessitant la correction de la longueur de vos données.

De nombreux algorithmes ML exigent que vous aplatiez vos données de séries temporelles avant de les utiliser. L'aplatissement des données de séries temporelles consiste à séparer chaque valeur de la série temporelle dans sa propre colonne dans un jeu de données. Le nombre de colonnes d'un jeu de données ne peut pas changer. Par conséquent, les longueurs de la série temporelle doivent être standardisées en aplatissant chaque tableau en un ensemble de ressources.

Chaque série temporelle est définie sur la longueur que vous spécifiez sous forme de quantile ou de centile du jeu de séries temporelles. Par exemple, vous pouvez avoir trois séquences ayant les longueurs suivantes :

Vous pouvez définir la longueur de toutes les séquences comme étant la longueur de la séquence ayant la longueur du 50e centile.

Des valeurs manquantes sont ajoutées aux tableaux de séries temporelles qui sont inférieures à la longueur spécifiée. Voici un exemple de format de standardisation de série temporelle en longueur supérieure : [2, 4, 5, NaN, NaN, NaN].

Vous pouvez utiliser différentes approches pour gérer les valeurs manquantes. Pour plus d'informations sur ces approches, veuillez consulter Gestion des données de séries temporelles manquantes.

Les tableaux de séries temporelles qui sont plus longues que la longueur spécifiée sont tronqués.

Vous pouvez utiliser la procédure suivante pour standardiser la longueur des séries temporelles.

Extraire des fonctions de vos données de séries temporelles

Si vous exécutez une classification ou un algorithme de régression sur vos données de séries temporelles, nous vous recommandons d'extraire des ressources de la série temporelle avant d'exécuter l'algorithme. L'extraction de ressources peut améliorer la performance de votre algorithme.

Utilisez les options suivantes pour choisir la façon dont vous souhaitez extraire des ressources de vos données :

Suivez la procédure suivante pour extraire des ressources de vos données de séries temporelles.

Utiliser des ressources décalées issues de vos données de séries temporelles

Dans de nombreux cas d'utilisation, la meilleure façon de prédire le comportement futur de vos séries temporelles consiste à utiliser leur comportement le plus récent.

Voici les utilisations les plus courantes des entités décalées :

Créer une plage de date/heure dans votre série temporelle

Il se peut que vous ayez des données de séries temporelles qui n'ont pas d'horodatage. Si vous savez que les observations ont été effectuées à intervalles réguliers, vous pouvez générer des horodatages pour la série temporelle dans une colonne distincte. Pour générer des horodatages, vous spécifiez la valeur de l'horodatage de début et la fréquence des horodatages.

Voici un exemple de données de série temporelle pour le nombre de clients d'un restaurant.

Si vous savez que le restaurant a ouvert ses portes à 17h00 et que des observations sont effectuées toutes les heures, vous pouvez ajouter une colonne d'horodatage correspondant aux données de séries temporelles. Vous pouvez voir la colonne d'horodatage dans le tableau suivant.

Utilisez la procédure suivante pour ajouter une plage de date/heure à vos données.

Utiliser une fenêtre propagée dans votre série temporelle

Vous pouvez extraire des ressources sur une période donnée. Par exemple, pour le temps, t, et une longueur de fenêtre temporelle de 3, et pour la ligne qui indique le t-ème horodatage, nous ajoutons les ressources extraites de la série temporelle aux temps t - 3, t -2 et t - 1. Pour en savoir plus sur l'extraction des ressources, veuillez consulter Extraire des fonctions de vos données de séries temporelles.

Vous pouvez utiliser la procédure suivante pour extraire des ressources sur une période.

Date/Heure enrichie

Utilisez Featurize date/time (Date/Heure enrichie) pour créer une encapsulation vectorielle représentant un champ date/heure. Pour utiliser cette transformation, vos données de date/heure doivent être dans l'un des formats suivants :

Vous pouvez choisir de déduire le format date/heure et de fournir un format date/heure. Si vous fournissez un format date/heure, vous devez utiliser les codes décrits dans la documentation Python. Les options que vous choisissez pour ces deux configurations ont des répercussions sur la rapidité de l'opération et sur les résultats finaux.

Lorsque vous utilisez cette transformation, vous spécifiez une Input column (Colonne d'entrée) qui contient des données de date/heure dans l'un des formats répertoriés ci-dessus. La transformation crée une colonne de sortie nommée Output column name (Nom de colonne de sortie). Le format de la colonne de sortie dépend de votre configuration en utilisant les éléments suivants :

De plus, vous devez choisir un Embedding mode (Mode d'encapsulation). Pour les modèles linéaires et les réseaux profonds, nous recommandons de choisir le mode cyclic (cyclique). Pour les algorithmes arborescents, nous recommandons d'utiliser le mode ordinal.

Formatage de chaîne

Les transformations Format string (Formatage de chaîne) contiennent des opérations de formatage de chaîne standard. Par exemple, vous pouvez utiliser ces opérations pour supprimer des caractères spéciaux, normaliser les longueurs de chaîne et mettre à jour le boîtier de chaîne.

Ce groupe de fonctions contient les transformations suivantes. Toutes les transformations renvoient des copies des chaînes dans Input column (Colonne d'entrée) et ajoutent le résultat à une nouvelle colonne de sortie.

Traiter les valeurs aberrantes

Les modèles de machine learning sont sensibles à la distribution et à l'étendue des valeurs de vos caractéristiques. Les valeurs aberrantes, ou rares, peuvent avoir un impact négatif sur la précision des modèles et allonger les durées d'entraînement. Utilisez ce groupe de caractéristiques pour détecter et mettre à jour les valeurs aberrantes dans votre jeu de données.

Lorsque vous définissez une transformation Handle outliers (Traiter les valeurs aberrantes), les statistiques utilisées pour détecter les valeurs aberrantes sont générées sur les données disponibles dans Data Wrangler lors de la définition de cette étape. Ces mêmes statistiques sont utilisées lors de l'exécution d'une tâche Data Wrangler.

Utilisez les sections suivantes pour en apprendre davantage sur les transformations que contient ce groupe. Vous spécifiez un Output name (Nom de sortie) et chacune de ces transformations produit une colonne de sortie avec les données résultantes.

Robust standard deviation numeric outliers (Écarts-types aberrants numériques robustes)

Cette transformation détecte et corrige les valeurs aberrantes dans les caractéristiques numériques à l'aide de statistiques robustes aux valeurs aberrantes.

Vous devez définir un Upper quantile (Quantile supérieur) et un Lower quantile (Quantile inférieur) pour les statistiques servant à calculer les valeurs aberrantes. Vous devez également spécifier le nombre de Standard deviations (Écarts-types) à partir duquel une valeur doit s'écarter de la moyenne pour être considérée comme une valeur aberrante. Par exemple, si vous spécifiez 3 pour les Standard deviations (Écarts-types), une valeur doit s'écarter de plus de 3 écarts-types de la moyenne pour être considérée comme aberrante.

La méthode Fix est la méthode utilisée pour gérer les valeurs aberrantes lorsqu'elles sont détectées. Sélectionnez parmi les éléments suivants :

Standard Deviation Numeric Outliers (Écarts-types aberrants numériques)

Cette transformation détecte et corrige les valeurs aberrantes dans les entités numériques à l'aide de la moyenne et de l'écart-type.

Vous spécifiez le nombre de Standard deviations (Écarts-types) qu'une valeur doit avoir par rapport à la moyenne pour être considérée comme une valeur aberrante. Par exemple, si vous spécifiez 3 pour les Standard deviations (Écarts-types), une valeur doit s'écarter de plus de 3 écarts-types de la moyenne pour être considérée comme aberrante.

La méthode Fix est la méthode utilisée pour gérer les valeurs aberrantes lorsqu'elles sont détectées. Sélectionnez parmi les éléments suivants :

Quantile Numeric Outliers (Quantiles numériques aberrants)

Utilisez cette transformation pour détecter et corriger les valeurs aberrantes dans les entités numériques à l'aide de quantiles. Vous pouvez définir un Upper quantile (Quantile supérieur) et un Lower quantile (Quantile inférieur). Toutes les valeurs situées au-dessus du quantile supérieur ou en dessous du quantile inférieur sont considérées comme des valeurs aberrantes.

La méthode Fix est la méthode utilisée pour gérer les valeurs aberrantes lorsqu'elles sont détectées. Sélectionnez parmi les éléments suivants :

Min-Max Numeric Outliers (Valeurs numériques min-max aberrantes)

Cette transformation détecte et corrige les valeurs aberrantes dans les entités numériques à l'aide de seuils supérieurs et inférieurs. Utilisez cette méthode si vous connaissez des valeurs de seuil qui distinguent les valeurs aberrantes.

Vous spécifiez un Upper threshold (Seuil supérieur) et un Lower threshold (Seuil inférieur), et si des valeurs se situent au-dessus ou au-dessous de ces seuils, elles sont considérées comme aberrantes.

La méthode Fix est la méthode utilisée pour gérer les valeurs aberrantes lorsqu'elles sont détectées. Sélectionnez parmi les éléments suivants :

Replace Rare (Remplacer les valeurs rares)

Lorsque vous utilisez la transformation Remplace rare (Remplacer les valeurs rares), vous spécifiez un seuil. Data Wrangler recherche toutes les valeurs qui atteignent ce seuil et les remplace par une chaîne que vous spécifiez. Par exemple, vous pouvez utiliser cette transformation pour classer toutes les valeurs aberrantes d'une colonne dans une catégorie « Autres ».

Handle Missing Values (Gestion des valeurs manquantes)

Les valeurs manquantes sont fréquentes dans les jeux de données de machine learning. Dans certaines situations, il convient d'imputer les données manquantes avec une valeur calculée, telle qu'une valeur moyenne ou catégoriquement commune. Vous pouvez traiter les valeurs manquantes à l'aide de la transformation de groupe Handle Missing Values (Gestion des valeurs manquantes). Ce groupe contient les transformations suivantes.

Fill Missing (Remplissage des valeurs manquantes)

Utilisez la transformation Fill missing (Remplissage des valeurs manquantes) pour remplacer les valeurs manquantes par une Fill value (Valeur de remplissage) que vous définissez.

Impute missing (Imputer les valeurs manquantes)

Utilisez la transformation Impute missing (Imputer les valeurs manquantes) pour créer une nouvelle colonne contenant des valeurs imputées où des valeurs manquantes ont été trouvées dans des données catégoriques et numériques en entrée. La configuration dépend de votre type de données.

Pour les données numériques, choisissez une politique d'imputation, utilisée pour déterminer la nouvelle valeur à imputer. Vous pouvez choisir d'imputer la moyenne ou la médiane sur les valeurs présentes dans votre jeu de données. Data Wrangler utilise la valeur calculée pour imputer les valeurs manquantes.

Pour les données catégorielles, Data Wrangler impute les valeurs manquantes en utilisant la valeur la plus fréquente de la colonne. Pour imputer une chaîne personnalisée, utilisez la transformation Fill missing (Remplir les valeurs manquantes) à la place.

Add Indicator for Missing (Ajouter un indicateur de valeur manquante)

Utilisez la transformation Add Indicator for missing (Ajouter un indicateur de valeur manquante) pour créer une colonne indicatrice, qui contient un booléen "false" si une ligne contient une valeur, et "true" si la valeur est manquante dans cette ligne.

Drop missing (Supprimer les valeurs manquantes)

Utilisez l'option Drop missing (Supprimer les valeurs manquantes) pour supprimer les lignes dans lesquelles des valeurs sont manquantes dans Input column (Colonne d'entrée).

Manage Columns (Gérer les colonnes)

Vous pouvez utiliser les transformations suivantes pour mettre à jour et gérer rapidement les colonnes de votre jeu de données :

Manage Rows (Gérer les lignes)

Utilisez ce groupe de transformation pour effectuer rapidement des opérations de tri et de mélange sur les lignes. Ce niveau contient les éléments suivants :

Manage Vectors (Gérer les vecteurs)

Utilisez ce groupe de transformation pour combiner ou aplatir des colonnes vectorielles. Ce groupe contient les transformations suivantes.

Process Numeric (Traitement numérique)

Utilisez le groupe de fonctions Process Numeric (Traitement numérique) pour traiter les données numériques. Chaque scalaire de ce groupe est défini à l'aide de la bibliothèque Spark. Les scalaires suivants sont pris en charge :

Echantillonnage

Une fois que vous avez importé vos données, vous pouvez utiliser le transformateur d'échantillonnage pour prélever un ou plusieurs échantillons. Lorsque vous utilisez le transformateur d'échantillonnage, Data Wrangler échantillonne votre jeu de données d'origine.

Vous pouvez choisir l'une des méthodes d'échantillonnage suivantes :

Vous pouvez stratifier un échantillon aléatoire pour vous assurer qu'il représente la distribution d'origine du jeu de données.

Vous pouvez effectuer la préparation des données pour plusieurs cas d'utilisation. Pour chaque cas d'utilisation, vous pouvez prélever un échantillon différent et appliquer un ensemble de transformations différent.

La procédure suivante décrit le processus de création d'un échantillon aléatoire.

La procédure suivante décrit le processus de création d'un échantillon stratifié.

Search and Edit (Rechercher et modifier)

Utilisez cette section pour rechercher et modifier des motifs spécifiques dans des chaînes. Par exemple, vous pouvez rechercher et mettre à jour des chaînes dans des phrases ou des documents, diviser des chaînes par des délimiteurs et rechercher des occurrences de chaînes spécifiques.

Les transformations suivantes sont prises en charge sous Search and edit (Rechercher et modifier). Toutes les transformations renvoient des copies des chaînes dans Input column (Colonne d'entrée) et ajoutent le résultat à une nouvelle colonne de sortie.

Split data

Utilisez la transformation Split data (Fractionner les données) pour diviser votre jeu de données en deux ou trois jeux de données. Par exemple, vous pouvez diviser votre jeu de données en un jeu de données utilisé pour l'entraînement de votre modèle et un jeu de données utilisé pour le tester. Vous pouvez déterminer la proportion du jeu de données à inclure dans chaque fractionnement. Par exemple, si vous divisez un jeu de données en deux jeux, le jeu de données d'entraînement peut contenir 80 % des données, tandis que le jeu de données de test en contient 20 %.

Le fractionnement de vos données en trois jeux de données vous permet de créer des jeux de données d'entraînement, de validation et de test. Vous pouvez voir la performance du modèle sur le jeu de données de test en supprimant la colonne cible.

Votre cas d'utilisation détermine la part du jeu de données d'origine que chacun de vos jeux de données reçoit et la méthode que vous utilisez pour diviser les données. Par exemple, vous pouvez utiliser un fractionnement stratifié pour vous assurer que la distribution des observations dans la colonne cible est la même dans tous les jeux de données. Vous pouvez utiliser les transformations de fractionnement suivantes :

Après avoir fractionné les données, vous pouvez appliquer des transformations supplémentaires à chaque jeu de données. Pour la plupart des cas d'utilisation, cela n'est pas nécessaire.

Data Wrangler calcule les proportions des fractionnements pour dégager les meilleures performances. Vous pouvez choisir un seuil d'erreur pour définir la précision des fractionnements. Les seuils d'erreur inférieurs reflètent plus fidèlement les proportions que vous spécifiez pour les fractionnements. Si vous définissez un seuil d'erreur plus élevé, vous obtenez de meilleures performances, mais une précision moindre.

Pour des données parfaitement réparties, réglez le seuil d'erreur sur 0. Vous pouvez spécifier un seuil compris entre 0 et 1 pour obtenir de meilleures performances. Si vous spécifiez une valeur supérieure à 1, Data Wrangler interprète cette valeur comme 1.

Si votre jeu de données comporte 10 000 lignes et que vous spécifiez une répartition 80/20 avec une erreur de 0,001, vous obtiendrez des observations se rapprochant de l'un des résultats suivants :

Le nombre d'observations pour le jeu de test dans l'exemple précédent se situe dans l'intervalle compris entre 8 010 et 7 990.

Par défaut, Data Wrangler utilise une valeur initiale aléatoire pour rendre les fractionnements reproductibles. Vous pouvez spécifier une autre valeur initiale afin de créer un fractionnement reproductible différent.

Parse Value as Type (Analyser la valeur en tant que type)

Utilisez cette transformation pour convertir une colonne en nouveau type. Les types de données Data Wrangler pris en charge sont :

Validate string (Valider la chaîne)

Utilisez la transformation Validate string (Valider la chaîne) pour créer une colonne indiquant qu'une ligne de données textuelles répond à une condition spécifiée. Par exemple, vous pouvez utiliser Validate string (Valider la chaîne) pour vérifier qu'une chaîne ne contient que des caractères minuscules. Les transformations suivantes sont prises en charge sous Validate string (Valider la chaîne).

Les transformations suivantes sont incluses dans ce groupe de transformation. Si une transformation génère une valeur booléenne, True est représenté par un 1 et False est représenté par un 0.

Annulation de l'imbrication des données JSON

Si vous possédez un fichier .csv, certaines valeurs de votre jeu de données peuvent être des chaînes JSON. De même, vous avez peut-être des données imbriquées dans des colonnes d'un fichier Parquet ou d'un document JSON.

Utilisez l'opérateur Flatten structured (Aplatir structuré) pour séparer les clés de premier niveau en colonnes distinctes. Une clé de premier niveau est une clé qui n'est pas imbriquée dans une valeur.

Par exemple, vous pouvez avoir un jeu de données doté d'une colonne personne contenant des informations démographiques sur chaque personne stockées sous forme de chaînes JSON. Une chaîne JSON peut ressembler à ce qui suit.

 "{"seq": 1,"name": {"first": "Nathaniel","last": "Ferguson"},"age": 59,"city": "Posbotno","state": "WV"}"
            

L'opérateur Flatten structured (Aplatir structuré) convertit les clés de premier niveau suivantes en colonnes supplémentaires dans le jeu de données :

Data Wrangler place les valeurs des clés sous la forme de valeurs dans les colonnes. Le nom des colonnes et les valeurs des chaînes JSON sont indiqués ci-dessous.

seq, name,                                    age, city, state
1, {"first": "Nathaniel","last": "Ferguson"}, 59, Posbotno, WV
            

Pour chaque valeur du jeu de données contenant des chaînes JSON, l'opérateur Flatten structured (Aplatir structuré) crée des colonnes pour les clés de premier niveau. Pour créer des colonnes pour les clés imbriquées, appelez à nouveau l'opérateur. Dans l'exemple précédent, l'appel de l'opérateur crée les colonnes suivantes :

L'exemple suivant illustre le jeu de données résultant du nouvel appel de l'opération.

seq, name,                                    age, city, state, name_first, name_last
1, {"first": "Nathaniel","last": "Ferguson"}, 59, Posbotno, WV, Nathaniel, Ferguson
            

Choisissez Keys to flatten on (Clés sur lesquelles aplatir) pour spécifier les clés de premier niveau à extraire sous forme de colonnes distinctes. Si vous ne spécifiez pas de clé, Data Wrangler extrait toutes les clés par défaut.

Éclatement du tableau

Utilisez Explode array (Éclater le tableau) pour développer les valeurs du tableau en lignes de sortie distinctes. Par exemple, l'opération peut prendre chaque valeur du tableau [[1, 2, 3,], [4, 5, 6], [7, 8, 9]] et créer une nouvelle colonne avec les lignes suivantes :

                [1, 2, 3]
                [4, 5, 6]
                [7, 8, 9]
            

Data Wrangler nomme la nouvelle colonne <nom de la colonne d'entrée>_flatten.

Vous pouvez appeler l'opération Explode array (Éclater le tableau) plusieurs fois pour obtenir les valeurs imbriquées du tableau dans des colonnes de sortie distinctes. L'exemple suivant montre le résultat obtenu après que l'opération a été appelée plusieurs fois sur un jeu de données avec un tableau imbriqué.

Transformation des données d'image

Utilisez Data Wrangler pour importer et transformer les images que vous utilisez pour vos pipelines de machine learning (ML). Une fois que vous avez préparé vos données d'image, vous pouvez les exporter de votre flux Data Wrangler vers votre pipeline de machine learning.

Vous pouvez utiliser les informations fournies ici pour vous familiariser avec l'importation et la transformation de données d'image dans Data Wrangler. Data Wrangler utilise OpenCV pour importer des images. Pour plus d'informations sur les formats d'image pris en charge, consultez Lecture et écriture de fichiers image.

Après vous être familiarisé avec les concepts de transformation de vos données d'image, suivez le didacticiel suivant, intitulé Préparer les données d'image avec Amazon SageMaker Data Wrangler.

Les secteurs et les cas d'utilisation suivants sont des exemples dans lesquels l'application du machine learning à des données d'image transformées peut s'avérer utile :

Lorsque vous travaillez avec des données d'image dans Data Wrangler, vous devez suivre le processus suivant :

Procédez comme suit pour importer vos données d'image.

Data Wrangler utilise la bibliothèque open source imgaug pour ses transformations d'image intégrées. Vous pouvez utiliser les transformations intégrées suivantes :

Utilisez la procédure suivante pour transformer vos images sans écrire de code.

Outre les transformations fournies par Data Wrangler, vous pouvez également utiliser vos propres extraits de code personnalisés. Pour plus d'informations sur l'utilisation d'extraits de code personnalisés, consultez Transformations personnalisées. Vous pouvez importer les bibliothèques OpenCV et imgaug dans vos extraits de code et utiliser les transformations qui leur sont associées. Voici un exemple d'extrait de code qui détecte les périphéries dans ces images.

# A table with your image data is stored in the `df` variable
import cv2
import numpy as np
from pyspark.sql.functions import column

from sagemaker_dataprep.compute.operators.transforms.image.constants import DEFAULT_IMAGE_COLUMN, IMAGE_COLUMN_TYPE
from sagemaker_dataprep.compute.operators.transforms.image.decorators import BasicImageOperationDecorator, PandasUDFOperationDecorator


@BasicImageOperationDecorator
def my_transform(image: np.ndarray) -> np.ndarray:
  # To use the code snippet on your image data, modify the following lines within the function
    HYST_THRLD_1, HYST_THRLD_2 = 100, 200
    edges = cv2.Canny(image,HYST_THRLD_1,HYST_THRLD_2)
    return edges
    

@PandasUDFOperationDecorator(IMAGE_COLUMN_TYPE)
def custom_image_udf(image_row):
    return my_transform(image_row)
    

df = df.withColumn(DEFAULT_IMAGE_COLUMN, custom_image_udf(column(DEFAULT_IMAGE_COLUMN)))
        

Lorsque vous appliquez des transformations dans votre flux Data Wrangler, Data Wrangler ne les applique qu'à un échantillon des images dans votre jeu de données. Pour optimiser votre expérience avec l'application, Data Wrangler n'applique pas les transformations à toutes vos images.

Pour appliquer les transformations à toutes vos images, exportez votre flux Data Wrangler vers un emplacement Amazon S3. Vous pouvez utiliser les images que vous avez exportées dans vos pipelines d'entraînement ou d'inférence. Utilisez un nœud de destination ou un bloc-notes Jupyter pour exporter vos données. Vous pouvez accéder à l'une ou l'autre méthode pour exporter vos données à partir du flux Data Wrangler. Pour obtenir des informations sur l'utilisation de ces méthodes, consultez Exporter vers Amazon S3.

Filtrage des données

Utilisez Data Wrangler pour filtrer les données de vos colonnes. Lorsque vous filtrez les données d'une colonne, vous spécifiez les champs suivants :

Vous pouvez filtrer les conditions suivantes :

Pour une colonne contenant les catégories male et female, vous pouvez filtrer toutes les valeurs male. Vous pouvez également filtrer toutes les valeurs female. Comme il n'y a que des valeurs male et female dans la colonne, le filtre renvoie une colonne contenant uniquement des valeurs female.

Vous pouvez également ajouter plusieurs filtres. Les filtres peuvent être appliqués sur plusieurs colonnes ou sur la même colonne. Par exemple, si vous créez une colonne dont les valeurs se situent uniquement dans une certaine plage, vous ajoutez deux filtres différents. L'un des filtres indique que la colonne doit avoir des valeurs supérieures à la valeur que vous fournissez. L'autre filtre indique que la colonne doit avoir des valeurs inférieures à la valeur que vous fournissez.

Utilisez la procédure suivante pour ajouter la transformation de filtre à vos données.

Mappage de colonnes pour Amazon Personalize

Data Wrangler s'intègre à Amazon Personalize, un service de machine learning entièrement géré qui génère des recommandations d'éléments et des segments d'utilisateurs. Vous pouvez utiliser la transformation Mapper des colonnes pour Amazon Personalize afin de convertir vos données dans un format interprétable par Amazon Personalize. Pour plus d'informations sur les transformations spécifiques à Amazon Personalize, consultez Importation de données à l'aide d'Amazon SageMaker Data Wrangler. Pour plus d'informations sur Amazon Personalize, consultez Qu'est-ce qu'Amazon Personalize ?.