Ingénierie de l’apprentissage automatique

CSI 4506 - Automne 2024

Marcel Turcotte

Version: nov. 14, 2024 08h45

Préambule

Citation du jour

;document.getElementById("tweet-39572").innerHTML = tweet["html"];

Hugging Face est une entreprise d’IA et une communauté open-source qui fournit des outils pour le traitement du langage naturel (NLP) et d’autres tâches d’apprentissage automatique. La société est devenue largement connue pour sa bibliothèque Transformers, qui propose des modèles pré-entraînés et une API facile à utiliser pour déployer des modèles de pointe tels que BERT, GPT, T5, et bien d’autres. Ces modèles peuvent être appliqués à des tâches comme la génération de texte, la traduction, la réponse aux questions, l’analyse des sentiments, et bien plus encore.

Clément Delangue, PDG de Hugging Face, discute de l’IA pour le bien commun. Plus précisément, le développement par IBM et la NASA d’un modèle d’IA open source pour l’analyse météorologique et climatique.

Objectifs d’apprentissage

1. Taille des données et son impact :
   • Reconnaître l’influence de la taille du jeu de données sur les performances du modèle.
   • Discuter du concept d’augmentation des données et de son rôle dans l’amélioration de la robustesse du modèle.
   • Explorer “l’efficacité déraisonnable des données” dans l’apprentissage automatique.
2. Ingénierie des attributs et encodage :
   • Expliquer l’importance de l’extraction des attributs et le rôle de la connaissance du domaine.
   • Comparer différentes méthodes d’encodage des données catégorielles, telles que l’encodage one-hot et l’encodage ordinal.
   • Justifier le choix des méthodes d’encodage en fonction de la nature des données et du problème.
3. Techniques de prétraitement des données :
   • Appliquer la normalisation et la standardisation pour la mise à l’échelle des attributs.
   • Décider quand utiliser la normalisation ou la standardisation en fonction des attributs des données.
   • Gérer les valeurs manquantes en utilisant diverses stratégies d’imputation et comprendre leurs implications.
4. Résoudre le déséquilibre des classes :
   • Définir le problème du déséquilibre des classes et son impact sur les performances du modèle.
   • Explorer des solutions telles que le suréchantillonnage, les ajustements algorithmiques et la génération de données synthétiques (par exemple, SMOTE).
   • Comprendre l’importance d’appliquer ces techniques de manière appropriée pour éviter les fuites de données.
5. Intégration des connaissances dans des applications pratiques :
   • Appliquer les concepts appris à des ensembles de données réels (par exemple, ensembles de données OpenML tels que ‘diabetes’ et ‘adult’).
   • Interpréter et analyser les résultats des évaluations de modèles et des expériences.
   • Développer une compréhension complète du pipeline d’apprentissage automatique de bout en bout.

Les objectifs d’apprentissage ci-haut ont été générés par le modèle d’OpenAI, o1, à partir du contenu du cours.

Les données

La taille compte

“Cependant, ces résultats suggèrent que nous devrions peut-être reconsidérer l’équilibre entre passer du temps et de l’argent à développer des algorithmes, contre investir dans le développement de corpus.”

Attribution: Banko et Brill (2001)

Efficacité déraisonnable des données

La présentation de Peter Norvig, intitulée “L’efficacité déraisonnable des données”, dure un peu plus d’une heure. Il est à noter que l’article sur lequel cette présentation est basée a été publié en 2009, avant le succès d’AlexNet.

Les améliorations substantielles observées avec AlexNet en 2012 ont mis en évidence les avantages de l’entraînement de réseaux neuronaux profonds sur de grands ensembles d’images.

De même, les modèles modernes tels que GPT, Gemini, Claude et LLaMA ont réalisé des progrès significatifs dans les capacités linguistiques en s’entraînant sur des quantités massives de textes, englobant presque toute la littérature écrite depuis le début de la civilisation humaine.

Les lois d’échelle neuronale décrivent comment les performances des réseaux neuronaux varient en fonction de facteurs clés comme la taille des ensembles de données, le nombre de paramètres et les coûts computationnels Kaplan et al. (2020).

Halevy, Norvig, et Pereira (2009) et Kaplan et al. (2020).

Définition

L’augmentation des données (data augmentation) est une technique utilisée pour accroître la diversité d’un ensemble de données en appliquant diverses transformations aux données existantes.

But: Améliorer la robustesse et la capacité de généralisation des modèles d’apprentissage automatique.

Augmentation des données

• Pour les images: Rotations, translations, redimensionnement, renversement, ajout de bruit, etc.
  • How to find ancient geoglyphs using machine learning?, Sakai et al. (2024)
• Pour les textes: Remplacement de synonymes, insertion aléatoire, suppression, et permutation des mots.

