Je voudrais partager ce que j'ai appris tout en apportant les corrections et les ajouts appropriés.

Actuellement, je me concentre principalement sur la tâche de régression. Veuillez noter que les spécifications peuvent différer pour d'autres tâches. (Autant que j'ai vérifié brièvement, il semble que les spécifications soient presque les mêmes entre les tâches.)

À propos de ce document

Focus sur le ** prétraitement ** de PyCaret. Fondamentalement, cela ne concerne pas la modélisation et le réglage.

J'écris en le déplaçant et en lisant le code source original. https://github.com/pycaret/pycaret

Veuillez noter qu'il peut y avoir des erreurs.

Hypothèses de mise en œuvre

On suppose que diverses bibliothèques sont importées comme suit.

import pandas as pd
import numpy as np

Qu'est-ce que PyCaret

Une bibliothèque qui automatise le prétraitement des données et la formation des modèles de machine learning et peut être déployée dans un environnement low code. https://pycaret.org/

L'installation est une commande pip unique. Très facile. ..

pip install pycaret

Vous pouvez vous référer à cet article pour une vue d'ensemble et comment implémenter une série de pipelines. https://qiita.com/tani_AI_Academy/items/62151d7e151024733919

Comment exécuter le prétraitement

Dans PyCaret, vous pouvez spécifier le prétraitement que vous souhaitez exécuter avec des paramètres. De plus, PyCaret confirme avec l'utilisateur certains contenus de traitement avant l'opération. Le déroulement des opérations est le suivant.

Appeler la fonction d'exécution de saisie / prétraitement de données

En appelant setup () du paquet préparé pour chaque tâche telle que la classification et la régression, le prétraitement suivant est exécuté.

Nettoyage et conversion de données
Séparation des données de train / test
Échantillonnage des données

** Le prétraitement que vous voulez que PyCaret traite peut être spécifié en le donnant comme argument à setup () **. Seul "target (variable cible)" est requis comme argument.

Dans l'explication suivante, je souhaite acquérir et exécuter les données attachées à PyCaret. Vous pouvez vérifier les données attachées à PyCaret sur la page d'origine. https://pycaret.org/get-data/

Bien sûr, vous pouvez également lire vos propres données avec des pandas et les utiliser.

Le code pour effectuer l'acquisition et le prétraitement des données est le suivant. Ici, seul l'argument "cible" est spécifié. Autres options par défaut.

from pycaret.datasets import get_data
dataset = get_data("diamond")

from pycaret.regression import *
setup(dataset, target="Price")

Bien que la valeur de retour soit transmise ici, plusieurs valeurs telles que des données prétraitées sont renvoyées. Pour la valeur de retour, cochez [Détails décrits ci-dessous](Les données après le prétraitement sont renvoyées comme valeur de retour de setup ()).

Vérifiez le résultat de l'estimation du type de chaque variable

Lorsque vous exécutez setup (), ** PyCaret déduit d'abord le type (Type de données) de chaque variable et invite l'utilisateur à vérifier le résultat de l'estimation et à continuer le traitement **. Si le résultat de l'estimation de type est correct, appuyez sur la touche Entrée dans la zone d'édition dans le cadre bleu de la figure pour continuer le processus. Si le type déduit est incorrect, vous pouvez interrompre le processus en tapant "quitter".

Les variables avec une estimation de type incorrecte peuvent être résolues en spécifiant explicitement le type dans setup (). (Pour plus de détails, voir [Contenu décrit ci-dessous](Fonctions numériques, Caractéristiques catégorielles).)

Vérifiez le résumé d'exécution du prétraitement

Lorsque l'exécution de setup () est terminée, le contenu du traitement est sorti au format de trame de données.

	Description	Value
0	session_id	3104
1	Transform Target	False
2	Transform Target Method	None
3	Original Data	(6000, 8)
4	Missing Values	False
5	Numeric Features	1
6	Categorical Features	6
7	Ordinal Features	False
8	High Cardinality Features	False
9	High Cardinality Method	None
10	Sampled Data	(6000, 8)
11	Transformed Train Set	(4199, 28)
12	Transformed Test Set	(1801, 28)
13	Numeric Imputer	mean
14	Categorical Imputer	constant
15	Normalize	False
16	Normalize Method	None
17	Transformation	False
18	Transformation Method	None
19	PCA	False
20	PCA Method	None
21	PCA Components	None
22	Ignore Low Variance	False
23	Combine Rare Levels	False
24	Rare Level Threshold	None
25	Numeric Binning	False
26	Remove Outliers	False
27	Outliers Threshold	None
28	Remove Multicollinearity	False
29	Multicollinearity Threshold	None
30	Clustering	False
31	Clustering Iteration	None
32	Polynomial Features	False
33	Polynomial Degree	None
34	Trignometry Features	False
35	Polynomial Threshold	None
36	Group Features	False
37	Feature Selection	False
38	Features Selection Threshold	None
39	Feature Interaction	False
40	Feature Ratio	False
41	Interaction Threshold	None

