Mage est un outil puissant pour les tâches ETL, avec des fonctionnalités qui permettent l'exploration et l'exploration de données, des visualisations rapides via des modèles de graphiques et plusieurs autres fonctionnalités qui transforment votre travail avec des données en quelque chose de magique.

Dans le traitement des données, au cours d'un processus ETL, il est courant de trouver des données manquantes qui peuvent générer des problèmes dans le futur, en fonction de l'activité que nous allons réaliser avec l'ensemble de données, les données nulles peuvent être assez perturbatrices.

Pour identifier l'absence de données dans notre ensemble de données, nous pouvons utiliser Python et la bibliothèque pandas pour vérifier les données qui présentent des valeurs nulles, en plus nous pouvons créer des graphiques qui montrent encore plus clairement l'impact de ces valeurs nulles dans notre ensemble de données.

Notre pipeline se compose de 4 étapes : commencer par le chargement des données, deux étapes de traitement et l'exportation des données.

Chargeur de données

Dans cet article nous utiliserons l'ensemble de données : Prédiction binaire des champignons vénéneux qui est disponible sur Kaggle dans le cadre d'un concours. Utilisons l'ensemble de données de formation disponible sur le site Web.

Créons une étape Data Loader en utilisant python pour pouvoir charger les données que nous allons utiliser. Avant cette étape, j'ai créé une table dans la base de données Postgres, que j'ai localement sur ma machine, pour pouvoir charger les données. Comme les données sont dans Postgres, nous utiliserons le modèle de chargement Postgres déjà défini dans Mage.

from mage_ai.settings.repo import get_repo_path
from mage_ai.io.config import ConfigFileLoader
from mage_ai.io.postgres import Postgres
from os import path

if 'data_loader' not in globals():
    from mage_ai.data_preparation.decorators import data_loader

if 'test' not in globals():
    from mage_ai.data_preparation.decorators import test

@data_loader
def load_data_from_postgres(*args, **kwargs):
    """
    Template for loading data from a PostgreSQL database.
    Specify your configuration settings in 'io_config.yaml'.
    Docs: https://docs.mage.ai/design/data-loading#postgresql
    """
    query = 'SELECT * FROM mushroom'  # Specify your SQL query here
    config_path = path.join(get_repo_path(), 'io_config.yaml')
    config_profile = 'default'

    with Postgres.with_config(ConfigFileLoader(config_path, config_profile)) as loader:

        return loader.load(query)

@test
def test_output(output, *args) -> None:
    """
    Template code for testing the output of the block.
    """

    assert output is not None, 'The output is undefined'

Au sein de la fonction load_data_from_postgres() nous définirons la requête que nous utiliserons pour charger la table dans la base de données. Dans mon cas, j'ai configuré les informations bancaires dans le fichier io_config.yaml où elles sont définies comme configuration par défaut, il suffit donc de transmettre le nom par défaut à la variable config_profile.

Après avoir exécuté le bloc, nous utiliserons la fonction Ajouter un graphique, qui fournira des informations sur nos données via des modèles déjà définis. Cliquez simplement sur l'icône à côté du bouton de lecture, marquée dans l'image par une ligne jaune.

Nous sélectionnerons deux options pour explorer davantage notre ensemble de données, les options summay_overview et feature_profiles. Grâce à summary_overview, nous obtenons des informations sur le nombre de colonnes et de lignes dans l'ensemble de données. Nous pouvons également afficher le nombre total de colonnes par type, par exemple le nombre total de colonnes catégorielles, numériques et booléennes. Feature_profiles, quant à lui, présente des informations plus descriptives sur les données, telles que : type, valeur minimale, valeur maximale, entre autres informations, nous pouvons même visualiser les valeurs manquantes, qui font l'objet de notre traitement.

Pour pouvoir nous concentrer davantage sur les données manquantes, utilisons le modèle : % de valeurs manquantes, un graphique à barres avec le pourcentage de données manquantes, dans chacune des colonnes.

Le graphique présente 4 colonnes où les valeurs manquantes correspondent à plus de 80% de son contenu, et d'autres colonnes qui présentent des valeurs manquantes mais en plus petites quantités, ces informations nous permettent désormais de rechercher différentes stratégies pour y faire face données nulles

Colonnes de dépôt de transformateur

Pour les colonnes qui contiennent plus de 80 % de valeurs nulles, la stratégie que nous suivrons sera d'effectuer une suppression des colonnes dans le dataframe, en sélectionnant les colonnes que nous allons exclure du dataframe. En utilisant le bloc TRANSFORMER dans le langage Python, nous sélectionnerons l'option Colum Removal .

from mage_ai.data_cleaner.transformer_actions.base import BaseAction
from mage_ai.data_cleaner.transformer_actions.constants import ActionType, Axis
from mage_ai.data_cleaner.transformer_actions.utils import build_transformer_action
from pandas import DataFrame

if 'transformer' not in globals():
    from mage_ai.data_preparation.decorators import transformer

if 'test' not in globals():
    from mage_ai.data_preparation.decorators import test