Les réseaux antagonistes génératifs (GANs) (une forme d’apprentissage profond) peuvent être utilisés pour générer de nouvelles données synthétiques qui imitent la distribution de l’ensemble de données original. Voir aussi : Shumailov et al. (2024).

L’ingénierie de l’apprentissage automatique

Ingénierie en apprentissage automatique

1. Collecter des données adéquates.
2. Extraire des attributs à partir des données brutes :
   • Ce processus est laborieux.
   • Il nécessite de la créativité.
   • Une connaissance du domaine est très bénéfique.

Ensemble de données - Adult

import numpy as np
np.random.seed(42)

from sklearn.datasets import fetch_openml

adult = fetch_openml(name='adult', version=2)
print(adult.DESCR)

Ensemble de données - Adult

Author: Ronny Kohavi and Barry Becker
Source: UCI - 1996
Please cite: Ron Kohavi, “Scaling Up the Accuracy of Naive-Bayes Classifiers: a Decision-Tree Hybrid”, Proceedings of the Second International Conference on Knowledge Discovery and Data Mining, 1996

Prediction task is to determine whether a person makes over 50K a year. Extraction was done by Barry Becker from the 1994 Census database. A set of reasonably clean records was extracted using the following conditions: ((AAGE>16) && (AGI>100) && (AFNLWGT>1)&& (HRSWK>0))

This is the original version from the UCI repository, with training and test sets merged.

Variable description

Variables are all self-explanatory except fnlwgt. This is a proxy for the demographic background of the people: “People with similar demographic characteristics should have similar weights”. This similarity-statement is not transferable across the 51 different states.

Description from the donor of the database:

The weights on the CPS files are controlled to independent estimates of the civilian noninstitutional population of the US. These are prepared monthly for us by Population Division here at the Census Bureau. We use 3 sets of controls. These are: 1. A single cell estimate of the population 16+ for each state. 2. Controls for Hispanic Origin by age and sex. 3. Controls by Race, age and sex.

We use all three sets of controls in our weighting program and “rake” through them 6 times so that by the end we come back to all the controls we used. The term estimate refers to population totals derived from CPS by creating “weighted tallies” of any specified socio-economic characteristics of the population. People with similar demographic characteristics should have similar weights. There is one important caveat to remember about this statement. That is that since the CPS sample is actually a collection of 51 state samples, each with its own probability of selection, the statement only applies within state.

Relevant papers

Ronny Kohavi and Barry Becker. Data Mining and Visualization, Silicon Graphics.
e-mail: ronnyk ‘@’ live.com for questions.

Downloaded from openml.org.

Adult - Workclass

adult.data['workclass'].unique()

['Private', 'Local-gov', NaN, 'Self-emp-not-inc', 'Federal-gov', 'State-gov', 'Self-emp-inc', 'Without-pay', 'Never-worked']
Categories (8, object): ['Federal-gov', 'Local-gov', 'Never-worked', 'Private', 'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay']

Adult - Education

adult.data['education'].unique()

['11th', 'HS-grad', 'Assoc-acdm', 'Some-college', '10th', ..., 'Assoc-voc', '9th', '12th', '1st-4th', 'Preschool']
Length: 16
Categories (16, object): ['10th', '11th', '12th', '1st-4th', ..., 'Masters', 'Preschool', 'Prof-school', 'Some-college']

Adult - Marital Status

adult.data['marital-status'].unique()

['Never-married', 'Married-civ-spouse', 'Widowed', 'Divorced', 'Separated', 'Married-spouse-absent', 'Married-AF-spouse']
Categories (7, object): ['Divorced', 'Married-AF-spouse', 'Married-civ-spouse', 'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed']

Données catégorielles

Points clés sur la représentation des données

• Représentation numérique: Certains algorithmes d’apprentissage nécessitent que les données soient sous forme numérique.
• Exemple d’attribut: Considérons l’attribut workclass, qui a 8 valeurs distinctes telles que ‘Federal-gov’, ‘Local-gov’, etc.

Méthodes d’encodage

Quelle méthode d’encodage est préférable et pourquoi?

1. w = 1, 2, 3, 4, 5, 6, 7, ou 8
2. w = [0,0,0], [0,0,1], [0,1,0], \(\ldots\), ou [1,1,1]
3. w = [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], \(\ldots\), ou [0,0,0,0,0,0,0,1]

Encodage pour les données catégorielles

Encodage One-Hot: Cette méthode est à privilégier pour les données catégorielles.

