Encodage d'étiquette en one-hot

Introduction

Dans ce projet, vous allez apprendre à effectuer un codage one-hot sur les données d'étiquette pour une tâche de classification à une seule étiquette. Le codage one-hot est une technique courante utilisée pour transformer les variables catégorielles en un format utilisable par les algorithmes d'apprentissage automatique.

🎯 Tâches

Dans ce projet, vous allez apprendre :

• à comprendre le concept de codage one-hot et son importance dans l'apprentissage automatique.
• à implémenter une fonction pour effectuer un codage one-hot sur une liste d'étiquettes d'échantillons.
• à tester la fonction de codage d'étiquette avec des données d'échantillonnage.

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• transformer les étiquettes catégorielles en un format numérique approprié pour les modèles d'apprentissage automatique.
• comprendre l'importance du prétraitement des données et de la génération de fonctionnalités dans le pipeline d'apprentissage automatique.
• démontrer des compétences de codage pratique en Python pour manipuler et transformer des données pour les tâches d'apprentissage automatique.

Encodage d'étiquette en one-hot

Dans cette étape, vous allez apprendre à effectuer un codage one-hot sur les données d'étiquette pour une tâche de classification à une seule étiquette.

Le codage one-hot est une technique courante utilisée pour transformer les variables catégorielles en un format utilisable par les algorithmes d'apprentissage automatique. Dans le cas de la classification à une seule étiquette, chaque étiquette unique dans le jeu de données est représentée comme un vecteur binaire, où la position de l'étiquette dans la liste est marquée comme 1 et toutes les autres positions sont 0.

Ouvrez le fichier label_process.py situé dans le répertoire /home/labex/project et ajoutez le code suivant :

def label_process(labels: List[str], sample_y: List[str]) -> List[List[int]]:
    """
    Transforms a list of sample labels into a format suitable for classification tasks.

    The function creates a binary list for each sample label, where the position
    of the label in the 'labels' list is marked as 1 and all other positions are 0.
    This is known as one-hot encoding.

    Args:
        labels (List[str]): List of unique labels/classes in the dataset.
        sample_y (List[str]): List of sample labels to be transformed.

    Returns:
        List[List[int]]: Transformed labels, each represented as a binary list corresponding
        to the positions in the 'labels' list.
    """
    train_y = []
    for y in sample_y:
        train = [0] * len(labels)
        train[labels.index(y)] = 1
        train_y.append(train)
    return train_y

1. Dans la fonction label_process, nous implémentons la logique de codage one-hot. La fonction prend deux arguments :
   • labels : une liste des étiquettes/classes uniques dans le jeu de données
   • sample_y : une liste des étiquettes d'échantillons à transformer
2. Initialisez une liste vide appelée train_y pour stocker les étiquettes transformées.
3. Itérez à travers la liste sample_y :
   • Pour chaque étiquette y, créez une nouvelle liste train de longueur égale au nombre d'étiquettes uniques (len(labels)), et initialisez tous les éléments à 0.
   • Trouvez l'index de l'étiquette actuelle y dans la liste labels en utilisant la méthode index(), et définissez l'élément correspondant dans train sur 1.
   • Ajoutez la liste train à la liste train_y.
4. Après la boucle, la liste train_y contiendra les étiquettes codées one-hot pour tous les échantillons. Retournez cette liste à partir de la fonction label_process.

Test du codage d'étiquette

Dans cette étape, vous allez tester la fonction label_process en fournissant des données d'échantillonnage et en vérifiant la sortie.

Ajoutez le code suivant dans le fichier label_process.py :

## Continue in the same file
if __name__ == "__main__":
    labels = ["Python", "Java", "Tensorflow", "Springboot", "Keras"]
    sample_y = ["Python", "Python", "Python", "Java", "Java", "Keras"]
    train_y = label_process(labels, sample_y)
    print(train_y)

Ce code définit une liste d'étiquettes uniques (labels) et une liste d'étiquettes d'échantillonnage (sample_y), puis appelle la fonction label_process et imprime les étiquettes codées one-hot résultantes.

2. Enregistrez le fichier label_process.py et exécutez le script à partir du terminal :

python label_process.py

La sortie devrait être :

[[1, 0, 0, 0, 0],
 [1, 0, 0, 0, 0],
 [1, 0, 0, 0, 0],
 [0, 1, 0, 0, 0],
 [0, 1, 0, 0, 0],
 [0, 0, 0, 0, 1]]

Cette sortie montre les étiquettes codées one-hot pour les données d'échantillonnage. Chaque ligne représente un échantillon, et les colonnes correspondent aux positions des étiquettes dans la liste labels.

Félicitations! Vous avez réussi à implémenter le codage one-hot des étiquettes pour une tâche de classification à une seule étiquette.

Résumé

Félicitations! Vous avez terminé ce projet. Vous pouvez pratiquer plus de laboratoires dans LabEx pour améliorer vos compétences.