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

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

À 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

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é.

** 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/

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")

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".

image.png

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) image.png

(Pour les tâches de classification) image.png

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

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.

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 ().

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 ().



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 ().

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 ().



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 ().



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 ().

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é.)

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 ().



référence

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

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 ().



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 ().



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 ().

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?

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 ().







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.





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.

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

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.

image.png

Paramètres

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



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 ().



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.

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 ().



référence

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

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 ().



référence

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

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.

Paramètres

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



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.

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 ().





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.

Recommended Posts

J'ai étudié le prétraitement qui peut être fait avec PyCaret
Il semble que le suivi des squelettes puisse être effectué avec RealSense
J'ai fait un shuffle qui peut être réinitialisé (inversé) avec Python
J'ai essayé de l'étendre pour que la base de données puisse être utilisée avec le logiciel d'analyse de Wiire
J'ai acheté et analysé la loterie jumbo de fin d'année avec Python qui peut être exécutée dans Colaboratory
Types de fichiers pouvant être utilisés avec Go
Répertorier les packages pouvant être mis à jour avec pip
J'ai essayé de résumer les opérations susceptibles d'être utilisées avec numpy-stl
Notes sur les connaissances Python utilisables avec AtCoder
Un mémo que j'ai touché au magasin de données avec python
Limites qui peuvent être analysées à la fois avec MeCab
Lister les classes qui peuvent être référencées par ObjCClass
Analyse morphologique et tfidf (avec code de test) pouvant être effectuée en 1 minute environ
A étudié le problème que plus de 101 images ne pouvaient pas être acquises avec le téléchargement de Google Images
L'histoire selon laquelle sendmail qui peut être exécuté dans le terminal ne fonctionnait pas avec cron
[Python] J'ai examiné une pratique qui peut être exécutée en parallèle avec le thread principal par traitement asynchrone (multiprocessing, asyncio)
Récapitulatif du format des formats qui peuvent être sérialisés avec gensim
Pourquoi puis-je utiliser le module en important avec python?
J'ai essayé le clustering avec PyCaret
Goroutine (contrôle parallèle) utilisable sur le terrain
Analyse de texte pouvant être effectuée en 5 minutes [Word Cloud]
Goroutine utilisable sur le terrain (édition errgroup.Group)
[Atcoder] [C ++] J'ai fait un outil d'automatisation de test qui peut être utilisé pendant le concours
Calibrer le modèle avec PyCaret
J'ai créé un plug-in qui peut faire "Daruma-san tombé" avec Minecraft
Faisons un diagramme sur lequel on peut cliquer avec IPython
[Flask] J'ai essayé de résumer la "configuration docker-compose" qui peut être créée rapidement pour les applications Web
Comprendre les probabilités et les statistiques qui peuvent être utilisées pour la gestion des progrès avec un programme python
À propos du fait que le résumé de la torche peut être vraiment utilisé lors de la construction d'un modèle avec Pytorch
[Python] Un programme qui trouve le nombre maximum de jouets pouvant être achetés avec votre argent
Prédisez le nombre de coussins qui peuvent être reçus en tant que répondants rires avec Word2Vec + Random Forest
[Python] Créez un graphique qui peut être déplacé avec Plotly
J'ai fait un package qui peut comparer des analyseurs morphologiques avec Python
Créez une Spinbox qui peut être affichée en binaire avec Tkinter
J'ai étudié la méthode X-means qui estime automatiquement le nombre de clusters
Créez un graphique des devises qui peut être déplacé avec Plotly (2)
Comparaison de 4 styles pouvant être passés à seaborn avec set_context
Créez une Spinbox pouvant être affichée dans HEX avec Tkinter
Module standard Python utilisable en ligne de commande
Créez un graphique des devises qui peut être déplacé avec Plotly (1)
J'ai fait un programme qui calcule automatiquement le zodiaque avec tkinter
Puis-je être un data scientist?
J'ai étudié le mécanisme de connexion flask!
requirements.txt peut être commenté avec #
J'ai étudié à quoi ressemble la lunette
J'ai aimé le tweet avec python. ..
Confirmation que rkhunter peut être installé
J'ai étudié la superposition de l'arborescence des appareils
Un mémo lors de la création d'un environnement qui peut être débogué avec Lambda @ Edge pour le moment
[Python] Code qui peut être écrit avec la mort cérébrale au début lors du scraping en tant que débutant
La barre de données EXCEL et l'échelle de couleurs peuvent également être faites avec des pandas
À propos du fait que l'objet recompilé peut être utilisé pour le modèle re.match
J'ai créé un modèle de projet Python générique
Module de traitement du signal acoustique qui peut être utilisé avec Python-Sounddevice ASIO [Application]
Le panneau Web LXC qui peut faire fonctionner LXC avec un navigateur était merveilleux
Masquer l'avertissement selon lequel zsh peut être utilisé par défaut sur Mac
Créez une application Web qui peut être facilement visualisée avec Plotly Dash
Bot LINE sans serveur qui peut être réalisé en 2 heures (acquisition de l'identifiant source)
[Peut être fait en 10 minutes] Créez rapidement un site Web local avec Django