• Augmente la dimensionnalité: L’encodage One-Hot augmente la dimensionnalité des vecteurs de attributs.
• Évite les biais: Les autres méthodes d’encodage peuvent introduire des biais.
• Exemple de biais: En utilisant la première méthode, w = 1, 2, 3, etc., cela implique que ‘Federal-gov’ et ‘Local-gov’ sont similaires, tandis que ‘Federal-gov’ et ‘Without-pay’ ne le sont pas.
• Similitude trompeuse: La deuxième méthode, w = [0,0,0], [0,0,1], etc., pourrait induire en erreur l’algorithme en suggérant une similarité basée sur des schémas numériques.

Définition

Encodage One-Hot: Une technique qui convertit les variables catégorielles en une représentation vectorielle binaire, où chaque catégorie est représentée par un vecteur avec un seul ‘1’ et tous les autres éléments à ‘0’.

Plus tard, nous considérerons un autre encodage appelé embedding.

OneHotEncoder

from numpy import array
from sklearn.preprocessing import OneHotEncoder

work = adult.data[['workclass']]

onehot_encoder = OneHotEncoder()

onehot_encoder.fit(work)
values_encoded = onehot_encoder.transform(work)

for i in range(5): print(values_encoded.toarray()[i])

[0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 1.]

Un étudiant de mon groupe de recherche a rencontré un problème difficile à déboguer. Il a par erreur créé un nouvel encodeur pour l’ensemble de test en utilisant onehot_encoder.fit(X_test['some_attribute']), ce qui a produit une représentation vectorielle différente de celle utilisée lors de l’entraînement. Par conséquent, les résultats sur l’ensemble d’entraînement étaient médiocres, tandis que les résultats sur l’ensemble de test semblaient satisfaisants.

Bien que Pandas propose une méthode appelée get_dummies() pour l’encodage One-Hot, il est important de noter les distinctions suivantes :

• Mémoire des catégories: OneHotEncoder conserve les catégories sur lesquelles il a été entraîné, tandis que get_dummies() ne le fait pas.
• Cohérence en production: Il est essentiel d’utiliser le même schéma d’encodage en production que celui utilisé lors de l’entraînement pour garantir des résultats précis.
• Différences de longueur de vecteur: Si get_dummies() rencontre un nombre différent de catégories dans de nouvelles données, il produira des vecteurs de longueurs variables, ce qui peut entraîner des erreurs.
• Gestion des valeurs manquantes: Lors de la gestion des valeurs manquantes, get_dummies() génère une colonne supplémentaire pour les prendre en compte.

La cohérence est cruciale: Assurez-vous d’utiliser le même encodage pour : ensemble de validation, ensemble de test, et données en production.

Étude de cas

• Ensemble de données : Heart Disease
  • Exemples : 303, Attributs : 13, Cible : Présence/absence de maladie
• Données catégorielles :
  • sexe : 1 = homme, 0 = femme
  • cp (type de douleur thoracique) :
    • 1 : Angine typique
    • 2 : Angine atypique
    • 3 : Douleur non angineuse
    • 4 : Asymptomatique
  • Autres : ‘fbs’, ‘restecg’, ‘exang’, ‘slope’, ‘thal’

Voici quelques suggestions pour des recherches ultérieures :

• Évaluer l’impact de l’omission des valeurs manquantes sur l’ensemble de données.
• Implémenter l’ajustement des hyperparamètres pour déterminer si la régularisation \(L_1\) ou \(L_2\) améliore les performances du modèle.

Pour simplifier l’analyse : Les exemples avec des valeurs manquantes ont été supprimés, aucun ajustement d’hyperparamètres n’a été effectué, les valeurs numériques ont été mises à l’échelle pour la convergence des solveurs.

Étude de cas

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_openml
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Chargement de l'ensemble de données 'Heart-Disease' depuis OpenML
data = fetch_openml(name='Heart-Disease', version=1, as_frame=True)
df = data.frame

# Remplacer '?' par NaN et convertir les colonnes en numérique
for col in df.columns:
    df[col] = pd.to_numeric(df[col], errors='coerce')

# Supprimer les lignes avec des valeurs manquantes
df.dropna(inplace=True)

# Définir les attributs et la cible
X = df.drop(columns=['target'])
y = df['target']

# Colonnes à encoder avec OneHotEncoder
colonnes_a_encoder = ['sex', 'cp', 'fbs', 'restecg', 'exang', 'slope', 'thal']

# Identifier les colonnes numériques
colonnes_numeriques = X.columns.difference(colonnes_a_encoder)

# Diviser l'ensemble de données en ensembles d'entraînement et de test avant les transformations
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Appliquer OneHotEncoder et StandardScaler à l'aide de ColumnTransformer
column_transformer = ColumnTransformer(
    transformers=[
        ('onehot', OneHotEncoder(), colonnes_a_encoder),
        ('scaler', StandardScaler(), colonnes_numeriques)
    ]
)