À partir de ce tableau, vous pouvez ** vérifier la taille des données, le nombre d'entités et si divers prétraitements sont spécifiés ou non **. Par défaut, la plupart des options sont désactivées (False ou None).

Si vous spécifiez une option avec l'argument de setup (), l'élément correspondant devient "True" et est coloré.

Dans les sections suivantes, nous expliquerons le contenu de divers éléments.

Informations sur la session

session_id

	Description	Value
0	session_id	3104

C'est un identifiant lorsque PyCaret est exécuté, et il semble qu'il soit utilisé en interne comme une graine pour des nombres aléatoires. S'il n'est pas spécifié, il sera déterminé au hasard.

Il peut être spécifié par l'argument "session_id" de setup (). Spécifiez cette valeur pour conserver la reproductibilité lors des exécutions répétées. (C'est une image proche de "random_state" dans scikit-learn.)

setup(dataset, target="Price", session_id=123)

Informations sur les données d'entrée

Original Data

	Description	Value
3	Original Data	(6000, 8)

La taille (forme) des données d'entrée est sortie.

Quand je le vérifie, c'est certainement la même taille.

dataset.shape

#Résultat d'exécution
# (6000, 8)

Missing Values

	Description	Value
4	Missing Values	False

Le fait que les données d'entrée soient ou non manquantes est émis. Étant donné que ces données ne contiennent aucun défaut, «False» est affiché.

S'il y a un défaut, cet élément sera "Vrai".

S'il y a un défaut, le défaut sera rempli dans ** setup () **. La spécification de la méthode de remplissage des défauts sera décrite plus loin.

Caractéristiques numériques et caractéristiques catégorielles

	Description	Value
5	Numeric Features	1
6	Categorical Features	6

Les valeurs estimées du nombre de valeurs continues et du nombre de quantités d'entités dans la catégorie sont respectivement sorties.

Il peut être explicitement spécifié par les arguments "numeric_features" et "categorical_features" de setup ().

setup(dataset, target="Price",
        categorical_features=["Cut", "Color", "Clarity", "Polish", "Symmetry", "Report"], 
        numeric_features=["Carat Weight"])

Dans la boîte de dialogue de confirmation de l'estimation de type ** PyCaret ci-dessus, s'il existe une variable dont l'estimation de type est incorrecte, spécifiez-la explicitement avec cet argument. ** **

Informations sur la division des données du train / test

Transformed Train Set、Transformed Test Set

	Description	Value
11	Transformed Train Set	(4199, 28)
12	Transformed Test Set	(1801, 28)

La taille de chaque division après est sortie dans les données de train / test. Le taux de division des données train / test peut être spécifié par l'argument "train_size" de setup (). La valeur par défaut est 0,7.

Le nombre de colonnes est différent des données d'entrée car le nombre d'entités après le prétraitement est affiché. (Cette fois, le nombre de caractéristiques est passé de 7 à 28 en raison du prétraitement.)

Informations sur l'échantillonnage des données

Sampled Data

	Description	Value
10	Sampled Data	(6000, 8)

Lorsque les données sont échantillonnées dans `` setup () '', le nombre de données après l'échantillonnage est émis. ** PyCaret vous encourage à échantillonner des données et à effectuer une série d'opérations lorsque le nombre de lignes de données est supérieur à 25 000. ** **

Si vous exécutez setup () sur des données de plus de 25 000 lignes, la boîte de dialogue de confirmation d'exécution de l'échantillonnage s'affichera après l'exécution de la boîte de dialogue de confirmation d'estimation de type. Lors de l'échantillonnage, entrez le pourcentage de données à échantillonner dans la zone d'édition dans le cadre bleu. Si vous souhaitez utiliser le nombre total de lignes sans échantillonnage, laissez ce champ vide et appuyez sur la touche Entrée.

(Pour les tâches de régression)

(Pour les tâches de classification)

Le graphique tracé ici montre une indication de la détérioration de la précision due à l'échantillonnage.

Pour la tâche de régression, un graphique des coefficients de décision (par défaut dans le modèle de régression linéaire)
Dans la tâche de classification, tracés de divers indicateurs (par défaut, modèle de régression logistique)

Le modèle utilisé pour ce tracé peut être spécifié dans l'argument "sample_estimator" de setup (). Par exemple, le code pour spécifier RandomForestRegressor est ci-dessous.

from sklearn.ensemble import RandomForestRegressor

traffic = get_data("traffic")
setup(traffic, target="traffic_volume", sample_estimator=RandomForestRegressor())

De plus, cette fonction elle-même peut être désactivée en spécifiant l'argument "sampling" de setup (). (Il n'est pas confirmé si l'échantillonnage est exécuté ou non, et le traitement se poursuit en utilisant toutes les données.)

(Autre) Méthodes liées au nettoyage des données et au traitement de la conversion de la quantité de caractéristiques

