Préparation des données pour l’apprentissage automatique

La première étape du processus d’apprentissage automatique (Machine Learning) consiste à déterminer ce que nous souhaitons prédire. Une fois que cela est établi, l’étape suivante est la “préparation des données” et l’ingénierie des caractéristiques (Features Engineering), c’est ce qui demande la majeure partie de notre temps.

La préparation des données consiste à effectuer la récolte de données, la réconciliation (Data Wrangling) et même l’enrichissement si nécessaire.

Récolte des données

Premièrement, rassemblez les données dont vous aurez besoin pour l’apprentissage automatique. Veillez à les rassembler sous une forme consolidée, afin qu’elles soient toutes contenues dans une seule table (Flat Table).

Pour cela, vous pouvez utiliser l’outil qui vous convient le plus. Par exemple :

• Outils de bases de données relationnelles (SQL)
• Jupiter notebook
• Excel
• Azure ML
• R Studio

Réconciliation (Data Wrangling)

il s’agit de préparer les données pour les rendre utilisables par des algorithmes d’apprentissage automatique. (Nettoyage des données, décomposition, agrégation, mise en forme et transformation, mise à l’échelle “Data Scaling”.)

Nettoyage des données

Il s’agit de trouver les valeurs “Null”, les valeurs manquantes et les données dupliquées.

Exemple de valeurs manquantes :

• blanks
• NULL
• ?
• N/A, NaN, NA
• 9999999
• Unknown

 

data_frame dans ce code est notre ensemble de données sur “pandas”.

#Count the number of missing values in each row in Pandas dataframe
data_frame.isnull().sum()

#Row		0
Title		0
Type		0
Price		1
Format		1
Pages		1
NumberSales	0

Si certaines lignes ont des données manquantes dans plusieurs colonnes importantes, nous pouvons envisager de les supprimer. En utilisant la requête DELETE en SQL ou pandas.drop() en Python.

On peut parfois remplacer la valeur manquante par zéro, la valeur la plus fréquente ou par la moyenne, cela dépend des valeurs et du type de colonne. En utilisant la requête de mise à jour UPDATE en SQL ou en utilisant pandas.fillna() en Python.

Dans le code suivant, nous remplaçons les valeurs manquantes de “Pages” par la moyenne :

global_mean = data_frame.mean()
data_frame['Pages'] = data_frame['Pages'].fillna(global_mean['Pages'])
data_frame.isnull().sum()

#Row		0
Title		0
Type		0
Price		1
Format		1
Pages		0
NumberSales	0

Et la valeur la plus fréquente, pour les valeurs manquantes de “Format” :

#Counts of unique values
data_frame["Format"].value_counts()

Big		2
Small		1
Name: Format, dtype: int64

Comme “Big” est la valeur la plus fréquente dans notre cas, nous allons donc remplacer toutes les valeurs manquantes par “Big”.

# Replace missing "Format" value with the most common value “Big”
data_frame["Format"] = data_frame['Format'].fillna("Big")

data_frame["Format"].value_counts()

Big		3
Small		1

Le data_frame résultant serait :

Assurez-vous de ne pas avoir de doublons. S’il y en a, supprimez les lignes dupliquées (DELETE en SQL et pandas.drop() en Python).

Décomposition des données

Les colonnes de texte contiennent parfois plusieurs informations ; séparez-les en autant de colonnes dédiées que nécessaire. Si certaines colonnes représentent des catégories, convertissez-les en colonnes de catégories dédiées.

Dans notre exemple, la colonne “Type” contient plus d’une information, nous pouvons clairement la diviser en 3 colonnes comme ci-dessous (Style, Type et Readers), et faire ensuite le même processus pour les valeurs manquantes s’il y a lieu.

Agrégation des données

Il s’agit du regroupement des données, si c’est pertinent.

Dans notre exemple, le nombre de ventes est en fait déjà une agrégation de données. Au départ, la base de données présentait des lignes de transactions, que nous avons agrégées pour obtenir le nombre de livres vendus par mois.

Mise en forme et transformation des données

Cela implique la conversion de données catégorielles en données numériques, puisque les algorithmes ne peuvent utiliser que des valeurs numériques.