# Ajuster le transformateur sur les données d'entraînement et transformer les données d'entraînement et de test
X_train_processed = column_transformer.fit_transform(X_train)
X_test_processed = column_transformer.transform(X_test)

# Initialiser et entraîner le modèle de régression logistique
model = LogisticRegression(max_iter=1000)
model = model.fit(X_train_processed, y_train)

Dans le cadre de l’utilisation de ColumnTransformer, le second élément des triplets, habituellement un estimateur, peut également être remplacé par les options drop ou passthrough. L’option drop permet d’exclure la colonne concernée du processus de transformation, tandis que passthrough préserve la colonne dans son état initial, sans apporter de modifications.

Étude de cas - résultats

# Prédire et évaluer le modèle
y_pred = model.predict(X_test_processed)

print(classification_report(y_test, y_pred))

              precision    recall  f1-score   support

         0.0       0.87      0.93      0.90        29
         1.0       0.93      0.88      0.90        32

    accuracy                           0.90        61
   macro avg       0.90      0.90      0.90        61
weighted avg       0.90      0.90      0.90        61

Étude de cas - douleur thoracique (cp)

# Récupérer les noms des attributs après transformation à l'aide de get_feature_names_out()
feature_names = column_transformer.get_feature_names_out()

# Obtenir les coefficients et les associer aux noms des attributs
coefficients = model.coef_[0]

# Créer un DataFrame avec les noms des attributs et les coefficients
coef_df = pd.DataFrame({
    'Attribut': feature_names,
    'Coefficient': coefficients
})

# Afficher les coefficients associés à 'cp'
cp_features = coef_df[coef_df['Attribut'].str.contains('_cp')]
print("\nCoefficients associés à 'cp' :")
print(cp_features)

Coefficients associés à 'cp' :
         Attribut  Coefficient
2  onehot__cp_0.0    -1.013382
3  onehot__cp_1.0    -0.212284
4  onehot__cp_2.0     0.599934
5  onehot__cp_3.0     0.628824

Étude de cas - coefficients

# Visualiser les coefficients

plt.figure(figsize=(8, 6))
plt.barh(coef_df['Attribut'], coef_df['Coefficient'])
plt.title('Coefficients des attributs')
plt.xlabel('Valeur du coefficient')
plt.ylabel('Attribut')
plt.tight_layout()
plt.show()

Les coefficients positifs dans un modèle de régression logistique signifient que des valeurs plus élevées de l’attribut correspondant contribuent positivement à la probabilité qu’un exemple appartienne à ‘target = 1.0’. Les coefficients négatifs indiquent l’effet opposé.

Étude de cas - coefficients

Étude de cas - coefficients (triés)

# Visualiser les coefficients

plt.figure(figsize=(8, 6))
coef_df.sort_values(by='Coefficient', inplace=True)
plt.barh(coef_df['Attribut'], coef_df['Coefficient'])
plt.title('Coefficients des attributs')
plt.xlabel('Valeur du coefficient')
plt.ylabel('Attribut')
plt.tight_layout()
plt.show()

Étude de cas - coefficients (triés)

Définition

L’encodage ordinal est une technique qui attribue des valeurs numériques aux attributs catégoriels en fonction de leur ordre ou de leur classement intrinsèque.

Encodage ordinal

Pour les attributs avec des valeurs comme ‘Mauvais’, ‘Moyen’, et ‘Bon’, un encodage ordinal aurait du sens.

Cependant !

from numpy import array
from sklearn.preprocessing import OrdinalEncoder

X =[['Mauvais'], ['Moyen'], ['Bon'], ['Moyen'], ['Moyen']]

encoder = OrdinalEncoder()

encoder.fit(X)
encoder.transform(X)

array([[1.],
       [2.],
       [0.],
       [2.],
       [2.]])

OrdinalEncoder (révisé)

from numpy import array
from sklearn.preprocessing import OrdinalEncoder

X =[['Mauvais'], ['Moyen'], ['Bon'], ['Moyen'], ['Moyen']]

encoder = OrdinalEncoder(categories=[['Mauvais', 'Moyen', 'Bon']])

encoder.fit(X)

X_encoded = encoder.transform(X)

X_encoded

array([[0.],
       [1.],
       [2.],
       [1.],
       [1.]])

L’ordre souhaité des catégories doit être fourni explicitement à l’encodeur ; sinon, il adopte l’ordre alphabétique par défaut.

Un encodeur ordinal est approprié lorsque les attributs catégoriels ont un ordre ou un classement clair et intrinsèque, comme ‘Faible’, ‘Moyen’, et ‘Élevé’, ou ‘Mauvais’, ‘Moyen’, et ‘Bon’. Cette méthode d’encodage préserve les relations ordinales entre les catégories.