@transformer
def execute_transformer_action(df: DataFrame, *args, **kwargs) -> DataFrame:
    """
    Execute Transformer Action: ActionType.REMOVE
    Docs: https://docs.mage.ai/guides/transformer-blocks#remove-columns
    """
    action = build_transformer_action(
        df,
        action_type=ActionType.REMOVE,
        arguments=['veil_type', 'spore_print_color', 'stem_root', 'veil_color'],        
        axis=Axis.COLUMN,
    )
    return BaseAction(action).execute(df)

@test
def test_output(output, *args) -> None:
    """
    Template code for testing the output of the block.

    """
    assert output is not None, 'The output is undefined'

Dans la fonction execute_transformer_action() nous insérerons une liste avec le nom des colonnes que nous voulons exclure de l'ensemble de données, dans la variable arguments, après cette étape, exécutez simplement le bloc.

Le transformateur remplit les valeurs manquantes

Maintenant, pour les colonnes qui contiennent moins de 80 % de valeurs nulles, nous utiliserons la stratégie Remplir les valeurs manquantes, comme dans certains cas malgré des données manquantes, en les remplaçant par des valeurs telles que En moyenne, ou à la mode, il peut être en mesure de répondre au besoin de données sans provoquer de nombreux changements dans l'ensemble de données, en fonction de votre objectif final.

Il existe certaines tâches, telles que la classification, où le remplacement des données manquantes par une valeur pertinente (mode, moyenne, médiane) pour l'ensemble de données peut contribuer à l'algorithme de classification, qui pourrait parvenir à d'autres conclusions si les données étaient supprimées. comme dans l’autre stratégie que nous avons utilisée.

Pour décider quelle mesure nous utiliserons, nous utiliserons à nouveau la fonctionnalité Ajouter un graphique de Mage. En utilisant le modèle Valeurs les plus fréquentes nous pouvons visualiser le mode et la fréquence de cette valeur dans chacune des colonnes.

En suivant des étapes similaires aux précédentes, nous utiliserons le transformateur Remplir les valeurs manquantes, pour effectuer la tâche de soustraction des données manquantes en utilisant le mode de chacune des colonnes : steam_surface, gill_spacing, cap_surface , gill_attachment, ring_type.

from mage_ai.data_cleaner.transformer_actions.constants import ImputationStrategy
from mage_ai.data_cleaner.transformer_actions.base import BaseAction
from mage_ai.data_cleaner.transformer_actions.constants import ActionType, Axis
from mage_ai.data_cleaner.transformer_actions.utils import build_transformer_action
from pandas import DataFrame

if 'transformer' not in globals():
    from mage_ai.data_preparation.decorators import transformer

if 'test' not in globals():
    from mage_ai.data_preparation.decorators import test

@transformer
def execute_transformer_action(df: DataFrame, *args, **kwargs) -> DataFrame:

    """
    Execute Transformer Action: ActionType.IMPUTE
    Docs: https://docs.mage.ai/guides/transformer-blocks#fill-in-missing-values

    """
    action = build_transformer_action(
        df,
        action_type=ActionType.IMPUTE,
        arguments=df.columns,  # Specify columns to impute
        axis=Axis.COLUMN,
        options={'strategy': ImputationStrategy.MODE},  # Specify imputation strategy
    )

    return BaseAction(action).execute(df)


@test
def test_output(output, *args) -> None:
    """
    Template code for testing the output of the block.
    """
    assert output is not None, 'The output is undefined'

Dans la fonction execute_transformer_action() , nous définissons la stratégie de remplacement des données dans un dictionnaire Python. Pour plus d'options de remplacement, accédez simplement à la documentation du transformateur : https://docs.mage.ai/guides/transformer-blocks#fill-in-missing-values.

Exportateur de données

Lorsque nous effectuerons toutes les transformations, nous sauvegarderons notre ensemble de données désormais traité, dans la même base de données Postgres mais maintenant avec un nom différent afin de pouvoir le différencier. En utilisant le bloc Data Exporter et en sélectionnant Postgres, nous définirons le shema et la table où nous voulons enregistrer, en rappelant que les configurations de la base de données sont préalablement enregistrées dans le fichier io_config.yaml.

from mage_ai.settings.repo import get_repo_path
from mage_ai.io.config import ConfigFileLoader
from mage_ai.io.postgres import Postgres
from pandas import DataFrame
from os import path

if 'data_exporter' not in globals():
    from mage_ai.data_preparation.decorators import data_exporter

@data_exporter
def export_data_to_postgres(df: DataFrame, **kwargs) -> None:

    """
    Template for exporting data to a PostgreSQL database.
    Specify your configuration settings in 'io_config.yaml'.
    Docs: https://docs.mage.ai/design/data-loading#postgresql

    """

    schema_name = 'public'  # Specify the name of the schema to export data to
    table_name = 'mushroom_clean'  # Specify the name of the table to export data to
    config_path = path.join(get_repo_path(), 'io_config.yaml')
    config_profile = 'default'

    with Postgres.with_config(ConfigFileLoader(config_path, config_profile)) as loader:

        loader.export(
            df,
            schema_name,
            table_name,
            index=False,  # Specifies whether to include index in exported table
            if_exists='replace', #Specify resolution policy if table name already exists
        )

Merci et à la prochaine fois ?

repo -> https://github.com/DeadPunnk/Mushrooms/tree/main