Pour les autres éléments, il s'agit d'informations indiquant si le nettoyage des données et le traitement de conversion de quantité de caractéristiques sont exécutés ou non et le procédé. Dans le chapitre suivant, nous expliquerons les processus correspondants.

Processus de nettoyage des données et de conversion des fonctionnalités

Nous considérerons le contenu du traitement et la méthode de spécification.

Les données après le prétraitement sont renvoyées comme valeur de retour de setup ()

Les données prétraitées et le pipeline de traitement sont renvoyés. Il semble que cela dépend du type de tâche que vous souhaitez résoudre.

`regression`


X, y, X_train, X_test, y_train, y_test, seed, prep_pipe, target_inverse_transformer, experiment__ \
    = setup(dataset, target="Price")

`classification`


from pycaret.classification import *

dataset = get_data('credit')
X, y, X_train, X_test, y_train, y_test, seed, prep_pipe, experiment__ \
    = setup(dataset, target = 'default')

La valeur de retour est légèrement différente entre la régression et la classification. ** Les données après le prétraitement sont renvoyées à X et y **, vous pouvez donc vérifier les résultats de traitement spécifiques.

Est-il possible de traiter les données après un prétraitement par PyCaret seul et de les réinitialiser dans PyCaret? Est actuellement inconnu.

Je voudrais continuer à enquêter.

Exclusion de la quantité de caractéristiques

Vous pouvez définir les fonctions à exclure lors du prétraitement et de la modélisation ultérieure.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

ignore_features (liste type de chaîne, par défaut = Aucun)
Spécifiez le nom de la colonne du montant de la fonction que vous souhaitez exclure de la liste.

référence

** L'ID et la date / heure semblent être définis comme exclus lors de la modélisation par défaut ** Si la colonne date n'est pas reconnue comme une date, il semble que vous puissiez la spécifier explicitement avec l'argument "date_features".

De plus, bien que les spécifications correctes soient confirmées, même s'il existe des colonnes contenant exactement les mêmes données, l'une d'entre elles sera automatiquement exclue.

Combler la carence

Interpole les défauts de la manière spécifiée.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

numeric_imputation (type de chaîne, par défaut = 'mean')
Spécifie la méthode de remplissage des données manquantes.
Vous pouvez spécifier «signifie» ou «médian».
'mean' comble le vide avec la valeur moyenne.
«médiane» comble l'écart avec la médiane.

categorical_imputation (type de chaîne, par défaut = 'constant')
Spécifie comment remplir les éléments manquants pour les données de catégorie.
Vous pouvez spécifier «constant» ou «mode».
Remplissez toujours "constant" avec la chaîne "not_available".
Remplissez "mode" avec la valeur la plus fréquente pour chaque quantité de fonction.

référence

Pour le moment, il n'est pas possible de spécifier pour chaque colonne, et il semble que toutes sont traitées par une méthode unifiée.

Codage séquentiel des données

La conversion d'étiquette est effectuée en spécifiant la colonne que vous souhaitez définir comme données ordinales.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

ordinal_features (type de dictionnaire, défaut = Aucun)
Spécifiez l'ordre des noms de colonne et les valeurs des données de commande au format dictionnaire.

Précisez avec l'image suivante. ordinal_features = { 'column_name' : ['low', 'medium', 'high'] }

Dans la partie valeur des données du dictionnaire, spécifiez les valeurs dans l'ordre croissant des données de commande.

Normalisation des fonctionnalités

Normaliser chaque quantité de fonction.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