Lorsque les données sont intrinsèquement ordinales, cet encodage est plus compact et peut être avantageux pour les modèles d’apprentissage automatique. Cependant, si l’ordinalité des données est incertaine, il est plus sûr d’utiliser un OneHotEncoder.

Définition

La discrétisation consiste à regrouper des valeurs ordinales en catégories discrètes.

Aussi appelée binning, bucketing, ou quantification.

Ingénierie des attributs : Binning

Exemple : Catégoriser les âges en groupes tels que ‘nourrisson’, ‘enfant’, ‘adolescent’, ‘adulte’, et ‘senior’.

Avantages :

• Permet à l’algorithme d’apprendre efficacement avec moins d’exemples d’entraînement.

Inconvénients :

• Nécessite une expertise dans le domaine pour définir des catégories significatives.
• Peut manquer de généralisabilité ; par exemple, l’âge de départ pour ‘senior’ pourrait être 60, 65 ou 70¹.

Fournir des indices ou des catégories prédéfinies peut aider un algorithme d’arbre de décision à générer des arbres plus compacts, car cela réduit la nécessité pour le classificateur d’apprendre indépendamment les limites de décision.

Cependant, introduire un tel biais fort peut nuire à la capacité de l’algorithme à découvrir des limites de décision significatives par lui-même.

La validation croisée est un moyen efficace pour déterminer la meilleure méthode d’encodage, mais il est essentiel de retenir l’ensemble de test jusqu’à la phase finale d’évaluation du projet pour éviter toute fuite de données et garantir une évaluation impartiale.

1. Votre professeur s’inquiète de votre choix de seuil

FunctionTransformer

import pandas as pd
import numpy as np
from sklearn.preprocessing import FunctionTransformer

bins = [0, 1, 13, 20, 60, np.inf]
labels = ['nourrisson', 'enfant', 'adolescent', 'adulte', 'senior']

transformer = FunctionTransformer(
    pd.cut, kw_args={'bins': bins, 'labels': labels, 'retbins': False}
)

X = np.array([0.5, 2, 15, 25, 97])
transformer.fit_transform(X)

['nourrisson', 'enfant', 'adolescent', 'adulte', 'senior']
Categories (5, object): ['nourrisson' < 'enfant' < 'adolescent' < 'adulte' < 'senior']

Voir aussi : KBinsDiscretizer

Mise à l’échelle

Normalisation

Les algorithmes d’apprentissage fonctionnent de manière optimale lorsque les valeurs des attributs ont des plages similaires, telles que [-1,1] ou [0,1].

• Cela accélère l’optimisation (par exemple, descente de gradient).

Normalisation: \[ \frac{x_i^{(j)} - \min^{(j)}}{\max^{(j)} - \min^{(j)}} \]

Voir : sklearn.preprocessing.MinMaxScaler

Standardisation

La standardisation (également appelée normalisation par score-z) transforme chaque attribut pour qu’elle ait une distribution normale avec une moyenne (\(\mu\)) de 0 et un écart type (\(\sigma\)) de 1.

\[ \frac{x_i^{(j)} - \mu^{(j)}}{\sigma^{(j)}} \]

Remarque : Les valeurs ne sont pas bornées !

Voir : sklearn.preprocessing.StandardScaler

Standardisation ou normalisation ?

• Traitez la mise à l’échelle comme un hyperparamètre et évaluez à la fois normalisation et standardisation.
• La standardisation est généralement plus robuste aux valeurs aberrantes (outliers) que la normalisation.
• Directives de Andriy Burkov (2019), § 5 :
  • Utilisez la standardisation pour les tâches d’apprentissage non supervisé.
  • Utilisez la standardisation si les attributs sont approximativement distribuées normalement.
  • Préférez la standardisation en présence de valeurs aberrantes.
  • Sinon, utilisez la normalisation.

Voyez-vous pourquoi la standardisation est généralement plus robuste aux valeurs aberrantes que la normalisation ?

Une stratégie efficace pour atténuer l’impact des valeurs aberrantes dans les données est d’appliquer une transformation logarithmique aux valeurs. Cette technique réduit l’asymétrie des données, diminuant ainsi l’influence disproportionnée des valeurs extrêmes.

Étude de cas - distribution normale

import numpy as np
np.random.seed(7)

# Charactéristiques de l'échantillon

sample_size = 1000
mu = 57
sigma = 7

# Générer des valeurs

norm_values = sigma * np.random.randn(sample_size) + mu

# Ajout de trois valeurs aberrantes

norm_values = np.append(norm_values, [92, 95, 98])

Étude de cas - distribution normale

Logarithme

Logarithme des valeurs d’une distribution normale contenant des valeurs aberrantes.

Normalisation