Les colonnes Style, Kind, Readers et Format sont clairement des colonnes de type catégorie. Nous allons voir deux façons de faire la transformation.

1. Premièrement méthode, convertir toutes les valeurs de type catégorie en valeurs numériques en remplaçant toutes les valeurs uniques par des nombres séquentiels.

Exemple de la façon de le faire en Python :

cleanup_nums = {"Format": {"Big": 1, "Small": 2},
                "Style": {"Serie": 1, "One Book": 2},
                "Kind": {"Learning": 1, "Story": 2},
                "Readers": {"Adults": 1, "Teenagers": 2, "Kids": 3}
               }
data_frame.replace(cleanup_nums, inplace=True)

data_frame.head()

Ce qui nous donne :

2. La deuxième méthode est celle des “dummies” : elle consiste à créer une colonne séparée pour chacune des valeurs uniques des colonnes de catégories. Comme la valeur de chaque colonne est binaire (0/1), vous ne pouvez donc avoir qu’une seule valeur 1 dans les colonnes nouvellement générées.

Faire cette conversion en Python :

# Convert category to dummy
data_frame = pd.get_dummies(data_frame, columns=["Format"])
data_frame = pd.get_dummies(data_frame, columns=["Style"])
data_frame = pd.get_dummies(data_frame, columns=["Kind"])
data_frame = pd.get_dummies(data_frame, columns=["Readers"])
data_frame.head()

Vous remarquerez ci-dessous que “Format” a généré deux colonnes, “Format_Big” et “Format_Small”, parce que la colonne a deux valeurs distinctes, “Big” et “Small”. Cependant, “Readers” génère trois colonnes différentes parce qu’elle a trois valeurs distinctes “Adults”, “Teenagers” et “Kids”.

* Les colonnes “Id” et “Title” ne seront pas utilisées pendant notre processus de ML.

L’avantage de la méthode des dummies est que toutes les valeurs ont le même poids. Cependant, comme elle ajoute autant de nouvelles colonnes que le nombre de catégories distinctes de chaque colonne initiale, soyez prudent avec l’utilisation de cette méthode si vous avez déjà de nombreuses colonnes à prendre en compte dans votre processus de ML.

D’autre part, si vous procédez en remplaçant les valeurs de catégories par des valeurs numériques séquentielles, cela peut avantager certaines catégories si leur nombre est plus élevé. Pour “Readers”, par exemple, la catégorie 3 aura un impact trois fois plus important que la catégorie 1. Imaginez le cas où vous aurez une colonne avec un très grand nombre de catégories.

Mise à l’échelle (Data Scaling)

Cela permet d’obtenir des données numériques à une échelle commune, si ce n’est déjà le cas. La mise à l’échelle des données ne s’applique pas au label ou aux colonnes de catégories. Elle est nécessaire lorsqu’il y a une grande variation entre les plages de valeurs des différentes colonnes.

Nous devons procéder à une mise à l’échelle, pour donner encore une fois le même poids à toutes les colonnes.

Dans notre exemple, nous allons mettre à l’échelle les colonnes “Price” et “Pages” :

1. Price [10, 16]
2. Pages [85, 120]

Nous devons mettre ces deux colonnes à l’échelle, sinon la colonne “Pages” aura plus de poids sur le résultat que la colonne “Price”.

Il existe de nombreuses méthodes de mise à l’échelle. Pour notre exemple, nous utiliserons le MinMaxScaler de 0 à 1.

#scale the columns
scaler = MinMaxScaler()
rescaledX = scaler.fit_transform(X[:,0:2])

#put the scaled columns in dataframe
colnames = [
    'Price',
    'Pages'
]
df_scaled = pd.DataFrame(rescaledX, columns=colnames)

# Replace the original columns with the new scaled
data_frame_scalled = data_frame
data_frame_scalled[colnames] = df_scaled[colnames]

data_frame_scalled.head()

Le résultat est le suivant :

Comme indiqué, il existe de nombreuses autres méthodes de mise à l’échelle ; la manière et le moment opportun d’utiliser chacune d’entre elles feront l’objet d’un prochain article.