normaliser (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

normalize_method (type de chaîne, par défaut = 'zscore')
Définit la méthode (l'une des suivantes) utilisée pour la normalisation.
'zscore': calculé comme z = (x --u) / s par une technique appelée standardisation.
'minmax': Échelle à la plage 0-1 avec une technique appelée mise à l'échelle Min-Max.
'maxabs': met à l'échelle les valeurs absolues maximale et minimale à 1.
`robuste ': échelles par rapport au quadrant des données.

référence

Vous pouvez vous référer à cet article pour une mise à l'échelle «robuste». https://qiita.com/unhurried/items/7a79d2f3574fb1d0cc27

Si le jeu de données contient des valeurs aberrantes, la mise à l'échelle «robuste» semble être forte.

Pour une autre mise à l'échelle, cet article sera utile. https://qiita.com/Umaremin/items/fbbbc6df11f78532932d

En général, les algorithmes linéaires ont tendance à être plus précis lorsqu'ils sont normalisés, mais ce n'est pas toujours le cas et peut nécessiter plusieurs expériences.

Intégration de valeurs rares dans des variables catégorielles

Dans la variable catégorielle, les catégories inférieures au seuil spécifié sont fusionnées en une seule catégorie.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

combine_rare_levels (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

rare_level_threshold (type float, par défaut = 0,1)
Spécifiez la valeur seuil à considérer comme une valeur rare.
Combinez toutes les catégories dont la fréquence d'occurrence est inférieure au seuil en une seule catégorie.
Valide uniquement lorsqu'il y a deux catégories ou plus sous le seuil.
Les catégories intégrées sont définies avec des noms comme "XXX_others_infrequent".

référence

En général, cette méthode évite le cas où une variable catégorielle a un grand nombre de catégories et est transformée en une variable fictive afin qu'elle devienne une matrice creuse.

Binning de données numériques

Classe la quantité de caractéristiques des données numériques.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

bin_numeric_features (liste type de chaîne, par défaut = Aucun)
Spécifiez le nom de la colonne du montant de la fonction de données numériques que vous souhaitez regrouper dans une liste.

référence

En interne, c'est une image qui exécute sklearn.preprocessing.KBinsDiscretizer. (Il semble qu'un algorithme utilisant la méthode des k-moyennes unidimensionnelles soit utilisé.)

Je ne comprends pas les détails tels que la façon de décider du nombre de bacs, alors j'aimerais étudier à l'avenir.

Suppression des valeurs aberrantes

Supprime les valeurs aberrantes des données de train.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

remove_outliers (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

outliers_threshold (type float, par défaut = 0,05)
Spécifie le pourcentage de valeurs aberrantes dans l'ensemble de données.
Par exemple, si vous spécifiez la valeur par défaut de 0,05, 0,025% des valeurs des deux côtés de la queue de la distribution seront supprimées.

référence

Il semble que la décomposition en valeurs singulières et l'ACP soient utilisées pour le traitement interne.

Je ne comprends pas les détails, donc j'aimerais étudier à l'avenir.

Suppression de multico

Supprime les fonctionnalités qui peuvent entraîner une multi-colinéarité.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

remove_multicollinearity (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

multicollinearity_threshold (type float, par défaut = 0.9)
Les variables dont l'intercorrélation est supérieure au seuil défini par ce paramètre seront supprimées.
(Il semble que celui avec la corrélation la plus faible avec la variable objectif soit supprimé des deux quantités de caractéristiques.)

référence

Pour plus d'informations sur Marco, cet article vous sera utile. https://qiita.com/ynakayama/items/36b7c1640e6a02ce2e00

Quantification des caractéristiques des résultats des anneaux de classe

La mise en cluster est effectuée à l'aide de chaque quantité d'entités et l'étiquette de classe de chaque enregistrement est ajoutée en tant que nouvelle quantité d'entités.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

create_clusters (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

cluster_iter (type int, par défaut = 20)
Spécifiez le nombre d'itérations lors de la détermination du nombre de clusters.

référence

Le nombre de grappes semble être déterminé en utilisant une combinaison de Calinski Harabasz et de critères de silhouette.

Pour le standard Calinski Harabasz et le standard silhouette, cet article sera utile. https://qiita.com/yasaigirai/items/ec3c3aaaab5bc9b930a2

Suppression de fonctionnalités par distribution de données

Supprimez les entités dont les écarts ne sont pas statistiquement significatifs.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

ignore_low_variance (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

référence

La distribution des données semble ici être calculée en utilisant le rapport des valeurs uniques (valeurs uniques) dans tous les échantillons. Est-ce une image qui est candidate à l'exclusion parce qu'on considère que plus il y a de «même valeur» dans une certaine variable, plus la variance est faible?

Je ne comprends pas les détails, donc j'aimerais étudier à l'avenir.

Génération de fonctionnalités d'interaction

Génère des fonctionnalités d'interaction à l'aide des paramètres spécifiés.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

polynomial_features (type booléen, par défaut = False)
Si True est spécifié, une nouvelle quantité d'entités sera générée en combinant les polynômes de toutes les quantités d'entités de données numériques.
L'ordre du polynôme est spécifié par le paramètre polynomial_degree.
Cependant, les fonctionnalités générées jugées insignifiantes sont exclues.
Définissez le seuil de jugement avec polynomial_threshold.

trigonometry_features (type booléen, par défaut = False)
Si True est spécifié, une nouvelle quantité d'entités sera générée en combinant les fonctions triangulaires de toutes les quantités d'entités de données numériques.
Spécifiez l'ordre et le seuil de la même manière que polynomial_features.

polynomial_degree (type int, par défaut = 2)
Spécifie l'ordre des caractéristiques polymorphes.

polynomial_threshold (type float, par défaut = 0,1)
Spécifiez la valeur de seuil pour déterminer s'il faut conserver la quantité de fonctionnalités nouvellement générée.
(Reportez-vous à «Référence» ci-dessous pour la méthode de jugement.)

Par exemple, si l'entrée est composée de deux variables [a, b], la spécification de polynomial_degree = 2 générera la quantité de caractéristiques [1, a, b, a ^ 2, ab, b ^ 2].

En plus de ce qui précède, vous pouvez spécifier davantage le montant de la fonction d'interaction. Génère des fonctionnalités d'interaction de premier ordre pour toutes les fonctionnalités de données numériques, y compris les fonctionnalités de variable fictive pour les variables catégorielles et les fonctionnalités générées par polynomial_features et trigonometry_features.

feature_interaction (type booléen, par défaut = False)
Si True est spécifié, l'interaction (a * b) sera calculée et générée en tant que nouvelle quantité d'entités.
Cependant, les fonctionnalités générées jugées insignifiantes sont exclues.
Définissez le seuil de jugement avec polynomial_threshold.

interaction_threshold (type booléen, par défaut = False)
Si True est spécifié, le rapport (a / b) sera calculé et généré comme une nouvelle quantité de caractéristiques.
Spécifiez le seuil ainsi que feature_interaction.

interaction_threshold (type booléen, par défaut = 0,01)
Spécifiez la valeur de seuil pour déterminer s'il faut conserver la quantité de fonctionnalités nouvellement générée.
(Reportez-vous à «Référence» ci-dessous pour la méthode de jugement.)

référence

A propos de polynomial_threshold et interaction_threshold Les indicateurs à comparer avec les seuils sont comme une importance basée sur plusieurs combinaisons telles que la forêt aléatoire, AdaBoost et la corrélation linéaire.

Je ne comprends pas les détails, donc j'aimerais étudier à l'avenir.

Pour trigonometry_features, créez-vous littéralement des entités à l'aide de fonctions trigonales (sin, cos, tan)? C'est ça?

Je ne comprends pas les détails, donc j'aimerais étudier à l'avenir.

Veuillez noter que cette fonction peut être inefficace pour les jeux de données avec un grand espace d'entités.

Génération de fonctionnalités de groupe

En spécifiant des caractéristiques associées dans l'ensemble de données, les caractéristiques statistiques basées sur celles-ci sont extraites. Les valeurs agrégées suivantes entre les quantités d'entités spécifiées sont calculées pour générer une nouvelle quantité d'entités.

valeur minimum
Valeur maximum
Valeur moyenne
Médiane
Valeur la plus fréquente
écart-type

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

group_features (type de liste de chaîne ou type de liste avec liste, par défaut = Aucun)
Spécifiez le nom de colonne du montant de la fonction de données numériques pour laquelle vous souhaitez générer le montant de la fonction de groupe (lié).

group_names (type de liste, par défaut = Aucun)
Chaque nom de groupe peut être spécifié sous forme de chaîne de caractères.
Un nom de colonne est donné à chaque valeur agrégée avec l'image "Nom du groupe_Min".
Si la longueur ne correspond pas à group_features ou si cet argument n'est pas spécifié, les noms seront group_1 et group_2 dans cet ordre.

L'image d'implémentation est la suivante.

setup(dataset, target="Price", group_features=[["cal1", "cal2" "cal3"], ["cal4", "cal5"]], group_names=["gr1", "gr2"])

Exécution de la sélection de quantité de fonction

Sélectionnez la quantité d'objets à l'aide de plusieurs index d'évaluation.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

feature_selection (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

feature_selection_threshold (type float, par défaut = 0.8)
Spécifie le seuil de pourcentage utilisé pour la sélection des fonctionnalités. (Y compris les entités polymorphes nouvellement générées, etc.)
Plus cette valeur est élevée, plus de fonctionnalités seront sélectionnées.

référence

À propos de feature_selection_threshold Les indicateurs à comparer avec les seuils sont comme une importance basée sur plusieurs combinaisons telles que la forêt aléatoire, AdaBoost et la corrélation linéaire.

Je ne comprends pas les détails, donc j'aimerais étudier à l'avenir.

Selon le commentaire source original, lors de l'utilisation de polynomial_features et feature_interaction, il est préférable de définir ce paramètre avec une valeur faible. Est-ce une image que la quantité de caractéristiques créée par l'interaction devrait être réduite dans une certaine mesure dans ce processus?

Réduction des caractéristiques de cardinalité élevée

La spécification d'une colonne avec une cardinalité élevée réduit les types de données dans la colonne et abaisse la cardinalité.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

high_cardinality_features (type de chaîne, par défaut = Aucun)
Spécifie la colonne (cardinalité élevée) à convertir.

high_cardinality_method (type de chaîne, par défaut = 'fréquence')
Spécifiez la méthode de conversion.
Vous pouvez sélectionner «fréquence» ou «clustering».
Si «fréquence» est spécifié, les données d'origine sont remplacées par la fréquence d'occurrence (valeur numérique) pour chaque type de données.
Si 'clustering' est spécifié, le clustering est effectué et le résultat (étiquette de classe) remplace les données d'origine.

référence

Pour les données de cardinalité, reportez-vous à cet article. https://qiita.com/soyanchu/items/034be19a2e3cb87b2efb

Dans la méthode de «clustering», k-means est utilisé pour un aperçu rapide de la source de la famille d'origine.

Je n'ai pas entièrement compris les avantages de la réduction de la cardinalité, alors j'aimerais étudier à l'avenir.

Mise à l'échelle des fonctionnalités

Met à l'échelle le montant de la fonction selon la méthode spécifiée.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

transformation (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

transformation_method (type de chaîne, par défaut = 'yeo-johnson')
Spécifiez la méthode de conversion.
Vous pouvez sélectionner'yeo-johnson 'ou' quantile '.
'Yeo-johnson' effectue la conversion Yeo-Johnson.
Est-ce que «quantile» est un quadrant? tenir.

référence

«Yeo-johnson» et «quantile» semblent transformer les données pour suivre une distribution normale.

Je ne comprends pas les détails, donc j'aimerais étudier à l'avenir.

Une vérification rapide du code d'origine montre que «l'yeo-johnson» utilise sklearn.preprocessing.PowerTransformer et «quantile» utilise sklearn.preprocessing.QuantileTransformer.

En général, rapprocher les caractéristiques d'une distribution normale peut être utile lors de la modélisation. Selon le commentaire de la source originale, «quantile» est non linéaire et il convient de noter qu'il peut fausser la corrélation linéaire entre les variables mesurées sur la même échelle.

Mise à l'échelle de la variable objective

Met à l'échelle la variable objectif selon la méthode spécifiée.

Pour le moment, cet élément ne peut pas être spécifié dans le package de classification. Il ne prend en charge que les transformations pour se rapprocher d'une distribution normale, ce qui est probablement dû au fait qu'il s'agit d'un traitement inutile dans la tâche de classification.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

transform_target (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

transform_target_method (type de chaîne, par défaut = 'box-cox')
Spécifiez la méthode de conversion.
Vous pouvez sélectionner'Box-cox'ou'yeo-johnson '.
`Box-cox effectue une conversion Box-Cox.
'Yeo-johnson' effectue la conversion Yeo-Johnson.

référence

Rapprocher la variable objective d'une distribution normale peut être utile lors de la modélisation.

La conversion Box-Cox a une restriction selon laquelle toutes les données sont des valeurs positives, donc si les données contiennent des valeurs négatives, il semble passer de force à la conversion Yeo-Johnson.

Pour la conversion Box-Cox, reportez-vous à cet article. https://qiita.com/dyamaguc/items/b468ae66f9ce6ee89724

Réduction de dimension de la quantité de caractéristiques

Nous réduirons la dimension du montant de la fonction.

Paramètres

Il peut être exécuté en donnant l'argument suivant à setup ().

pca (type booléen, par défaut = False)
Spécifiez s'il faut exécuter ce processus (Vrai / Faux).

pca_method (type de chaîne, par défaut = 'linéaire')
'linéaire': réduction de dimension par analyse en composantes principales (linéaire).
'kernel': réduction de dimension par analyse des composants principaux du noyau.
'incrémental': la réduction de dimension est effectuée par analyse en composantes principales (données de masse ver).

pca_components (type int / float, par défaut = 0,99)
Spécifiez le nombre / pourcentage d'entités à conserver après la réduction de dimension.
S'il est spécifié comme type int, il sera traité comme le nombre d'entités à laisser.
Il est nécessaire de spécifier une valeur inférieure au nombre original de fonctionnalités.
S'il est spécifié comme type flottant, il sera traité comme un pourcentage des fonctionnalités restantes.

référence

En général, il est effectué dans le but de supprimer des fonctionnalités sans importance et d'économiser de la mémoire et des ressources CPU.

Ce processus (réduction de dimension) semble être exécuté à la fin du pipeline de prétraitement. (La dimension est réduite pour les données une fois qu'un autre prétraitement est terminé.)

Cet article sera utile pour l'analyse des composants principaux. https://qiita.com/shuva/items/9625bc326e2998f1fa27 https://qiita.com/NoriakiOshita/items/460247bb57c22973a5f0

Pour «incrémental», il semble utiliser une méthode appelée Incremental PCA. Selon l'explication de scikit-learn, si l'ensemble de données cible est trop volumineux pour tenir dans la mémoire, il est préférable d'utiliser la PCA incrémentielle (IPCA) au lieu de l'analyse en composantes principales (PCA). IPCA utilise la quantité de mémoire qui ne dépend pas du nombre de données d'entrée pour créer une approximation de faible dimension des données d'entrée. https://scikit-learn.org/stable/auto_examples/decomposition/plot_incremental_pca.html

Exemple d'implémentation

Créez un grand nombre de fonctionnalités

from pycaret.regression import *
X, y, X_train, X_test, y_train, y_test, seed, prep_pipe, target_inverse_transformer, experiment__ \
    =  setup(dataset, target="Price", session_id=123, 
             bin_numeric_features = ["Carat Weight"],
             create_clusters = True,
             polynomial_features = True,  feature_interaction = True,  feature_ratio = True)

Le contenu de l'exécution (extrait) de la sortie de setup () est comme indiqué dans la figure ci-dessous.

En vérifiant les données prétraitées renvoyées, 72 fonctionnalités ont été générées comme indiqué ci-dessous.

print(X.info())

#Résultat de sortie
# <class 'pandas.core.frame.DataFrame'>
# Int64Index: 6000 entries, 0 to 5999
# Data columns (total 72 columns):
#  #   Column                                            Non-Null Count  Dtype  
# ---  ------                                            --------------  -----  
#  0   Carat Weight_Power2                               6000 non-null   float64
#  1   Cut_Fair                                          6000 non-null   float64
#  2   Cut_Good                                          6000 non-null   float64
#  3   Cut_Ideal                                         6000 non-null   float64
#  4   Cut_Signature-Ideal                               6000 non-null   float64
#  5   Cut_Very Good                                     6000 non-null   float64
#  6   Color_D                                           6000 non-null   float64
#  7   Color_E                                           6000 non-null   float64
#  8   Color_F                                           6000 non-null   float64
#  9   Color_G                                           6000 non-null   float64
#  10  Color_H                                           6000 non-null   float64
#  11  Color_I                                           6000 non-null   float64
#  12  Clarity_FL                                        6000 non-null   float64
#  13  Clarity_IF                                        6000 non-null   float64
#  14  Clarity_SI1                                       6000 non-null   float64
#  15  Clarity_VS1                                       6000 non-null   float64
#  16  Clarity_VS2                                       6000 non-null   float64
#  17  Clarity_VVS1                                      6000 non-null   float64
#  18  Clarity_VVS2                                      6000 non-null   float64
#  19  Polish_EX                                         6000 non-null   float64
#  20  Polish_G                                          6000 non-null   float64
#  21  Polish_ID                                         6000 non-null   float64
#  22  Polish_VG                                         6000 non-null   float64
#  23  Symmetry_EX                                       6000 non-null   float64
#  24  Symmetry_G                                        6000 non-null   float64
#  25  Symmetry_ID                                       6000 non-null   float64
#  26  Symmetry_VG                                       6000 non-null   float64
#  27  Report_GIA                                        6000 non-null   float64
#  28  Carat Weight_0.0                                  6000 non-null   float64
#  29  Carat Weight_1.0                                  6000 non-null   float64
#  30  Carat Weight_10.0                                 6000 non-null   float64
#  31  Carat Weight_11.0                                 6000 non-null   float64
#  32  Carat Weight_12.0                                 6000 non-null   float64
#  33  Carat Weight_13.0                                 6000 non-null   float64
#  34  Carat Weight_2.0                                  6000 non-null   float64
#  35  Carat Weight_3.0                                  6000 non-null   float64
#  36  Carat Weight_4.0                                  6000 non-null   float64
#  37  Carat Weight_5.0                                  6000 non-null   float64
#  38  Carat Weight_6.0                                  6000 non-null   float64
#  39  Carat Weight_7.0                                  6000 non-null   float64
#  40  Carat Weight_8.0                                  6000 non-null   float64
#  41  Carat Weight_9.0                                  6000 non-null   float64
#  42  data_cluster_0                                    6000 non-null   float64
#  43  Polish_EX_multiply_Carat Weight_Power2            6000 non-null   float64
#  44  Symmetry_EX_multiply_Carat Weight_Power2          6000 non-null   float64
#  45  Report_GIA_multiply_Carat Weight_Power2           6000 non-null   float64
#  46  Clarity_VVS2_multiply_Carat Weight_Power2         6000 non-null   float64
#  47  Clarity_IF_multiply_Carat Weight_Power2           6000 non-null   float64
#  48  Clarity_SI1_multiply_Carat Weight_Power2          6000 non-null   float64
#  49  Carat Weight_Power2_multiply_data_cluster_0       6000 non-null   float64
#  50  Symmetry_EX_multiply_data_cluster_0               6000 non-null   float64
#  51  Report_GIA_multiply_data_cluster_0                6000 non-null   float64
#  52  Symmetry_VG_multiply_Carat Weight_Power2          6000 non-null   float64
#  53  Carat Weight_8.0_multiply_Carat Weight_Power2     6000 non-null   float64
#  54  Cut_Signature-Ideal_multiply_Carat Weight_Power2  6000 non-null   float64
#  55  data_cluster_0_multiply_Symmetry_EX               6000 non-null   float64
#  56  Color_E_multiply_Carat Weight_Power2              6000 non-null   float64
#  57  data_cluster_0_multiply_Cut_Ideal                 6000 non-null   float64
#  58  Carat Weight_Power2_multiply_Polish_EX            6000 non-null   float64
#  59  data_cluster_0_multiply_Report_GIA                6000 non-null   float64
#  60  Color_F_multiply_Carat Weight_Power2              6000 non-null   float64
#  61  Carat Weight_Power2_multiply_Carat Weight_8.0     6000 non-null   float64
#  62  Cut_Ideal_multiply_Carat Weight_Power2            6000 non-null   float64
#  63  Color_D_multiply_Carat Weight_Power2              6000 non-null   float64
#  64  data_cluster_0_multiply_Carat Weight_Power2       6000 non-null   float64
#  65  data_cluster_0_multiply_Polish_EX                 6000 non-null   float64
#  66  Color_I_multiply_Carat Weight_Power2              6000 non-null   float64
#  67  Polish_EX_multiply_data_cluster_0                 6000 non-null   float64
#  68  Color_H_multiply_Carat Weight_Power2              6000 non-null   float64
#  69  Carat Weight_Power2_multiply_Report_GIA           6000 non-null   float64
#  70  Clarity_VS2_multiply_Carat Weight_Power2          6000 non-null   float64
#  71  Carat Weight_Power2_multiply_Symmetry_VG          6000 non-null   float64
# dtypes: float64(72)
# memory usage: 3.3 MB

La vérification du pipeline de prétraitement renvoyé est la suivante.

print(prep_pipe)

#Résultat d'exécution
# Pipeline(memory=None,
#          steps=[('dtypes',
#                  DataTypes_Auto_infer(categorical_features=[],
#                                       display_types=True, features_todrop=[],
#                                       ml_usecase='regression',
#                                       numerical_features=[], target='Price',
#                                       time_features=[])),
#                 ('imputer',
#                  Simple_Imputer(categorical_strategy='not_available',
#                                 numeric_strategy='mean',
#                                 target_variable=None)),
#                 ('new_levels1',
#                  New_Catagorical_Levels_i...
#                 ('dummy', Dummify(target='Price')),
#                 ('fix_perfect', Remove_100(target='Price')),
#                 ('clean_names', Clean_Colum_Names()),
#                 ('feature_select', Empty()), ('fix_multi', Empty()),
#                 ('dfs',
#                  DFS_Classic(interactions=['multiply', 'divide'],
#                              ml_usecase='regression', random_state=123,
#                              subclass='binary', target='Price',
#                              top_features_to_pick_percentage=None)),
#                 ('pca', Empty())],
#          verbose=False)

Résumé

** PyCaret peut effectuer divers traitements de nettoyage de données et de conversion de fonctionnalités avec un code simple ** PyCaret peut décrire divers pré-traitements simplement en spécifiant les paramètres, et j'ai senti que cela conduirait à un gain de temps important. J'ai également pensé que le code serait plus propre et plus unifié, ce qui améliorerait la lisibilité et l'efficacité de la réflexion pour l'équipe et moi-même.

** Comprendre le prétraitement réalisable avec PyCaret conduit également à étudier diverses techniques ** PyCaret est relativement facile à réaliser, même pour ceux qui ne sont pas doués pour le codage. Je pensais que ce serait un bon outil pour les débutants qui avaient trébuché dans le codage jusqu'à présent, de se concentrer sur l'apprentissage de la théorie tout en la déplaçant réellement. (J'ai moi-même appris beaucoup de techniques que je ne connaissais pas auparavant en menant cette recherche.)

** D'autre part (pour le moment) PyCaret n'est qu'un outil d'efficacité ** PyCaret n'effectue que le traitement de nettoyage et de conversion de la quantité de caractéristiques en fonction des données saisies par l'utilisateur, et j'ai réalisé qu'il était toujours nécessaire d'effectuer manuellement la création d'hypothèses, la collecte de données et la conception de la quantité de caractéristiques. C'est fait.

[PYTHON] J'ai étudié le prétraitement qui peut être fait avec PyCaret

À propos de ce document

Hypothèses de mise en œuvre

Qu'est-ce que PyCaret

Comment exécuter le prétraitement

Appeler la fonction d'exécution de saisie / prétraitement de données

Vérifiez le résultat de l'estimation du type de chaque variable

Vérifiez le résumé d'exécution du prétraitement

Informations sur la session

Informations sur les données d'entrée

Caractéristiques numériques et caractéristiques catégorielles

Informations sur la division des données du train / test

Informations sur l'échantillonnage des données

(Autre) Méthodes liées au nettoyage des données et au traitement de la conversion de la quantité de caractéristiques

Processus de nettoyage des données et de conversion des fonctionnalités

Les données après le prétraitement sont renvoyées comme valeur de retour de setup ()

regression

classification

Exclusion de la quantité de caractéristiques

Paramètres

référence

Combler la carence

Paramètres

référence

Codage séquentiel des données

Paramètres

Normalisation des fonctionnalités

Paramètres

référence

Intégration de valeurs rares dans des variables catégorielles

Paramètres

référence

Binning de données numériques

Paramètres

référence

Suppression des valeurs aberrantes

Paramètres

référence

Suppression de multico

Paramètres

référence

Quantification des caractéristiques des résultats des anneaux de classe

Paramètres

référence

Suppression de fonctionnalités par distribution de données

Paramètres

référence

Génération de fonctionnalités d'interaction

Paramètres

référence

Génération de fonctionnalités de groupe

Paramètres

Exécution de la sélection de quantité de fonction

Paramètres

référence

Réduction des caractéristiques de cardinalité élevée

Paramètres

référence

Mise à l'échelle des fonctionnalités

Paramètres

référence

Mise à l'échelle de la variable objective

Paramètres

référence

Réduction de dimension de la quantité de caractéristiques

Paramètres

référence

Exemple d'implémentation

Créez un grand nombre de fonctionnalités

Résumé

`regression`

`classification`