Champignons Magiques : explorer et traiter les données nulles avec Mage

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.

Lors du 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 à l'avenir, 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 passer 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 chercher différentes stratégies pour y faire face données nulles.

Colonnes de dépôt de transformateur

Pour les colonnes qui ont 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. A l'aide du bloc TRANSFORMER dans le langage Python, nous sélectionnerons l'option Suppression de colonnes .

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 souhaitons 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 ont 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 moyenne, ou 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.

Existem algumas tarefas, como a de classificação, onde a substituição dos dados faltantes por um valor que seja relevante (moda, média, mediana) para o dataset, possa contribuir com o algoritmo de classificação, que poderia chegar a outras conclusões caso o dados fossem apagados como na outra estratégia de utilizamos.

Para tomar uma decisão com relação a qual medida vamos utilizar, vamos recorrer novamente a funcionalidade Add chart do Mage. Usando o template Most frequent values podemos visualizar a moda e a frequência desse valor em cada uma das colunas.

Seguindos passos semelhantes aos anteriores, vamos usar o tranformer Fill in missing values, para realizar a tarefa de subtiruir os dados faltantes usando a moda de cada uma das colunas: 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'

Na função execute_transformer_action() , definimos a estratégia para a substituição dos dados num dicionário do Python. Para mais opções de substituição, basta acessar a documentação do transformer: https://docs.mage.ai/guides/transformer-blocks#fill-in-missing-values.

Data Exporter

Ao realizar todas as transformações, vamos salvar nosso dataset agora tratado, na mesma base do Postgres mas agora com um nome diferente para podermos diferenciar. Usando o bloco Data Exporter e selecionando o Postgres, vamos definir o shema e a tabela onde queremos salvar, lembrando que as configurações do banco são salvas previamente no arquivo 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
        )

Obrigado e até a próxima ?

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!