Normalisation (MinMaxScaler) des valeurs d’une distribution normale contenant des valeurs aberrantes.

Standardisation

Standardisation (StandardScaler) des valeurs d’une distribution normale contenant des valeurs aberrantes.

Logarithme & Standardisation

Standardisation (StandardScaler) des valeurs d’une distribution normale contenant des valeurs aberrantes.

Valeurs manquantes

Définition

Les valeurs manquantes font référence à l’absence de données ou de valeurs dans un ensemble de données là où une valeur est attendue.

Exemple: L’âge est souvent une bonne illustration, car certains patients peuvent ne pas divulguer leur âge pour des raisons de confidentialité.

Gestion des valeurs manquantes

• Supprimer les exemples:
  • Faisable si l’ensemble de données est grand et que l’issue n’est pas affectée.
• Supprimer les attributs :
  • Convient si cela n’affecte pas le résultat du projet.
• Utiliser des algorithmes qui gèrent les données manquantes :
  • Exemple : XGBoost
  • Remarque : Certains algorithmes comme sklearn.linear_model.LinearRegression ne peuvent pas traiter les valeurs manquantes.
• Imputation des données :
  • Remplacer les valeurs manquantes par des valeurs calculées.

Définition

L’imputation des données est le processus consistant à remplacer les valeurs manquantes dans un ensemble de données par des valeurs substituées, généralement en utilisant des méthodes statistiques ou d’apprentissage automatique.

Stratégie d’imputation des données

Remplacer les valeurs manquantes par la moyenne ou la médiane de l’attribut.

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy="median")

X = imputer.fit_transform(X)

• Inconvénients : Ignore les corrélations entre les attributs et les relations complexes.

• Imputation par la mode : Remplacer les valeurs manquantes par la valeur la plus fréquente ; ignore également les corrélations entre les attributs.

L’imputation des données repose souvent sur plusieurs hypothèses qui peuvent ne pas toujours être valides.

Hypothèse de randomisation : De nombreuses méthodes (comme l’imputation par moyenne/médiane) supposent que l’absence de données est indépendante de toutes autres données disponibles.

Biais du modèle : Des hypothèses de randomisation incorrectes peuvent entraîner des estimations biaisées et des conclusions erronées.

Perte d’information : L’imputation peut obscurcir des schémas dans les données, entraînant la perte d’informations précieuses pour des modèles avancés.

Soyez prudent !

Stratégie d’imputation des données

Méthode de valeur spéciale : Remplacer les valeurs manquantes par une valeur en dehors de la plage normale (par exemple, utiliser -1 ou 2 pour des données normalisées entre [0,1]).

• Objectif : Permettre à l’algorithme d’apprentissage de reconnaître et de gérer correctement les valeurs manquantes.

Stratégie d’imputation des données

• Imputation par valeur intermédiaire : Remplacer les valeurs manquantes par une valeur au milieu de la plage normale (par exemple, utiliser 0 pour des données distribuées entre [-1,1]).

  • Données catégorielles : Utiliser de petites valeurs numériques non nulles.
    • Exemple : Utiliser [0.25, 0.25, 0.25, 0.25] au lieu de [1, 0, 0, 0] pour ‘Mauvais’, [0, 1, 0, 0] pour ‘Moyen’, [0, 0, 1, 0] pour ‘Bon’, et [0, 0, 0, 1] pour ‘Excellent’.
  • Objectif : Minimiser l’impact des valeurs imputées sur les résultats.

Choix de la méthode : L’efficacité des méthodes d’imputation peut varier, et il est essentiel de comparer plusieurs techniques pour déterminer la meilleure approche pour votre ensemble de données spécifique.

Approche alternative

• Définition du problème : Prédire des étiquettes inconnues (manquantes) pour des exemples donnés.
• Avez-vous déjà rencontré ce type de problème auparavant ?
• Pertinence : Cela peut être formulé comme un problème d’apprentissage supervisé.
  • Soit \(\hat{x_i}\) un nouvel exemple : \([x_i^{(1)}, x_i^{(2)}, \ldots, x_i^{(j-1)}, x_i^{(j+1)}, \ldots, x_i^{(D)}]\).
  • Soit \(\hat{y}_i = x_i^{j}\).
  • Ensemble d’entraînement : Utiliser des exemples où \(x_i^{j}\) n’est pas manquant.
  • Méthode : Entraîner un classificateur sur cet ensemble pour prédire (imputer) les valeurs manquantes.

Utiliser l’apprentissage automatique pour l’imputation

1. Méthode basée sur les instances :

   • Utiliser \(k\) plus proches voisins (k-NN) pour trouver les \(k\) exemples les plus proches et imputer à l’aide des valeurs non manquantes du voisinage.

2. Méthodes basées sur des modèles :

   • Utiliser des techniques avancées telles que les forêts aléatoires, la décomposition tensorielle ou les réseaux neuronaux profonds.

Pourquoi utiliser ces méthodes ?

• Avantages :
  • Traitent efficacement les relations complexes et les corrélations entre les attributs.
• Inconvénients :
  • Coût-intensif en termes de temps de travail, de CPU et de ressources mémoire.

Déséquilibre des classes

Définition

Le problème de déséquilibre des classes (class imbalance) survient lorsqu’un grand nombre d’exemples appartient à une classe majoritaire, tandis qu’un nombre relativement faible d’exemples appartient à une ou plusieurs classes minoritaires.

Les modèles ont tendance à favoriser la classe majoritaire, ce qui conduit à de mauvaises performances sur la classe minoritaire.

Les mesures d’évaluation standard comme l’exactitude (accuracy) peuvent être trompeuses en présence d’un déséquilibre des classes.

Solutions

• Rééchantillonnage :
  • Techniques comme le suréchantillonnage de la classe minoritaire ou le sous-échantillonnage de la classe majoritaire.
• Ajustements algorithmiques :
  • Utiliser l’apprentissage sensible aux coûts ou ajuster les seuils de décision.
• Données synthétiques :
  • Générer des exemples synthétiques pour la classe minoritaire en utilisant des méthodes comme SMOTE (Synthetic Minority Over-sampling Technique).

L’article original de Chawla et al. (2002) présente SMOTE, tandis que Pradipta et al. (2021) fournit un examen récent des méthodes.

Suréchantillonnage

• Inconvénient : Le suréchantillonnage peut entraîner un surapprentissage, surtout si les exemples synthétiques sont très similaires aux exemples existants.
  • Impact : Le modèle peut bien fonctionner sur l’ensemble d’entraînement mais mal généraliser sur de nouvelles données.

Sous-échantillonnage

• Inconvénient : Perte d’information due à la réduction du nombre d’exemples dans la classe majoritaire.
  • Impact : Risque de sous-apprentissage et modèle moins précis.
• Réduction des performances du modèle : Un ensemble d’entraînement plus petit peut ne pas capturer la complexité du problème.
  • Impact : Peut entraîner un modèle moins précis et moins robuste.

Appliquer les solutions uniquement à l’ensemble d’entraînement pour éviter les fuites de données.

Prologue

Lectures complémentaires

• Machine Learning Engineering par Andriy Burkov (A. Burkov 2020).

• Traite de la collecte de données, du stockage, du prétraitement, de l’ingénierie des caractéristiques, du test et du débogage des modèles, du déploiement, de la mise hors service, et de la maintenance.

• Par l’auteur de The Hundred-Page Machine Learning Book (Andriy Burkov 2019).

• Disponible sous un modèle “lire d’abord, acheter plus tard”.

Résumé

• Taille de l’ensemble d’entraînement : Impact sur l’efficacité du modèle et la généralisation.
• Encodage des attributs : Évaluation des techniques éviter des biais et possiblement faciliter l’apprentissage.
• Prétraitement :
  • Mise à l’échelle des données
  • Gestion des valeurs manquantes
  • Gestion du déséquilibre des classes

Prochain cours

• Introduction aux réseaux neuronaux artificiels.

Références

Banko, Michele, et Eric Brill. 2001. « Scaling to very very large corpora for natural language disambiguation ». In Proceedings of the 39th Annual Meeting on Association for Computational Linguistics, 26‑33. ACL ’01. USA: Association for Computational Linguistics. https://doi.org/10.3115/1073012.1073017.

Burkov, A. 2020. Machine Learning Engineering. True Positive Incorporated. https://books.google.ca/books?id=HeXizQEACAAJ.

Burkov, Andriy. 2019. The Hundred-Page Machine Learning Book. Andriy Burkov.

Chawla, N V, K W Bowyer, L O Hall, et W P Kegelmeyer. 2002. « SMOTE: Synthetic minority over-sampling technique ». Journal of Artificial Intelligence Research 16: 321‑57.

Halevy, Alon, Peter Norvig, et Fernando Pereira. 2009. « The Unreasonable Effectiveness of Data ». IEEE Intelligent Systems 24 (2): 8‑12.

Kaplan, Jared, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, et Dario Amodei. 2020. « Scaling Laws for Neural Language Models ». https://arxiv.org/abs/2001.08361.

Pradipta, Gede Angga, Retantyo Wardoyo, Aina Musdholifah, I Nyoman Hariyasa Sanjaya, et Muhammad Ismail. 2021. « SMOTE for Handling Imbalanced Data Problem : A Review ». 2021 Sixth International Conference on Informatics and Computing (ICIC) 00: 1‑8. https://doi.org/10.1109/icic54025.2021.9632912.

Russell, Stuart, et Peter Norvig. 2020. Artificial Intelligence: A Modern Approach. 4ᵉ éd. Pearson. http://aima.cs.berkeley.edu/.

Sakai, Masato, Akihisa Sakurai, Siyuan Lu, Jorge Olano, Conrad M. Albrecht, Hendrik F. Hamann, et Marcus Freitag. 2024. « AI-accelerated Nazca survey nearly doubles the number of known figurative geoglyphs and sheds light on their purpose ». Proceedings of the National Academy of Sciences 121 (40): e2407652121. https://doi.org/10.1073/pnas.2407652121.

Shumailov, Ilia, Zakhar Shumaylov, Yiren Zhao, Nicolas Papernot, Ross Anderson, et Yarin Gal. 2024. « AI models collapse when trained on recursively generated data ». Nature 631 (8022): 755‑59. https://doi.org/10.1038/s41586-024-07566-y.

Annexe : Pipeline

Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

num_pipeline = Pipeline([
        ('imputer', SimpleImputer(strategy="median")),
        ('attribs_adder', CombinedAttributesAdder()),
        ('std_scaler', StandardScaler()),
        ])

training_num_tr = num_pipeline.fit_transform(training_num)

full_pipeline = ColumnTransformer([
        ("num", num_pipeline, num_attribs),
        ("cat", OneHotEncoder(), ["sequence"]),
    ])

training_prepared = full_pipeline.fit_transform(training)

Marcel Turcotte

[email protected]

École de science informatique et de génie électrique (SIGE)

Université d’Ottawa

Attribution: Générée par DALL-E, via ChatGPT (GPT-4), OpenAI, 20 septembre, 2024.

Voir la page suivante pour les interactions.

GPT-4o interactions 2024-09-30

J’ai présenté à GPT-4o une image du personnage principal de Marcel the Shell With Shoes On et j’ai eu les interactions suivantes.

Marcel: How would you describe the subject of the image, its artistic quality, technique, and rendering style?

GPT-4o: The image depicts a whimsical character that resembles a small shell with one large, expressive eye. It stands on two legs wearing shoes, giving it a cute and almost anthropomorphic appearance. The character has a surreal and quirky look, which lends it a sense of personality and charm.

Artistic Quality:

The image is rendered with a high degree of polish and smoothness, possibly created digitally. The textures, shading, and lighting are soft and subtle, giving the character a smooth and rounded look. The rendering captures a delicate balance between realism (in the textures of the shell and shoes) and cartoon-like abstraction (in the exaggerated eye and small stature).

Technique:

The artist appears to have employed a blend of digital painting and 3D-like modeling techniques, with careful attention to detail in the reflections in the eye and the textures of the shell and shoes. The color palette is muted, using soft tones that evoke a gentle, friendly atmosphere.

Rendering Style:

The rendering style is a mix of minimalist and hyperrealist elements. The minimalism is seen in the simplified forms of the character—particularly the body and legs—while the hyperrealism comes through in the detailing of the eye and the subtle textures. This gives the character a tactile, almost tangible quality while maintaining its fantastical, imaginative essence.

The overall effect of the design is both charming and surreal, combining everyday objects (a shell, shoes) with anthropomorphic and fantastical elements to create a unique, playful character.

Marcel: Create an image based on the following description: The image depicts a whimsical character that resembles a small shell with one large, expressive eye. It stands on two legs wearing shoes, giving it a cute and almost anthropomorphic appearance. The character has a surreal and quirky look, which lends it a sense of personality and charm.

Artistic Quality:

The image is rendered with a high degree of polish and smoothness, possibly created digitally. The textures, shading, and lighting are soft and subtle, giving the character a smooth and rounded look. The rendering captures a delicate balance between realism (in the textures of the shell and shoes) and cartoon-like abstraction (in the exaggerated eye and small stature).

Technique:

The artist appears to have employed a blend of digital painting and 3D-like modeling techniques, with careful attention to detail in the reflections in the eye and the textures of the shell and shoes. The color palette is muted, using soft tones that evoke a gentle, friendly atmosphere.

Rendering Style:

The rendering style is a mix of minimalist and hyperrealist elements. The minimalism is seen in the simplified forms of the character—particularly the body and legs—while the hyperrealism comes through in the detailing of the eye and the subtle textures. This gives the character a tactile, almost tangible quality while maintaining its fantastical, imaginative essence.

The overall effect of the design is both charming and surreal, combining everyday objects (a shell, shoes) with anthropomorphic and fantastical elements to create a unique, playful character.

GTP-4o: Here is the image based on the description you provided. Let me know if you’d like to make any adjustments!