Cet article est un complément à l'apprentissage des fonctionnalités. Les étudiants intéressés par une analyse détaillée de l'ingénierie des fonctionnalités peuvent passer à la trilogie d'ingénierie des fonctionnalités.

Cours intensifs sur des cas d'application pratiques des algorithmes MATLAB-[Applications numériques et analogiques] Feature Engineering

Cours intensifs sur des cas d'application pratiques des algorithmes MATLAB - [Applications numériques et analogiques] Feature Engineering (Supplémentaire)

Cours intensifs sur des cas d'application pratiques des algorithmes MATLAB - [Applications numériques et analogiques] Feature Engineering (Final)

La figure ci-dessus est l'organigramme familier de la modélisation de l'apprentissage automatique. Une étape très importante dans l'ensemble du processus de modélisation est le prétraitement des données et l'ingénierie des fonctionnalités, qui déterminent en grande partie la qualité de l'effet de modélisation final.

Introduction à l'ingénierie des fonctionnalités

Tout d’abord, jetons un coup d’œil à « l’ingénierie des fonctionnalités ». En fait, vous avez déjà vu que nous avons créé des fonctionnalités dans la série pratique d'articles de ShowMeAI. Projet complet d'apprentissage automatique Python - Prévisions des ventes de commerce électronique [2] et Projet complet d'apprentissage automatique Python - Prévisions des ventes de commerce électronique (avancé) [3] Traitement d'ingénierie.

Si nous définissons l'ingénierie des fonctionnalités , elle fait référence à : l'utilisation de la connaissance du domaine et des données existantes pour créer de nouvelles fonctionnalités à utiliser dans les algorithmes d'apprentissage automatique ; elle peut être manuelle ou automatique.

Il existe un dicton populaire dans l'industrie : l'ingénierie des données et des fonctionnalités détermine la limite supérieure du modèle, et l'algorithme amélioré s'approche tout juste de cette limite supérieure.

En effet, en termes de modélisation des données, il existe une différence entre « état idéal » et « scène réelle ». Dans de nombreux cas, les données originales ne se présentent pas sous une forme propre, claire et suffisante :

Le processus d'ingénierie des fonctionnalités équivaut à trier les données, à extraire des informations significatives en combinaison avec l'entreprise et à les organiser sous une forme propre et ordonnée : l'ingénierie des fonctionnalités a des significations très importantes :

Le contenu de cet article comprend " 1. Type de fonctionnalité ", " 2. Nettoyage des données ", " 3. Construction de fonctionnalités ", " 4. Transformation de fonctionnalités ", " 5. Sélection de fonctionnalités " et d'autres sections.

Projet de combat Titanic

Ici, nous utilisons l' ensemble de données Titanic le plus simple et le plus couramment utilisé pour vous l'expliquer.

L'ensemble de données Titanic est un ensemble de données très adapté aux débutants en science des données et en apprentissage automatique. L'ensemble de données contient les informations personnelles et l'état de survie de certains membres de l'équipage dans l'épave du Titanic en 1912. Nous pouvons former un modèle approprié sur l'ensemble de données et prédire la survie dans de nouvelles données (ensemble de test).

L'ensemble de données Titanic peut être chargé directement via la bibliothèque d'outils Seaborn, comme indiqué dans le code suivant :

import pandas as pd
import numpy as np
import seaborn as sns
df_titanic = sns.load_dataset('titanic')

La description du champ de données de l'ensemble de données est présentée dans la figure suivante :

1. Type de fonctionnalité

Avant de démontrer le prétraitement des données et l'ingénierie des fonctionnalités de Titanic, ShowMeAI vous donnera quelques connaissances de base sur les données.

Les données peuvent être divisées en « données structurées » et « données non structurées ». Par exemple, dans le domaine Internet, la plupart des données commerciales tabulaires stockées dans les bases de données sont des données structurées, tandis que le texte, la voix, l'image et la vidéo, etc. appartiennent aux données non structurées.

Pour les données que nous avons enregistrées, nous pouvons généralement distinguer l'alignement des « données quantitatives » et des « données qualitatives », où :

Données quantitatives : Désigne certaines valeurs numériques utilisées pour mesurer la quantité et la taille. Tels que la hauteur, la longueur, le volume, la surface, l'humidité, la température et d'autres mesures.
Données qualitatives : Désigne les catégories qui décrivent la nature des éléments. Tels que la texture, le goût, l’odeur, la couleur, etc.

2. Nettoyage des données

Avant l'exploration ou la modélisation des données proprement dite, nous disposerons d'un lien de « prétraitement des données » pour effectuer le nettoyage des données et d'autres opérations sur les données d'origine.

Étant donné que les données du monde réel sont généralement des « données sales » incomplètes et incohérentes, l'exploration de données ne peut pas être effectuée directement ou les résultats de l'exploration ne sont pas satisfaisants.

Les principales causes de « données sales » comprennent : les données falsifiées, les données incomplètes, l’incohérence des données, la duplication des données, les données anormales, etc.

Le processus de nettoyage des données comprend les méthodes de traitement des données « 2.1 Alignement des données », « 2.2 Traitement des valeurs manquantes », « 2.3 Traitement des valeurs anormales », « 2.4 Conversion des données, etc. ». Nous expliquons ces méthodes de traitement en détail.

2.1 Alignement des données

Les données brutes collectées ont différents formats et formes. Nous effectuerons un traitement d'alignement des données sur le temps, les champs et les dimensions associées. Après l'alignement et la normalisation des données, les données sont soignées et cohérentes, ce qui est plus approprié pour la modélisation. La figure suivante montre quelques exemples de traitement :

① Heure

Les formats de date sont incohérents〖2022-02-20, 20220220, 2022/02/20, 20/02/2022〗.
Les unités d'horodatage sont incohérentes, certaines sont exprimées en secondes et d'autres en millisecondes.
Utilisez une heure non valide pour représenter, utilisez 0 pour représenter l'horodatage et utilisez FFFF pour représenter l'horodatage de fin.

② champ

Le sexe est inscrit dans le nom et le numéro de téléphone portable est inscrit dans le numéro d'identification.

③dimension

Le type numérique est unifié [tel que 1, 2.0, 3.21E3, quatre].
L'unité est unifiée [comme 180 cm, 1,80 m].

2.2 Traitement des valeurs manquantes

Les données manquantes sont un problème courant dans les données réelles. Pour diverses raisons, les données que nous collectons ne sont pas nécessairement complètes. Nous avons des méthodes courantes pour traiter les valeurs manquantes. La méthode de traitement spécifique peut être développée dans un diagramme :

Non traité (certains modèles tels que XGBoost[4] / LightGBM[5], etc. peuvent gérer les valeurs manquantes).
Supprimez les données manquantes (en fonction de la dimension de l'échantillon ou de la dimension du champ).
Remplissez avec la moyenne, la médiane, le mode, les moyennes de classe ou les estimations.

En revenant à notre ensemble de données Titanic, nous démontrons diverses méthodes. Comprenons d'abord la valeur manquante de l'ensemble de données (distribution récapitulative) :

df_titanic.isnull().sum()

survived         0
pclass           0
sex              0
age            177
sibsp            0
parch            0
fare             0
embarked         2
class            0
who              0
adult_male       0
deck           688
embark_town      2
alive            0
alone            0

(1) Suppression et traitement des valeurs manquantes

Le traitement le plus direct et le plus grossier consiste à éliminer les valeurs manquantes, c'est-à-dire à supprimer les objets (champs, échantillons/enregistrements) avec des valeurs d'attributs d'informations manquantes, afin d'obtenir un tableau d'informations complet. Les avantages et inconvénients sont les suivants :

Avantages : Simple et facile à mettre en œuvre, il est efficace lorsque l'objet a plusieurs valeurs d'attribut manquantes et que les objets supprimés avec des valeurs manquantes sont très petits par rapport au volume de données de l'ensemble de données initial ;
Inconvénients : Lorsque la proportion de données manquantes est importante, en particulier lorsque les données manquantes ne sont pas distribuées de manière aléatoire, cette méthode peut conduire à des écarts de données, conduisant à des conclusions erronées.

Dans notre cas Titanic actuel, embark_townle champ a 2 valeurs nulles, pensez à supprimer le traitement manquant.

df_titanic[df_titanic["embark_town"].isnull()]
df_titanic.dropna(axis=0,how='any',subset=['embark_town'],inplace=True)

(2) Remplissage des données et traitement des valeurs manquantes

La deuxième catégorie est que nous pouvons utiliser certaines méthodes pour remplir les valeurs manquantes. Par exemple, le remplissage basé sur des méthodes statistiques, des méthodes modèles et des méthodes combinées avec les affaires.

① Remplissage manuel . Le remplissage manuel est effectué sur la base des connaissances métier.

② Remplir avec une valeur spéciale . Traitez les valeurs nulles comme une valeur de propriété spéciale, différente de toute autre valeur de propriété. Comme toutes les valeurs vides sont unknownremplies. Généralement comme remplissage temporaire ou processus intermédiaire.

df_titanic['embark_town'].fillna('unknown', inplace=True)

③ Remplissage statistique . Si le taux manquant est faible, il peut être comblé en fonction de la répartition des données. Les statistiques de remplissage courantes sont les suivantes :

Médiane : Pour les données avec une distribution asymétrique, la médiane est utilisée pour combler les valeurs manquantes.
Mode : les fonctionnalités discrètes peuvent utiliser le mode pour remplir les valeurs manquantes.
Moyenne : Pour les données conformes à une distribution uniforme, remplissez les valeurs manquantes avec la moyenne de la variable.

Remplissage médian - tarif : Il existe de nombreuses valeurs manquantes et la médiane est utilisée pour remplir.

df_titanic['fare'].fillna(df_titanic['fare'].median(), inplace=True)

Mode de remplissage—embarqué : il n'y a que deux valeurs manquantes et le mode de remplissage est utilisé.

df_titanic['embarked'].isnull().sum()
#执行结果：2
df_titanic['embarked'].fillna(df_titanic['embarked'].mode(), inplace=True)
df_titanic['embarked'].value_counts()
#执行结果：
#S    64

Rembourrage moyen.

age : Groupe par sexe, pclasse et qui, s'ils appartiennent au même groupe, remplissent avec la moyenne ou la médiane de ce groupe.

df_titanic.groupby(['sex', 'pclass', 'who'])['age'].mean()

age_group_mean = df_titanic.groupby(['sex', 'pclass', 'who'])['age'].mean().reset_index()

def select_group_age_median(row):
    condition = ((row['sex'] == age_group_mean['sex']) &
                (row['pclass'] == age_group_mean['pclass']) &
                (row['who'] == age_group_mean['who']))
    return age_group_mean[condition]['age'].values[0]

df_titanic['age'] =df_titanic.apply(lambda x: select_group_age_median(x) if np.isnan(x['age']) else x['age'],axis=1)

④ Remplissage des prévisions du modèle . Si d'autres champs non manquants sont abondants, on peut également utiliser le modèle pour modéliser et prédire le remplissage. Le champ à remplir est utilisé comme Label, et les données sans données manquantes sont utilisées comme données d'entraînement. Un modèle de classification/régression. est établi pour prédire et combler les champs manquants à remplir. .

Voisin le plus proche (KNN) . Déterminez d'abord les K échantillons les plus proches de l'échantillon avec des données manquantes selon la distance euclidienne ou l'analyse de corrélation, et utilisez la moyenne pondérée/vote de ces K valeurs pour estimer les données manquantes de l'échantillon.
Régression . Sur la base de l'ensemble complet de données, une équation de régression est établie. Pour les objets contenant des valeurs nulles, la valeur de propriété inconnue est estimée en remplaçant la valeur de propriété connue dans l'équation, et cette estimation est utilisée pour compléter. Lorsque les variables ne sont pas liées de manière linéaire, cela conduit à des estimations biaisées et la régression linéaire est souvent utilisée.

Prenons comme exemple le champ d'âge dans l'affaire Titanic pour expliquer :

Il manque une grande quantité d'âge. Ici, nous utilisons les six caractéristiques de sexe, pclass, who, fare, parch et sibsp pour construire un modèle de forêt aléatoire afin de remplir les valeurs d'âge manquantes.

df_titanic_age = df_titanic[['age', 'pclass', 'sex', 'who','fare', 'parch', 'sibsp']]
df_titanic_age = pd.get_dummies(df_titanic_age)
df_titanic_age.head()

# 乘客分成已知年龄和未知年龄两部分
known_age = df_titanic_age[df_titanic_age.age.notnull()]
unknown_age = df_titanic_age[df_titanic_age.age.isnull()]
# y 即目标年龄
y_for_age = known_age['age']
# X 即特征属性值
X_train_for_age = known_age.drop(['age'], axis=1)
X_test_for_age = unknown_age.drop(['age'], axis=1)
from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor(random_state=0, n_estimators=2000, n_jobs=-1)
rfr.fit(X_train_for_age, y_for_age)
# 用得到的模型进行未知年龄结果预测
y_pred_age = rfr.predict(X_test_for_age)
# 用得到的预测结果填补原缺失数据
df_titanic.loc[df_titanic.age.isnull(), 'age'] = y_pred_age

sns.distplot(df_titanic.age)

⑤ Remplissage par interpolation . Vous pouvez également utiliser la méthode d'interpolation pour remplir les données, notamment l'interpolation linéaire, l'interpolation multiple, l'interpolation sur plateforme chaude, l'interpolation lagrangienne, l'interpolation de Newton, etc.

interpolation linéaire

.interpolate(method = 'linear', axis)La méthode remplacera les valeurs NaN linearle long de la valeur donnée par interpolation , la différence est la valeur médiane avant et après ou de haut en basaxis

df_titanic['fare'].interpolate(method = 'linear', axis = 0)

Dans le même temps, les valeurs de ligne peuvent également être utilisées pour insérer

df_titanic['fare'].interpolate(method = 'linear', axis = 1)

Imputation multiple

L'idée d'interpolation multi-valeurs vient de l'estimation bayésienne, qui considère que la valeur à interpoler est aléatoire, et que sa valeur provient de la valeur observée. En pratique, les valeurs à interpoler sont généralement estimées, puis différents bruits sont ajoutés pour former plusieurs ensembles de valeurs interpolées facultatives. Selon une base de sélection, sélectionnez la valeur d'interpolation la plus appropriée. La méthode d'imputation multiple comporte trois étapes :

① Générer un ensemble de valeurs d'imputation possibles pour chaque valeur nulle, qui reflètent l'incertitude du modèle de non-réponse ; chaque valeur peut être utilisée pour imputer les valeurs manquantes dans l'ensemble de données, ce qui donne plusieurs ensembles de données complets ;
② Chaque ensemble de données d'imputation est analysé statistiquement à l'aide de la méthode statistique pour l'ensemble de données complet ;
③ Les résultats de chaque ensemble de données d'imputation sont sélectionnés en fonction de la fonction de notation pour générer la valeur d'imputation finale.

⑥ Remplissage variable factice . Il existe une autre méthode de remplissage très intéressante appelée "remplissage de variable factice", qui peut être utilisée lorsque la variable est discrète et qu'il y a peu de valeurs différentes. Prenons l'exemple des données du Titanic :

Variable de genre SEX, il existe trois valeurs différentes de male, fameal, NA (manquant), la colonne peut être convertie en IS_SEX_MALE, IS_SEX_FEMALE, IS_SEX_NA.
S'il existe plus d'une douzaine de valeurs différentes pour une variable, les valeurs avec des fréquences plus petites peuvent être classées en une seule catégorie en fonction de la fréquence de chaque valeur otherafin de réduire la dimensionnalité. Cette pratique maximise la préservation des informations variables.

Voici un exemple de code pour référence :

sex_list = ['MALE', 'FEMALE', np.NaN, 'FEMALE', 'FEMALE', np.NaN, 'MALE']
df = pd.DataFrame({'SEX': sex_list})
display(df)

df.fillna('NA', inplace=True)
df = pd.get_dummies(df['SEX'],prefix='IS_SEX')
display(df)

# 原始数据
 SEX
0    MALE
1    FEMALE
2    NaN
3    FEMALE
4    FEMALE
5    NaN
6    MALE
# 填充后
 IS_SEX_FEMALE     IS_SEX_MALE    IS_SEX_NA
0    0                 1                0
1    1                 0                0
2    0                 0                1
3    1                 0                0
4    1                 0                0
5    0                 0                1
6    0                 1

Lorsque les valeurs propres manquent à plus de 80 %, il est recommandé de supprimer [ou d'ajouter des informations de drapeau "oui" et "non"], ce qui affectera facilement l'effet du modèle.

df_titanic.drop(["deck"],axis=1)

2.3 Traitement des valeurs aberrantes

La qualité des données affectera également grandement l'effet d'application de l'apprentissage automatique.Les valeurs d'erreur ou les valeurs aberrantes dans les données peuvent provoquer des erreurs de mesure ou des conditions anormales du système, ce qui entraînera de gros problèmes dans l'apprentissage du modèle. En fait, nous avons souvent des liens de détection et de traitement des valeurs aberrantes. Laissez-moi vous faire un résumé.

(1) Méthode de détection des anomalies

① Basé sur une analyse statistique . Habituellement, l'utilisateur modélise les points de données avec une certaine distribution statistique, puis utilise le modèle supposé pour déterminer s'il est anormal en fonction de la distribution des points. Par exemple, en analysant la divergence des données statistiques, c'est-à-dire l'indice de variation des données, nous pouvons comprendre la distribution des données, puis utiliser l'indice de variation des données pour trouver des données aberrantes dans les données.

Les indicateurs de variation des données couramment utilisés incluent l'intervalle , l'intervalle interquartile , l'écart moyen , l'écart type , le coefficient de variation , etc. Par exemple, une valeur élevée de l'indicateur de variation indique une grande variation et une large distribution ; une petite valeur indique une faible dispersion et une distribution plus dense.

Par exemple, les valeurs maximales et minimales peuvent être utilisées pour juger si la valeur de cette variable dépasse une plage raisonnable. Par exemple, si l'âge du client est de -20 ou 200 ans, il s'agit d'une valeur aberrante.

②Principe 3σ . Si les données sont distribuées à peu près normalement, $3\sigma$ une valeur aberrante est, en principe, une valeur qui s'écarte de plus de 3 écarts types par rapport à la moyenne dans un ensemble de mesures.

③Analyse des boîtes à moustaches . Tout le monde se souvient qu’il existe un outil très efficace dans la section analyse des données appelé boxplot [6]. La méthode d'évaluation des valeurs aberrantes par les diagrammes en boîte est basée sur les quartiles et les intervalles interquartiles. Les quartiles sont robustes. Par conséquent, les diagrammes en boîte sont plus objectifs dans l'identification des valeurs aberrantes et présentent certains avantages dans l'identification des valeurs aberrantes.

sns.catplot(y="fare",x="survived", kind="box", data=df_titanic,palette="Set2")

④ Basé sur la détection du modèle . Nous pouvons également détecter des valeurs aberrantes sur la base du modèle. L'idée de base est d'abord d'établir un modèle de données, et les objets qui ne peuvent pas parfaitement correspondre au même modèle sont considérés comme anormaux. Si le modèle est une collection de clusters, les anomalies sont des objets qui n'appartiennent de manière significative à aucun cluster. Lors de l'utilisation de modèles de régression, les anomalies sont des objets relativement éloignés de la valeur prédite.

Points forts : Avoir des bases solides en théorie statistique, et ces tests peuvent être très puissants lorsque suffisamment de données et de connaissances sur le type de test utilisé sont présentes.
Inconvénients : Pour les données multivariées, moins de choix sont disponibles, et pour les données de grande dimension, ces probabilités de détection sont faibles.

⑤ Basé sur la distance . Nous disposons également de méthodes basées sur la distance qui peuvent être utilisées pour la détection d'anomalies. De telles méthodes reposent sur l’hypothèse qu’un objet de données constitue une anomalie s’il est éloigné de la plupart des points. En définissant la mesure de proximité entre les objets, jugez si l'objet anormal est éloigné des autres objets en fonction de la distance.Les principales méthodes de mesure de distance utilisées incluent la distance absolue (distance de Manhattan), la distance euclidienne et la distance de Mahalanobis.

Avantages : Les méthodes basées sur la distance sont beaucoup plus simples que les méthodes basées sur les statistiques ; car il est beaucoup plus facile de définir une mesure de distance pour un ensemble de données que de déterminer la distribution de l'ensemble de données.
Inconvénients :
- Les méthodes basées sur la proximité prennent $O(m^{2})$ du temps et ne conviennent pas aux grands ensembles de données ;
- La méthode est également sensible au choix des paramètres ;
- Impossible de gérer des ensembles de données avec des régions de densité différente, car il utilise un seuil global qui ne peut pas prendre en compte de tels changements de densité.

⑥ Basé sur la densité . Une idée de détection d'anomalies très directe est basée sur la densité de distribution. Plus précisément : en inspectant la densité autour du point actuel, la densité locale du point anormal local/point aberrant est nettement inférieure à celle de la plupart des points voisins. De telles méthodes conviennent aux ensembles de données non uniformes.

Avantages : Donne une mesure quantitative des valeurs aberrantes des objets et se gère bien même si les données ont des régions distinctes.
Inconvénients :
- Comme les méthodes basées sur la distance, ces méthodes présentent nécessairement $O(m^{2})$ une complexité temporelle importante.
- Pour les données de faible dimension, cela peut être réalisé en utilisant une structure de données spécifique $O(ologme)$ ;
- La sélection des paramètres est difficile.
- Bien que l'algorithme résolve ce problème en observant différentes valeurs de k et en obtenant le score aberrant maximum, il reste nécessaire de choisir des limites supérieure et inférieure pour ces valeurs.

⑦ Basé sur le regroupement . Nous pouvons effectuer une détection d'anomalies basée sur une méthode de regroupement, et les échantillons éloignés du cluster sont plus susceptibles d'être des valeurs aberrantes.

Cependant, cette méthode sera affectée par le nombre de clusters. Une stratégie consiste à répéter l'analyse pour un nombre différent de clusters ; une autre méthode consiste à trouver un grand nombre de petits clusters. L'idée est que les clusters plus petits ont tendance à être plus cohérents. Si un objet constitue une valeur aberrante en présence d’un grand nombre de petits clusters, il s’agit probablement d’une véritable valeur aberrante. L’inconvénient est qu’un groupe de valeurs aberrantes peut former de petits clusters et échapper à la détection.

Avantages :
- Les techniques de regroupement basées sur la complexité linéaire et quasi-linéaire (k-means) peuvent être très efficaces pour trouver des valeurs aberrantes ;
- La définition des clusters est généralement le complément des valeurs aberrantes, il est donc possible de trouver à la fois des clusters et des valeurs aberrantes.
Inconvénients :
- Les ensembles de valeurs aberrantes résultants et leurs scores peuvent dépendre fortement du nombre de clusters utilisés et de la présence de valeurs aberrantes dans les données ;
- La qualité des clusters produits par l’algorithme de clustering a une grande influence sur la qualité des valeurs aberrantes produites par l’algorithme.

⑧ Détection des valeurs aberrantes basée sur la proximité . De la même manière, nous avons également une idée basée sur la proximité pour faire la détection des anomalies : nous pensons que les points anormaux sont éloignés de la plupart des points. Cette approche est plus générale et plus facile à utiliser que les méthodes statistiques, car il est plus facile de déterminer une mesure de proximité significative pour un ensemble de données que de déterminer sa distribution statistique.

Le score aberrant d'un objet est donné par la distance à son voisin le plus proche, le score aberrant est donc très sensible à la valeur de :

Avantages : Simple.
Inconvénients :
- Les méthodes basées sur la proximité prennent $O(m^{2})$ du temps et ne conviennent pas aux grands ensembles de données ;
- La méthode est également sensible au choix des paramètres ;
- Impossible de gérer des ensembles de données avec des régions de densité différente, car il utilise un seuil global qui ne peut pas prendre en compte de tels changements de densité.

Au stade du traitement des données, les valeurs aberrantes sont considérées comme des points aberrants qui affectent la qualité des données, plutôt que comme des points cibles de détection anormale. Généralement, une méthode relativement simple et intuitive est utilisée pour juger la valeur aberrante des variables en combinant les diagrammes en boîte et les statistiques MAD. méthodes. Ce qui suit consiste à dessiner un diagramme de dispersion et à juger directement en fonction de la distribution.

sns.scatterplot(x="fare", y="age", hue="survived",data=df_titanic,palette="Set1")

(2) Méthode de gestion des exceptions

Le traitement des valeurs aberrantes nécessite une analyse spécifique de situations spécifiques. Les méthodes couramment utilisées pour le traitement des valeurs aberrantes sont les suivantes :

Supprimer les enregistrements contenant des valeurs aberrantes : si certains des échantillons anormaux exclus sont vraiment des échantillons inutiles présentant des caractéristiques anormales, il est préférable de confirmer une compilation en collaboration avec l'entreprise pour éviter que les échantillons normaux ne soient filtrés.
Traitez les valeurs aberrantes comme des valeurs manquantes et transmettez-les à la méthode de traitement des valeurs manquantes.
Corrigé en utilisant la moyenne/médiane/mode.
Non traité.

3. Construction des fonctionnalités

Le processus de prétraitement des données de précommande peut garantir que nous obtenons des données propres, soignées et précises, mais ces données ne sont peut-être pas les plus efficaces pour la modélisation. À l'étape suivante, nous effectuons généralement la construction de fonctionnalités et générons des variables dérivées combinées à des scénarios commerciaux. pour améliorer les capacités d’expression des données et modéliser les effets de modélisation.

3.1 Construction des caractéristiques statistiques

Les fonctionnalités statistiques constituent une classe de fonctionnalités très efficace, en particulier dans les scénarios de problèmes de timing. Voici quelques dimensions de réflexion et méthodes pour construire des fonctionnalités statistiques :

Créez de nouvelles fonctionnalités basées sur des règles métier, des connaissances préalables, etc.
Quartile, médiane, moyenne, écart type, écart, asymétrie, inclinaison, système discret.
Construisez des statistiques à long terme et à court terme (telles que des semaines et des mois).
Décroissance temporelle (plus l'observation est proche, plus la valeur du poids est élevée).

Pour en revenir à l'ensemble de données Titanic, examinons les nouvelles fonctionnalités que nous pouvons créer en combinaison avec une compréhension commerciale :

① traitement de l'âge . Nous traitons ensuite le champ d'âge. Étant donné que les personnes de différents groupes d'âge peuvent avoir des probabilités de sauvetage différentes, nous les divisons en différents intervalles en fonction de la valeur d'âge, correspondant à l'enfant, au jeune, à la quarantaine, à la vieillesse, etc.

def age_bin(x):
 if x <= 18:
 return 'child'
 elif x <= 30:
 return 'young'
 elif x <= 55:
 return 'midlife'
 else:
 return 'old'
df_titanic['age_bin'] = df_titanic['age'].map(age_bin)
df_titanic['age_bin'].unique()
执行结果：
array(['young', 'midlife', 'child', 'old'], dtype=object)

② Extrayez la fonctionnalité "titre" . Dans le champ du nom, nous pouvons voir différents titres, tels que "Mr", "Master", "Dr", etc. Ces titres reflètent l'identité du passager et d'autres informations, et nous pouvons les extraire pour construire de nouvelles fonctionnalités.

# 提取称呼
df_titanic['title'] = df_titanic['name'].map(lambda x: x.split(',')[1].split('.')[0].strip())

df_titanic['title'].value_counts()

Les résultats d'exécution sont les suivants :

Mr              757
Miss            260
Mrs             197
Master           61
Rev               8
Dr                8
Col               4
Ms                2
Major             2
Mlle              2
Dona              1
Sir               1
Capt              1
Don               1
Lady              1
Mme               1
the Countess      1
Jonkheer          1

Faisons une simple statistique "d'appel"

# 对称呼细分，是官员，还是皇室，还是女士、先生、小姐
df_titanic['title'].unique()

Résultats du :

array(['Mr', 'Mrs', 'Miss', 'Master', 'Don', 'Rev', 'Dr', 'Mme', 'Ms',
 'Major', 'Lady', 'Sir', 'Mlle', 'Col', 'Capt', 'the Countess',
 'Jonkheer', 'Dona'], dtype=object)

Ensuite, nous normaliserons et unifierons ces « titres » et « titres ».

title_dictionary = {
 "Mr": "Mr",
 "Mrs": "Mrs",
 "Miss": "Miss",
 "Master": "Master",
 "Don": "Royalty",
 "Rev": "Officer",
 "Dr": "Officer",
 "Mme": "Mrs",
 "Ms": "Mrs",
 "Major": "Officer",
 "Lady": "Royalty",
 "Sir": "Royalty",
 "Mlle": "Miss",
 "Col": "Officer",
 "Capt": "Officer",
 "the Countess": "Royalty",
 "Jonkheer": "Royalty",
 "Dona": 'Mrs'
}
df_titanic['title'] = df_titanic['title'].map(title_dictionary)
df_titanic['title'].value_counts()

Les résultats d'exécution sont les suivants :

Mr         757
Miss       262
Mrs        201
Master      61
Officer     23
Royalty      5

③ Sélectionnez la taille de la famille . Sur Titanic, certains membres ont un lien de parenté. Considérant que la taille de la famille a également un impact sur le fait qu'ils soient finalement sauvés, nous pouvons construire une family_size caractéristique pour représenter la taille de la famille.

df_titanic['family_size'] = df_titanic['sibsp'] + df_titanic['parch'] + 1
df_titanic['family_size'].head()

Les résultats d'exécution sont les suivants :

3.2 Valeur de la période

Dans des scénarios tels que le commerce électronique, les données ont une certaine périodicité et nous pouvons extraire certaines valeurs périodiques comme informations efficaces. Certaines considérations concernant le cycle de synchronisation sont les suivantes :

Valeurs de période pour les n périodes/jours/mois/années précédents, telles que les quantiles des 5 derniers jours, les moyennes, etc.
Année/QoQ

3.3 Regroupement des données

Le regroupement de données est une méthode courante de traitement des attributs de valeur continue.Cela signifie que nous découpons les valeurs continues en segments et attribuons des valeurs continues aux segments correspondants. Le regroupement de données est également appelé regroupement de données ou discrétisation.

① Fréquence égale et regroupement équidistant

(a) Classement personnalisé . Fait référence à la définition des intervalles en fonction de l'expérience commerciale ou du bon sens, puis à la classification des données d'origine dans chaque intervalle.

(b) Regroupement équidistant . Divisez les données en parties égales de même largeur.

Le regroupement équidistant ne prend en compte que la limite et le nombre d'instances dans chaque groupe égal peut varier. L’inconvénient du regroupement équidistant est qu’il est fortement affecté par les valeurs aberrantes.

(c) Regroupement à fréquence égale . Divisez les données en plusieurs parties égales et le nombre de données dans chaque partie égale est le même.

Dans le regroupement à fréquence égale, les valeurs limites des intervalles sont calculées de manière à ce que chaque intervalle contienne un nombre d'instances à peu près égal. Disons N = 5, chaque bac devrait contenir environ 20 % des instances.

Binning de variables numériques . Faisons d'abord une segmentation à fréquence égale du prix du billet (si vous dessinez la distribution du prix du billet, vous constaterez qu'il s'agit d'une distribution à très longue queue, qui ne convient pas à une segmentation équidistante), et regardons les segments séparés. intervalles.

# qcut 等频率分箱
df_titanic['fare_bin'], bins = pd.qcut(df_titanic['fare'], 5, retbins=True)
df_titanic['fare_bin'].value_counts()

Le résultat est le suivant :

(7.854, 10.5]        184
(21.679, 39.688]     180
(-0.001, 7.854]      179
(39.688, 512.329]    176
(10.5, 21.679]       172
bins #array([  0.    ,   7.8542,  10.5   ,  21.6792,  39.6875, 512.3292])

Ce qui suit est une segmentation à fréquence égale selon le segment d'intervalle

# 对船票fare进行分段分桶
def fare_cut(fare):
    if fare <=  7.8958:
        return 0
    if fare <= 10.5:
        return 1
    if fare <= 21.6792:
        return 2
    if fare <=  39.6875:
        return 3
    return 4

df_titanic['fare_bin'] = df_titanic['fare'].map(fare_cut)

Par rapport au prix du billet, la répartition du champ d'âge est plus concentrée et la taille de l'intervalle est relativement claire.Nous utilisons une segmentation équidistante et le code est le suivant :

# cut 等距离分箱
bins = [0, 12, 18, 65, 100]
pd.cut(df_titanic['age'], bins).value_counts

② Godets Best-KS .

Étapes de mise en œuvre :

③ Répartition du chi carré . Les méthodes de discrétisation des données ascendantes (c'est-à-dire basées sur le regroupement) reposent sur le test du chi carré : les intervalles adjacents avec la plus petite valeur du chi carré sont regroupés jusqu'à ce qu'un certain critère d'arrêt soit rempli.

Idée de base : deux intervalles adjacents peuvent être fusionnés s'ils ont des distributions de classes très similaires ; sinon, ils doivent rester séparés. Alors que de faibles valeurs du chi carré indiquent qu'ils ont des distributions de classes similaires.

Étapes de mise en œuvre :

Prédéfinir un seuil du chi carré

Initialisation ; trie les instances en fonction des attributs à discrétiser, et chaque instance appartient à un intervalle

Fusionner les intervalles : calculez la valeur du chi carré de chaque paire d'intervalles adjacents et fusionnez la paire d'intervalles avec la plus petite valeur du chi carré

Implémentation du code : https://github.com/Lantianzz/Scorecard-Bundle

④ Regroupement d'entropie minimale . Il existe également la méthode de regroupement à entropie minimale, qui doit minimiser la valeur d'entropie totale, c'est-à-dire permettre au regroupement de distinguer au maximum les catégories de la variable dépendante.

L'entropie est une mesure du degré de désordre des données dans la théorie de l'information. L'objectif fondamental de la proposition d'entropie de l'information est de découvrir la relation entre la quantité d'informations et la redondance d'un certain système de symboles, afin d'obtenir la plus grande efficacité avec le minimum coût et consommation.Stockage, gestion et livraison des données.

Plus l'entropie de l'ensemble de données est faible, plus la différence entre les données est petite.La division minimale de l'entropie est de faire en sorte que les données de chaque boîte aient la meilleure similarité. Compte tenu du nombre de compartiments, si toutes les situations de regroupement possibles sont prises en compte, les compartiments obtenus par la méthode d'entropie minimale devraient être les compartiments avec la plus petite entropie.

3.4 Combinaison de fonctionnalités

Dans certains scénarios, nous envisagerons des combinaisons de fonctionnalités pour créer des fonctionnalités fortes. Voici une méthode de construction de combinaisons de fonctionnalités couramment utilisée :

Discret + Discret : Construisez un produit cartésien (c'est-à-dire une relation "et" par paire).
Discret + continu : produit cartésien après regroupement de fonctionnalités continues ou construction de fonctionnalités statistiques basées sur le regroupement de fonctionnalités de catégorie par.
Continu + continu : addition, soustraction, multiplication et division, caractéristiques polynomiales, différences du second ordre, etc.

caractéristiques polynomiales . Pour les fonctionnalités à valeur continue, nous construisons des fonctionnalités polynomiales pour plusieurs fonctionnalités afin d'obtenir une combinaison de fonctionnalités et une amélioration d'ordre élevé.

Dans le cas du Titanic, les caractéristiques numériques suivantes sont les suivantes :

df_titanic_numerical = df_titanic[['age','sibsp','parch','fare','family_size']]
df_titanic_numerical.head()

Nous pouvons nous référer au code suivant pour créer des fonctionnalités polynomiales

# 扩展数值特征
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=2, include_bias=False, interaction_only=False)
df_titanic_numerical_poly = poly.fit_transform(df_titanic_numerical)
pd.DataFrame(df_titanic_numerical_poly, columns=poly.get_feature_names()).head()

Après avoir construit les fonctionnalités, nous vérifions la corrélation des nouvelles variables de fonctionnalités dérivées. Plus la couleur est foncée dans la carte thermique ci-dessous, plus la corrélation est grande :

sns.heatmap(pd.DataFrame(df_titanic_numerical_poly, columns=poly.get_feature_names()).corr())

4. Transformation des fonctionnalités

Pour les fonctionnalités construites, nous effectuerons quelques opérations de « transformation de fonctionnalités » pour nous adapter aux différents modèles et mieux compléter la modélisation.

4.1 Normalisation

L'opération de normalisation est également appelée transformation du score Z, qui donne à la moyenne arithmétique de la colonne de caractéristiques numériques 0 et à la variance (et à l'écart type) 1, comme le montre la figure.

Remarque : S'il existe des valeurs aberrantes avec des valeurs extrêmement grandes ou petites (découvertes par EDA) dans la colonne des caractéristiques numériques, des statistiques plus robustes (robustes) doivent être utilisées : utilisez la médiane au lieu de la moyenne arithmétique et utilisez le quantile (quantile ) plutôt que la variance. Cette méthode de normalisation a un paramètre important : (quantile inférieur, quantile supérieur), mieux déterminé grâce à la visualisation des données avec EDA. Immunisé contre les valeurs aberrantes.

from sklearn.preprocessing import StandardScale
#标准化模型训练
Stan_scaler = StandardScaler()
Stan_scaler.fit(x)
x_zscore = Stan_scaler.transform(x)
x_test_zscore = Stan_scaler.transform(x_test)
joblib.dump(Stan_scaler,'zscore.m')  #写入文件

4.2 Normalisation

L'opération de normalisation ajustera l'ampleur des données en fonction de la longueur du module vectoriel, mais ne modifiera pas l'ordre des données d'origine. comme le montre la photo.

4.3 Mise à l'échelle de l'amplitude (mise à l'échelle)

La mise à l'échelle de l'amplitude consiste à rendre les valeurs de différentes caractéristiques dans le même ordre de grandeur et le même intervalle de données. La méthode la plus courante consiste à mettre à l'échelle les valeurs maximales et minimales, comme le montre la figure.

from sklearn import preprocessing
min_max_scaler = preprocessing.MinMaxScaler()
min_max_scaler.fit_transform(x)
x_minmax = min_max_scaler.transform(x)
x_test_minmax = min_max_scaler.transform(x_test)
joblib.dump(min_max_scaler,'min_max_scaler.m')  #写入文件

4.4 Normalisation vs normalisation

La normalisation et la normalisation sont deux opérations de transformation de caractéristiques très courantes.Comparons la normalisation et la normalisation :

Leurs scénarios applicables respectifs peuvent être résumés comme suit :

Dans les algorithmes de classification et de clustering, la standardisation du score Z fonctionne mieux lorsque la distance est utilisée pour mesurer la similarité (comme SVM, KNN) ou lorsque la technologie PCA est utilisée pour la réduction de dimensionnalité.

Reportez-vous au didacticiel ShowMeAI Algorithmes graphiques d'apprentissage automatique : de la mise en route à la maîtrise d'une série de didacticiels [7]

La première méthode ou d'autres méthodes de normalisation peuvent être utilisées lorsque la mesure de distance, le calcul de covariance et les données ne sont pas conformes à la distribution normale. Par exemple, en traitement d'image, après conversion d'une image RVB en image en niveaux de gris, sa valeur est limitée à la plage de [0,255].
Les modèles arborescents (tels que Random Forest, GBDT, XGBoost, LightGBM, etc.) ne nécessitent pas de normalisation des fonctionnalités. S'il s'agit d'un modèle basé sur des paramètres ou sur une distance (régression logistique, clustering K-Means, réseau de neurones, etc.), une normalisation est nécessaire car des paramètres ou des distances doivent être calculés.

4.5 Transformation non linéaire

Dans certains scénarios, nous ajustons ou corrigeons également la distribution des champs numériques et utilisons des transformations statistiques ou mathématiques pour réduire l'impact de l'asymétrie de la distribution des données. Faites en sorte que les valeurs des intervalles initialement denses soient dispersées autant que possible et que les valeurs des intervalles initialement dispersés soient agrégées autant que possible. La plupart des fonctions de transformation appartiennent à la famille des fonctions de transformation de puissance, la fonction principale est de stabiliser la variance, de maintenir la distribution proche de la distribution normale et de rendre les données indépendantes de la moyenne de la distribution. Examinons quelques transformations statistiques non linéaires typiques .

① Transformation du journal . La transformation de journal est souvent utilisée pour créer des transformations de données monotones. La fonction principale est de stabiliser la variance, de toujours maintenir la distribution proche de la distribution normale et de rendre les données indépendantes de la moyenne de la distribution.

La transformation logarithmique a tendance à étendre la plage de valeurs de variables indépendantes qui se situent dans la plage d'amplitude inférieure et a tendance à comprimer ou à réduire la plage de valeurs de variables indépendantes dans la plage d'amplitude supérieure, rendant ainsi la distribution asymétrique aussi proche de une distribution aussi normale que possible.
Compte tenu de la variance instable de certaines caractéristiques numériques continues, nous devons utiliser le journal pour ajuster la variance de l'ensemble de la distribution des données, qui appartient à la conversion de données stables à variance.

La transformation logarithmique appartient à la famille des fonctions de transformation de puissance, et l'expression mathématique est

Ensuite, nous effectuons une transformation log1p sur le champ prix du billet dans l'ensemble de données Titanic. L'exemple de code est le suivant :

sns.distplot(df_titanic.fare,kde=False)

df_titanic['fare_log'] = np.log((1+df_titanic['fare']))
sns.distplot(df_titanic.fare_log,kde=False)

② Transformation boîte-cox . La transformation box-cox est une méthode de transformation de puissance généralisée proposée par Box et Cox en 1964. Il s'agit d'une transformation de données couramment utilisée dans la modélisation statistique et utilisée lorsque la variable de réponse continue ne satisfait pas la distribution normale. Après la transformation box-cox, l'erreur non observable et la corrélation des variables prédictives peuvent être réduites dans une certaine mesure.

La principale caractéristique de la transformation box-cox est d'introduire un paramètre, d'estimer le paramètre à travers les données elles-mêmes, puis de déterminer la forme de transformation des données à adopter.La transformation box-cox peut évidemment améliorer la normalité, la symétrie et l'égalité de la variance. Pour beaucoup, il est prouvé que les données réelles fonctionnent.

L'expression mathématique de la fonction de transformation box-cox est la suivante :

Ensuite, nous effectuons une transformation box-cox sur le champ prix du billet dans l'ensemble de données Titanic. L'exemple de code est le suivant :

# 从数据分布中移除非零值
fare_positive_value = df_titanic[(~df_titanic['fare'].isnull()) & (df_titanic['fare']>0)]['fare']
import scipy.stats as spstats
# 计算最佳λ值
l, opt_lambda = spstats.boxcox(fare_positive_value)
print('Optimal lambda value:', opt_lambda) # -0.5239075895755266
# 进行 Box-Cox 变换
fare_boxcox_lambda_opt = spstats.boxcox(df_titanic[df_titanic['fare']>0]['fare'],lmbda=opt_lambda)
sns.distplot(fare_boxcox_lambda_opt,kde=Fal

4.6 Traitement des variables discrètes

Pour les caractéristiques de champ catégorielles (telles que la couleur, le type et le degré de qualité), de nombreux modèles ne peuvent pas les gérer directement. Après les avoir codées, nous pouvons mieux présenter les informations et prendre en charge l'apprentissage du modèle. Il existe les méthodes de codage courantes suivantes pour les variables catégorielles :

Avantages : Par rapport à l'encodage OneHot, l'encodage LabelEncoder occupe moins d'espace mémoire et prend en charge l'encodage des fonctionnalités de texte.
Inconvénients : Sa méthode d'encodage apporte des relations de taille et d'ordre supplémentaires aux différentes catégories, ce qui a un impact dans certains modèles informatiques (comme la régression logistique), et elle peut être utilisée dans des modèles arborescents.

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
le.fit(["超一线", "一线", "二线", "三线"])
print('特征：{}'.format(list(le.classes_)))
# 输出 特征：['一线', '三线', '二线', '超一线']
print('转换标签值：{}'.format(le.transform(["超一线", "一线", "二线"])))
# 输出 转换标签值：array([3 0 2]...)
print('特征标签值反转：{}'.format(list(le.inverse_transform([2, 2, 1]))))
# 输出 特征标签值反转：['二线', '二线', '三线

② un encodage vectoriel à chaud (un encodage à chaud) . L'encodage à chaud est généralement utilisé pour traiter les fonctionnalités qui n'ont pas de relation de taille entre les catégories. Par exemple : fonctionnalité : groupe sanguin, il existe quatre catégories [A, B, AB, O], après un encodage à chaud, le groupe sanguin sera transformé en un vecteur clairsemé en 4 dimensions (la dimension du vecteur clairsemé final généré , et la catégorie même numéro) :

Avantages : L'encodage à chaud résout le problème selon lequel les classificateurs ne sont pas faciles à gérer les données d'attribut et joue également un rôle dans l'expansion des fonctionnalités dans une certaine mesure. Ses valeurs ne sont que 0 et 1, et les différents types sont stockés dans l'espace vertical.
Inconvénients : Il ne peut binariser que des variables numériques et ne peut pas encoder directement des variables catégorielles de type chaîne. Lorsque le nombre de catégories est grand, l’espace des fonctionnalités devient très grand. Dans ce cas, la PCA peut généralement être utilisée pour réduire la dimensionnalité. Et la combinaison d’un encodage à chaud + PCA est également très utile en pratique.

À l'aide de la bibliothèque d'outils pandas (voir le didacticiel Data Analysis Series de ShowMeAI [9] et la référence rapide des outils de science des données | Guide de l'utilisateur Pandas [10] pour plus de détails), l'exemple de référence de code Python pour le codage vectoriel à chaud est le suivant :

sex_list = ['MALE', 'FEMALE', np.NaN, 'FEMALE', 'FEMALE', np.NaN, 'MALE']
df = pd.DataFrame({'SEX': sex_list})
display(df)
df.fillna('NA', inplace=True)
df = pd.get_dummies(df['SEX'],prefix='IS_SEX')
display(df)

Les résultats avant et après la transformation finale sont les suivants :

# 原始数据
 SEX
0   MALE
1   FEMALE
2   NaN
3   FEMALE
4   FEMALE
5   NaN
6   MALE

# 独热向量编码后
 IS_SEX_FEMALE     IS_SEX_MALE    IS_SEX_NA
0    0                 1                0
1    1                 0                0
2    0                 0                1
3    1                 0                0
4    1                 0                0
5    0                 0                1

Ci-dessous, nous effectuons un codage vectoriel unique sur les champs 'sex', 'class', 'pclass', 'embarqué', 'who', 'family_size', 'age_bin'.

pd.get_dummies(df_titanic, columns=['sex', 'class', 'pclass', 'embarked', 'who', 'family_size', 'age_bin'],drop_first=True)

Bien sûr, nous pouvons également utiliser SKLearn (voir le didacticiel ShowMeAI, le guide d'application le plus complet de SKLearn et la revue rapide de l'outil de modélisation d'IA | Guide d'utilisation de Scikit-learn pour un apprentissage détaillé) pour implémenter un codage vectoriel à chaud :

import numpy as np
from sklearn.preprocessing import OneHotEncoder
# 非负整数表示的标签列表
labels = [0,1,0,2]
# 行向量转列向量
labels = np.array(labels).reshape(len(labels), -1)
# 独热向量编码
enc = OneHotEncoder()
enc.fit(labels)
targets = enc.transform(labels).toarray()
# 如果不加 toarray() 的话，输出的是稀疏的存储格式，即索引加值的形式，也可以通过参数指定 sparse = False 来达到同样的效果

Le résultat est le suivant :

array([[ 1.,  0.,  0.],
 [ 0.,  1.,  0.],
 [ 1.,  0.,  0.],
 [ 0.,  0.,  1.]])

③ Binarisation d'étiquettes (LabelBinarizer) . La fonction est la même que OneHotEncoder, mais OneHotEncoder ne peut binariser que des variables numériques et ne peut pas encoder directement des variables catégorielles de type chaîne, tandis que LabelBinarizer peut directement binariser des variables de caractères.

from sklearn.preprocessing import LabelBinarizer
lb=LabelBinarizer()
labelList=['yes', 'no', 'no', 'yes','no2']
# 将标签矩阵二值化
dummY=lb.fit_transform(labelList)
print("dummY:",dummY)
# 逆过程
yesORno=lb.inverse_transform(dummY)
print("yesOrno:",yesORno)

Le résultat est le suivant :

dummY: [[0 0 1]
 [1 0 0]
 [1 0 0]
 [0 0 1]
 [0 1 0]]
yesOrno: ['yes' 'no' 'no' 'yes' 'no2']

4.7 Réduction de dimensionnalité

Dans les projets d'apprentissage automatique réels, nous pouvons également procéder à une réduction de dimensionnalité [11], principalement parce que les données présentent les problèmes suivants :

Multicolinéarité des données : il existe une corrélation entre les attributs des caractéristiques. La multicolinéarité conduira à un espace de solutions instable, ce qui entraînera une faible capacité de généralisation du modèle.
Les échantillons spatiaux à haute latitude sont rares, ce qui rend difficile pour le modèle de trouver des caractéristiques de données.
Trop de variables peuvent empêcher le modèle de trouver des régularités.
Considérer uniquement l'influence d'une seule variable sur l'attribut cible peut ignorer la relation potentielle entre les variables.

L'objectif de la réduction de la dimensionnalité des caractéristiques est de réduire le nombre d'attributs de caractéristiques et de garantir que les attributs de caractéristiques sont indépendants les uns des autres.

Les méthodes de réduction de dimensionnalité couramment utilisées comprennent : PCA, SVD, LDA, T-sne et d'autres méthodes de réduction de dimensionnalité non linéaire.

Pour l'explication de la réduction de dimensionnalité ici, nous vous donnerons une explication basée sur l'ensemble de données de l'iris :

from sklearn import datasets

iris_data = datasets.load_iris()

X = iris_data.data
y = iris_data.target

def draw_result(X, y):
    plt.figure()
    # 提取 Iris-setosa
    setosa = X[y == 0]
    # 绘制点：参数 1 x 向量，y 向量
    plt.scatter(setosa[:, 0], setosa[:, 1], color="red", label="Iris-setosa")

    versicolor = X[y == 1]
    plt.scatter(versicolor[:, 0], versicolor[:, 1], color="orange", label="Iris-versicolor")

    virginica = X[y == 2]
    plt.scatter(virginica[:, 0], virginica[:, 1], color="blue", label="Iris-virginica")

    plt.legend()
    plt.show()

draw_result(X, y)

① PCA (Analyse en Composantes Principales) . Concernant l'algorithme de réduction de dimensionnalité de l'analyse en composantes principales PCA, vous pouvez vous référer à l'article ShowMeAI Graphical Machine Learning | Explication détaillée de l'algorithme de réduction de dimensionnalité [12] pour une étude détaillée.

import numpy as np
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
newX = pca.fit_transform(X)
draw_result(newX, y)

② SVD (décomposition en valeur singulière)

Les principales étapes de la méthode SVD sont les suivantes :

from sklearn.decomposition import TruncatedSVD
iris_2d = TruncatedSVD(2).fit_transform(X)
draw_result(iris_2d, y)

PCA contre SVD

③ LDA (Analyse Discriminante Linéaire) . Il s'agit d'une réduction de dimensionnalité supervisée, qui obtient le sous-ensemble de fonctionnalités optimal en minimisant la dispersion intra-classe et en maximisant la dispersion inter-classe.

Interprétation de la figure ci-dessus : LD1 peut séparer les deux classes avec une distribution normale par détermination linéaire. La décision linéaire de LD2 maintient une grande variance de l'ensemble de données, mais LD2 ne peut pas fournir d'informations sur les catégories, donc LD2 n'est pas une bonne décision linéaire.

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
lda = LDA(n_components=2)
iris_2d = lda.fit_transform(X, y)
draw_result(iris_2d, y)

LDA contre PCA

PCA essaie de trouver l'axe de composante principale orthogonal avec la plus grande variance LDA trouve le sous-espace de caractéristiques qui peut optimiser la classification LDA et PCA sont toutes deux des techniques de transformation linéaire qui peuvent être utilisées pour réduire la dimensionnalité de l'ensemble de données PCA est un algorithme non supervisé LDA est un algorithme supervisé. LDA est une technique supérieure d'extraction de caractéristiques pour la classification.

④T-SNE . T-SNE (t-distributed stochastic voisin embedding) est une méthode de réduction de dimensionnalité non linéaire :

from sklearn.manifold import TSNE
tsne = TSNE(n_components=2)
iris_2d = tsne.fit_transform(X)
draw_result(iris_2d, y)

5. Sélection des fonctionnalités

La sélection des fonctionnalités est un processus souvent utilisé dans le processus de modélisation, et il est également important :

Les fonctionnalités sont redondantes et certaines sont trop fortement corrélées, consommant des ressources informatiques.
Le bruit est présent et a un impact négatif sur les résultats du modèle.
Certaines fonctionnalités sont sujettes au surapprentissage.

En général, il y a deux considérations principales pour la sélection des fonctionnalités :

Degré de divergence des caractéristiques : si une caractéristique ne diverge pas, par exemple, la variance est proche de 0, ce qui signifie que les échantillons n'ont fondamentalement aucune différence dans cette caractéristique, et cette caractéristique n'est pas utile pour distinguer les échantillons.
Corrélation entre fonctionnalités et objectifs : Plus la corrélation entre fonctionnalités et objectifs est élevée, plus il convient de les conserver, ce qui est plus facile à comprendre pour tout le monde.

Les méthodes de sélection des fonctionnalités peuvent être classées dans les trois types suivants :

Filtre : Méthode de filtrage, notant chaque caractéristique en fonction de la divergence ou de la corrélation, fixant un seuil ou le nombre de seuils à sélectionner pour sélectionner les caractéristiques.
Wrapper : Méthode Wrapper, selon la fonction objectif (généralement le score d'effet de prédiction), sélectionner plusieurs fonctionnalités ou exclure plusieurs fonctionnalités à chaque fois.
Embedded : méthode intégrée, utilisez d'abord des algorithmes et des modèles d'apprentissage automatique pour la formation, obtenez le coefficient de poids de chaque fonctionnalité et sélectionnez les fonctionnalités en fonction du coefficient de grand à petit. Semblable à la méthode Filter, mais via une formation pour déterminer les avantages et les inconvénients des fonctionnalités. Nous utilisons la bibliothèque de SKLearn feature_selection pour la sélection des fonctionnalités.

5.1 Filtre Filtre

① Filtrage des écarts . Il s'agit de la classe permettant de filtrer les entités en fonction de la variance des entités elles-mêmes. Par exemple, si la variance d'une caractéristique elle-même est faible, cela signifie que les échantillons n'ont pratiquement aucune différence dans cette caractéristique. Peut-être que la plupart des valeurs de la caractéristique sont les mêmes, ou même les valeurs de l'ensemble de la caractéristique. sont identiques, cette fonctionnalité n'a aucun effet sur la distinction des échantillons.

Nous éliminerons les caractéristiques du champ avec une très petite variance. Le code de référence est implémenté comme suit :

from sklearn.feature_selection import VarianceThreshold
variancethreshold = VarianceThreshold() #实例化，默认方差为 0.方差<=0 的过滤掉
df_titanic_numerical = df_titanic[['age','sibsp','parch','fare','family_size']]
X_var = variancethreshold.fit_transform(df_titanic_numerical)    #获取删除不合格特征后的新特征矩阵
del_list = df_titanic_numerical.columns[variancethreshold.get_support()==0].to_list()  #获得删除

② Filtrage chi carré . Le test du Chi carré, dédié aux algorithmes de classification, capture la corrélation et recherche les caractéristiques avec p inférieur au niveau de signification. Le filtrage chi carré est un filtrage de corrélation spécifiquement destiné aux étiquettes discrètes (c'est-à-dire les problèmes de classification).

df_titanic_categorical = df_titanic[['sex', 'class', 'embarked', 'who',  'age_bin','adult_male','alone','fare_bin']]
df_titanic_numerical = df_titanic[['age','sibsp','parch','fare','family_size','pclass']]
df_titanic_categorical_one_hot = pd.get_dummies(df_titanic_categorical, columns=['sex', 'class', 'embarked', 'who',  'age_bin','adult_male','alone','fare_bin'], drop_first=True)
df_titanic_combined = pd.concat([df_titanic_numerical,df_titanic_categorical_one_hot],axis=1)

y = df_titanic['survived']
X = df_titanic_combined.iloc[:,1:]

from sklearn.feature_selection import chi2
from sklearn.feature_selection import SelectKBest
chi_value, p_value = chi2(X,y)
#根据 p 值，得出 k 值
k = chi_value.shape[0] - (p_value > 0.05).sum()  #要保留的特征的数量 14
#根据卡方值，选择前几特征,筛选后特征
X_chi = SelectKBest(chi2, k=14).fit_transform(X, y)

③Test F. Le test capture la corrélation linéaire, exige que les données obéissent à la distribution normale et recherche la caractéristique selon laquelle la valeur P est inférieure au niveau de signification.

from sklearn.feature_selection import f_classif
f_value, p_value = f_classif(X,y)
#根据 p 值，得出 k 值
k = f_value.shape[0] - (p_value > 0.05).sum()
#筛选后特征
X_classif = SelectKBest(f_classif, k=14).fit_transform(X, y)

④ Méthode d'information mutuelle . La méthode d'information mutuelle est une méthode de filtrage utilisée pour capturer toute relation (y compris les relations linéaires et non linéaires) entre chaque entité et étiquette.

from sklearn.feature_selection import mutual_info_classif as MIC
#互信息法
mic_result = MIC(X,y)   #互信息量估计
k = mic_result.shape[0] - sum(mic_result <= 0)    #16
X_mic = SelectKBest(MIC, k=16).fit_transform(X, y)

5.2 Emballage emballé

① Méthode normalisée de suppression des caractéristiques . La méthode récursive d'élimination et de suppression utilise un modèle de base pour plusieurs cycles d'entraînement. Après chaque cycle d'entraînement, les caractéristiques de plusieurs coefficients de poids sont éliminées, puis le cycle d'entraînement suivant est effectué sur la base du nouvel ensemble de fonctionnalités. feature_selection Le code pour sélectionner les fonctionnalités à l'aide de la classe RFE de la bibliothèque est le suivant :

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
#递归特征消除法，返回特征选择后的数据
#参数 estimator 为基模型
#参数 n_features_to_select 为选择的特征个数
X_ref = RFE(estimator=LogisticRegression(), n_features_to_select=10).fit_transform(X, y)

② Évaluation de l'importance des fonctionnalités . Nous pouvons obtenir l'importance des fonctionnalités en fonction de certains modèles (tels que divers modèles d'arbres), puis effectuer un filtrage

from sklearn.ensemble import ExtraTreesClassifier
# 建模与获取特征重要度
model = ExtraTreesClassifier()
model.fit(X, y)
print(model.feature_importances_)

# 特征重要度排序
feature=list(zip(X.columns,model.feature_importances_))
feature=pd.DataFrame(feature,columns=['feature','importances'])
feature.sort_values(by='importances',ascending=False).head(20)

③ Organiser l'évaluation de l'importance . Nous disposons également d’une classe de méthodes capables d’évaluer l’importance des caractéristiques, puis d’effectuer un filtrage, appelé importance de permutation.

Justification : l'importance de la permutation est calculée après la formation d'un modèle d'apprentissage automatique. Cette approche pose une hypothèse au modèle, à savoir dans quelle mesure cela affecterait la précision d'un modèle d'apprentissage automatique prédictif en cas de mélange aléatoire d'une colonne de données de fonctionnalités d'ensemble de validation tout en préservant la cible et toutes les autres colonnes. Pour une fonctionnalité de grande importance, le remaniement aléatoire peut nuire davantage à la précision des prédictions du modèle d'apprentissage automatique.

Avantages : calcul rapide ; facile à utiliser et à comprendre ; propriétés de mesure de l'importance des caractéristiques ; recherche de la stabilité des caractéristiques.

Le code de référence est implémenté comme suit :

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import eli5
from eli5.sklearn import PermutationImportance
my_model = RandomForestClassifier(random_state=0).fit(train_X, train_y)
perm = PermutationImportance(my_model, random_state=1).fit(val_X, val_y)
eli5.show_weights(perm, feature_names = val_X.columns.tolist())

5.3 Intégré Intégré

① Méthode de sélection des fonctionnalités basée sur les éléments de pénalité . En utilisant le modèle de base avec des éléments de pénalité, en plus du filtrage des caractéristiques, une réduction de dimensionnalité est également effectuée.

Le code de sélection de fonctionnalités à l'aide de classes feature_selectionde bibliothèque SelectFromModelcombinées à un modèle de régression logistique avec une pénalité L1 est le suivant :

from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression
#带 L1 和 L2 惩罚项的逻辑回归作为基模型的特征选择,这个设置带 L1 惩罚项的逻辑回归作为基模型的特征选择
lr = LogisticRegression(solver='liblinear',penalty="l1", C=0.1)
X_sfm = SelectFromModel(lr).fit_transform(X, y)
X_sfm.shape
(891, 7

Le code permettant de sélectionner des fonctionnalités à l'aide de la classe SelectFromModel de la bibliothèque feature_selection combinée avec le modèle SVM est le suivant :

from sklearn.feature_selection import SelectFromModel
from sklearn.svm import LinearSVC
lsvc = LinearSVC(C=0.01,penalty='l1',dual=False).fit(X, y)
model = SelectFromModel(lsvc,prefit=True)
X_sfm_svm = model.transform(X)
X_sfm_svm.shape
(891, 7

② Basé sur le modèle arborescent . GBDT dans le modèle arborescent peut également être utilisé comme modèle de base pour la sélection de fonctionnalités. En utilisant la classe SelectFromModel de la bibliothèque feature_selection combinée avec le modèle GBDT, le code pour sélectionner les fonctionnalités est le suivant :

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import GradientBoostingClassifier
#GBDT 作为基模型的特征选择
gbdt = GradientBoostingClassifier()
X_sfm_gbdt = SelectFromModel(gbdt).fit_transform(X, y)

5.4 Résumé de la sélection des fonctionnalités

Concernant la sélection des fonctionnalités, faites un résumé de votre expérience, comme suit :

Pour les variables de caractéristiques catégorielles, vous pouvez commencer par SelectKBest et utiliser des sélecteurs chi carré ou arborescents pour sélectionner les variables ;
Variables de caractéristiques quantitatives, vous pouvez utiliser directement des modèles linéaires et des sélecteurs basés sur la corrélation pour sélectionner des variables ;
Pour les problèmes de classification binaire, vous pouvez envisager d'utiliser SelectFromModel et SVC ;
Avant la sélection des fonctionnalités, pour bien comprendre les données, il est généralement nécessaire de procéder à une analyse exploratoire des données EDA.

6. Suggestions pratiques pour l'ingénierie des fonctionnalités

Enfin, ShowMeAI combine une expérience pratique des applications industrielles pour résumer quelques points clés de l'ingénierie des fonctionnalités :

6.1 Compréhension des données

L'efficacité de la construction de fonctionnalités est fortement liée à l'activité et à la distribution des données. Il est donc recommandé d'effectuer une analyse exploratoire des données EDA avant cette étape pour bien comprendre les données.

Vous pouvez vous référer à l'article ShowMeAI Projet complet d'apprentissage automatique Python - Prévisions des ventes de commerce électronique [13] et Projet complet d'apprentissage automatique Python - Prévisions des ventes de commerce électronique <Avancé> [14] pour comprendre le processus et la méthode de base de l'EDA.

6.2 Prétraitement des données

Certains prétraitements de données et traitements de fonctionnalités que nous pouvons effectuer sont les suivants :

① Discrétisation des fonctionnalités continues

L'essence est de limiter la précision des caractéristiques à virgule flottante.Les données anormales ont une forte robustesse et le modèle sera plus stable.
Les modèles d'arbres n'ont pas besoin de le faire

② Troncature numérique

Limiter la valeur de la fonctionnalité à une certaine plage (utile pour la suppression des exceptions)
Vous pouvez utiliser .clip(low,upper) la méthode pandas dataframe

6.3 Nettoyage des données

En combinaison avec des scénarios commerciaux et la distribution des données, un traitement raisonnable des valeurs manquantes et des valeurs aberrantes est effectué.

6.4 Construction et transformation des fonctionnalités

Il est recommandé de ne pas effectuer de PCA ou LDA pour la réduction de dimensionnalité. Il est préférable de construire des fonctionnalités et de les filtrer.

① Combinaison linéaire (combinaison linéaire)

Convient aux arbres de décision et aux ensembles basés sur des arbres de décision (tels que l'augmentation de gradient, la forêt aléatoire), car la fonction de division alignée sur l'axe commun n'est pas efficace pour capturer la corrélation entre différentes caractéristiques ;
Ne convient pas au SVM, à la régression linéaire, aux réseaux de neurones, etc.

② Combinaison de caractéristiques catégorielles et de caractéristiques numériques

Utilisez N1 et N2 pour représenter des caractéristiques numériques, utilisez C1 et C2 pour représenter des caractéristiques catégorielles et utilisez l'opération groupby de pandas pour créer les nouvelles fonctionnalités significatives suivantes : (parmi elles, C2 peut également être un N1 discrétisé)

median(N1)_by(C1)   中位数
mean(N1)_by(C1)   算术平均数
mode(N1)_by(C1)   众数
min(N1)_by(C1)   最小值
max(N1)_by(C1)   最大值
std(N1)_by(C1)   标准差
var(N1)_by(C1)   方差
freq(C2)_by(C1)   频数

③ Caractéristiques statistiques + combinaison linéaire

Les fonctionnalités statistiques peuvent être combinées avec des méthodes d'ingénierie de fonctionnalités de base telles que la combinaison linéaire (uniquement pour les arbres de décision), et des fonctionnalités plus significatives peuvent être obtenues, telles que :

N1 - median(N1)_by(C1)
N1 - mean(N1)_by(C1)

④ Créer de nouvelles fonctionnalités basées sur le modèle arborescent

Dans la série d'algorithmes d'arbre de décision (tels que l'arbre de décision, gbdt, forêt aléatoire, pour plus de détails, veuillez vous référer à l'algorithme d'apprentissage automatique graphique du didacticiel ShowMeAI : de la mise en route à la maîtrise des didacticiels de la série pour un apprentissage et une compréhension détaillés), chaque échantillon sera mappé aux feuilles de l’arbre de décision.

Nous pouvons ajouter l'index (entier naturel) ou le vecteur de codage à chaud (vecteur clairsemé obtenu par codage factice) de l'échantillon après chaque mappage d'arbre de décision en tant que nouvelle fonctionnalité du modèle.

Dans Scikit-Learn et XGBoost, il peut être implémenté sur la base apply() d' decision_path() autres méthodes.

6.5 Modèle

Dans différents types de modèles, nous considérons également différentes méthodes d'ingénierie de fonctionnalités :

① modèle d'arbre

Il n'est pas sensible à l'ampleur de la valeur caractéristique et il n'est pas nécessaire qu'il soit sans dimension et transformé statistiquement ;
Les caractéristiques du modèle numérique sont apprises en fonction de la distance de l'échantillon, et le codage des caractéristiques de catégorie peut ne pas être effectué (mais les caractéristiques de type caractère ne peuvent pas être directement utilisées comme entrée, donc au moins un codage d'étiquette est requis).
LightGBM et XGBoost peuvent tous deux apprendre les valeurs manquantes dans le cadre des données, il n'est donc pas nécessaire de gérer les valeurs manquantes. D'autres cas doivent combler les manquants.

② Modèle dépendant de la distance de l'échantillon

Tels que la régression linéaire, le SVM, l'apprentissage profond, etc. entrent dans cette catégorie.
Pour les caractéristiques numériques, un traitement sans dimension est requis.
Pour certaines caractéristiques des données de la distribution à longue traîne, une transformation statistique peut être effectuée pour mieux optimiser le modèle.
Pour les modèles linéaires, le regroupement de fonctionnalités peut améliorer l’expressivité du modèle.

Un aperçu du processus de modélisation de l'apprentissage automatique (code Python)

Avec l'avènement de l'ère de l'intelligence artificielle, l'apprentissage automatique est devenu un outil clé pour résoudre des problèmes, tels que l'identification si une transaction est frauduleuse, la prévision des précipitations, la catégorisation des actualités et la recommandation de produits marketing. Nous décrivons ensuite en détail comment l’apprentissage automatique est appliqué à des problèmes pratiques et décrivons le flux général des applications d’apprentissage automatique.

1.1 Définir le problème

Clarifier le problème commercial est une condition préalable à l'apprentissage automatique, c'est-à-dire résumer le problème en tant que problème de prédiction de l'apprentissage automatique : quel type de données doit être appris en entrée et quel type de modèle pour prendre des décisions car l'objectif est d'obtenir comme sortie.

Un scénario simple de classification des actualités consiste à apprendre les actualités existantes et leurs données d'étiquette de catégorie, à obtenir un modèle de classification de texte et à utiliser le modèle pour prédire la catégorie des nouvelles actualités chaque jour, afin de les classer dans chaque chaîne d'information.

1.2 Sélection des données

Il existe un dicton largement répandu dans le domaine de l'apprentissage automatique : "Les données et les fonctionnalités déterminent la limite supérieure des résultats de l'apprentissage automatique, et l'algorithme du modèle n'est qu'aussi proche que possible de cette limite supérieure", ce qui signifie que la qualité des données et leur représentation des caractéristiques détermine l'effet final du modèle, et dans les applications industrielles réelles, les algorithmes occupent généralement une très petite partie, et la majeure partie du travail consiste à trouver des données, à affiner les données, à analyser les données et à l'ingénierie des fonctionnalités.

La sélection des données est la clé de la préparation des matières premières pour l'apprentissage automatique. Il convient de prêter attention à : ① la représentativité des données : une qualité de données médiocre ou non représentative entraînera un mauvais ajustement du modèle ; ② la plage temporelle des données : pour les variables caractéristiques X et Si l'étiquette Y est liée au temps, il est nécessaire de délimiter la fenêtre temporelle des données, sinon cela peut conduire à une fuite de données, c'est-à-dire au phénomène d'existence et d'utilisation de variables caractéristiques à causalité inversée. (par exemple, prédire s'il pleuvra demain, mais les données d'entraînement incluent la température et l'humidité de demain) ; ③ Portée de l'activité des données : clarifier la portée du tableau de données lié à la tâche et éviter de manquer des données représentatives ou d'introduire une grande quantité de données non pertinentes données sous forme de bruit.

2 Ingénierie des fonctionnalités

L'ingénierie des fonctionnalités consiste à transformer l'analyse et le traitement des données brutes en fonctionnalités disponibles pour le modèle. Ces fonctionnalités peuvent mieux décrire les lois sous-jacentes au modèle prédictif, améliorant ainsi la précision du modèle pour les données invisibles. Techniquement, l'ingénierie des fonctionnalités peut être divisée en les étapes suivantes : ① Analyse exploratoire des données : distribution des données, données manquantes, anomalies et corrélations, etc. ; ② Prétraitement des données : traitement des valeurs manquantes/valeurs aberrantes, discrétisation des données, standardisation des données, etc. ; ③ Extraction de caractéristiques : représentation de caractéristiques, dérivation de caractéristiques, sélection de caractéristiques, réduction de dimensionnalité de caractéristiques, etc. ;

2.1 Analyse exploratoire des données

Après avoir obtenu les données, vous pouvez d'abord effectuer une analyse exploratoire des données (EDA) pour comprendre la structure interne et les lois des données elles-mêmes. Si vous ne comprenez pas les données et n'avez aucune connaissance commerciale pertinente, vous pouvez directement alimenter les données vers les méthodes traditionnelles. les modèles ne fonctionnent souvent pas très bien. Grâce à l'analyse exploratoire des données, il est possible de comprendre la distribution des données, les données manquantes, les anomalies et les corrélations. L'utilisation de ces informations de base pour le traitement des données et le traitement des caractéristiques peut encore améliorer la qualité des caractéristiques et sélectionner de manière flexible les méthodes de modèle appropriées.

2.2 Prétraitement des données

Traitement des valeurs aberrantes

Les données collectées peuvent introduire des valeurs aberrantes (bruit) dues à des facteurs humains ou naturels, qui interféreront avec l'apprentissage du modèle. Il est généralement nécessaire de traiter les valeurs anormales d'origine humaine, de déterminer les valeurs anormales par des moyens commerciaux ou techniques (tels que le critère 3σ), puis de filtrer les informations anormales au moyen de (correspondance d'expression régulière) et de supprimer ou de remplacer les valeurs en fonction de la situation de l'entreprise.

Gestion des valeurs manquantes

Les valeurs manquantes des données peuvent être complétées, non traitées ou supprimées en regroupant les entreprises. Selon le taux de fonctionnalités manquantes et la méthode de traitement, il est divisé dans les situations suivantes : ① Le taux de fonctionnalités manquantes est élevé et la variable de fonctionnalité peut être directement supprimée en combinaison avec l'entreprise. L'expérience peut ajouter une fonctionnalité variable de type booléen pour enregistrer l'absence du champ, les manquants sont enregistrés comme 1 et les non-manquants sont enregistrés comme 0 ; ② Le taux de manquants est faible et certaines méthodes de remplissage des valeurs manquantes peuvent être utilisées. en collaboration avec l'entreprise, comme la méthode fillna de pandas , Former le modèle de régression pour prédire les valeurs manquantes et les remplir ; ③ Aucun traitement : certains modèles tels que random forest, xgboost et lightgbm peuvent gérer les données manquantes, et n'ont pas besoin de traiter les données manquantes.

discrétisation des données

La discrétisation consiste à segmenter des données continues en intervalles discrets. Les principes de segmentation incluent des méthodes telles que l'égalité de largeur et l'égalité de fréquence. La discrétisation peut généralement augmenter la capacité anti-bruit, rendre les fonctionnalités plus interprétables par l'entreprise et réduire la surcharge temporelle et spatiale de l'algorithme (les différents algorithmes varient).

normalisation des données

La dimension de chaque variable caractéristique des données est très différente et l'influence de la différence de dimension des différents composants peut être éliminée en utilisant la standardisation des données pour accélérer l'efficacité de la convergence des modèles. Les méthodes couramment utilisées sont : ① Standardisation min-max : la plage de valeurs peut être mise à l'échelle jusqu'à (0, 1) sans modifier la distribution des données. max est la valeur maximale de l'échantillon et min est la valeur minimale de l'échantillon.

② Standardisation du score z : la plage de valeurs peut être mise à l'échelle jusqu'à près de 0 et les données traitées sont conformes à la distribution normale standard. est la moyenne et σ est l'écart type.

2.3 Extraction de fonctionnalités

Représentation des caractéristiques

Les données doivent être converties sous une forme numérique pouvant être traitée par l'ordinateur, et les données d'image doivent être converties en représentation d'une matrice tridimensionnelle RVB.

Les données de caractères peuvent être représentées par des tableaux multidimensionnels, tels que le codage Onehot one-hot (représenté par une seule position de 1), la représentation distribuée word2vetor, etc. ;

Dérivation des fonctionnalités

Les fonctionnalités de base ont une expression limitée des informations sur l'échantillon, et la dérivation de fonctionnalités peut augmenter la capacité d'expression non linéaire des fonctionnalités et améliorer l'effet du modèle. De plus, comprendre les caractéristiques de conception de l’entreprise peut également augmenter l’interprétabilité du modèle. (Par exemple, diviser le poids par la taille est une caractéristique importante pour exprimer l'état de santé.) La dérivation de caractéristiques consiste à effectuer un certain traitement (agrégation/conversion, etc.) sur la signification des caractéristiques de base existantes. Les méthodes courantes sont la conception manuelle et la dérivation automatique de caractéristiques. (Figure 4.15) : ① Combiné avec la compréhension de l'entreprise pour faire la conception de dérivés artificiels : le mode d'agrégation fait référence au calcul de la valeur moyenne, du nombre, de la valeur maximale, etc. Par exemple, le salaire sur 12 mois peut être traité : le salaire mensuel moyen, le salaire maximum, etc. ; la méthode de conversion fait référence à l'addition, la soustraction, la multiplication et la division entre champs. Par exemple, à travers 12 mois de salaire, on peut traiter : le rapport et la différence entre les revenus salariaux et les dépenses du mois en cours, etc. ;

② Utilisez des outils dérivés de fonctionnalités automatisés : tels que Featuretools, etc., vous pouvez utiliser l'agrégation (agg_primitives), la conversion (trans_primitives) ou des méthodes personnalisées pour générer violemment des fonctionnalités ;

sélection de fonctionnalité

L'objectif de la sélection des fonctionnalités est de trouver le sous-ensemble de fonctionnalités optimal, de réduire le risque de surajustement du modèle et d'améliorer l'efficacité opérationnelle en éliminant les fonctionnalités importantes et en supprimant les fonctionnalités redondantes. Les méthodes de sélection de fonctionnalités sont généralement divisées en trois catégories : ① Méthode de filtrage : calculez le manque de fonctionnalités, la divergence, la corrélation, le volume d'informations, la stabilité et d'autres types d'indicateurs pour évaluer et sélectionner chaque fonctionnalité, couramment utilisées telles que le taux manquant, le taux à valeur unique. , Vérification de la variance, coefficient de corrélation de Pearson, test du chi carré chi2, valeur IV, gain d'information et PSI et autres méthodes. ② Méthode d'empaquetage : entraîne le modèle de manière itérative en sélectionnant une partie des fonctionnalités à chaque fois et sélectionne la sélection de fonctionnalités en fonction du score d'effet de prédiction du modèle, comme l'élimination récursive des fonctionnalités RFE de sklearn. ③ Méthode d'intégration : utilisez directement une formation de modèle pour comprendre l'importance des fonctionnalités et effectuez la sélection des fonctionnalités pendant la formation du modèle. Le coefficient de pondération de chaque caractéristique est obtenu via le modèle et la caractéristique est sélectionnée en fonction du coefficient de pondération, de grand à petit. Couramment utilisé, comme la régression logistique basée sur le terme régulier L1, la fonction de sélection de l'importance des fonctionnalités XGBOOST.

réduction de la dimensionnalité des fonctionnalités

Si le nombre de caractéristiques après la sélection des caractéristiques est encore trop grand, dans ce cas, il y aura souvent des problèmes avec des échantillons de données clairsemés et des calculs de distance difficiles (appelés « malédiction de la dimensionnalité »), qui peuvent être résolus par la réduction de la dimensionnalité des caractéristiques. Les méthodes de réduction de dimensionnalité couramment utilisées sont : l’analyse en composantes principales (ACP), etc.

3 Formation sur modèle

La formation de modèles est le processus consistant à utiliser des méthodes de modèle établies pour apprendre l'expérience des données. Ce processus doit également être combiné avec l'évaluation du modèle pour ajuster les hyperparamètres de l'algorithme et enfin sélectionner un modèle avec de meilleures performances.

3.1 Division des ensembles de données

Avant de former le modèle, la méthode de vérification HoldOut couramment utilisée (en plus de la méthode Leave-One-Out, de la validation croisée k-fold et d'autres méthodes) divise l'ensemble de données en ensemble d'apprentissage et en ensemble de test, et l'ensemble d'entraînement peut être approfondi. subdivisé en ensemble de formation et ensemble de vérification pour faciliter l’évaluation des performances du modèle. ① Ensemble de formation (ensemble de formation) : utilisé pour exécuter l'algorithme d'apprentissage et entraîner le modèle. ② L'ensemble de développement (ensemble de développement) est utilisé pour ajuster les hyperparamètres, sélectionner les fonctionnalités, etc., afin de sélectionner un modèle approprié. ③ L'ensemble de test (ensemble de test) est uniquement utilisé pour évaluer les performances du modèle sélectionné, mais ne modifiera pas l'algorithme d'apprentissage ou les paramètres en conséquence. ###3.2 Sélection de la méthode du modèle Sélectionnez la méthode du modèle appropriée en fonction de la tâche actuelle et des conditions des données. Les méthodes couramment utilisées sont présentées dans la figure ci-dessous, la sélection de la méthode du modèle scikit-learn. De plus, plusieurs modèles peuvent être combinés pour la fusion de modèles.

3.3 Processus de formation

Le processus de formation du modèle consiste à apprendre l'expérience des données pour obtenir un meilleur modèle et les paramètres correspondants (par exemple, le réseau neuronal apprend enfin une meilleure valeur de poids). L'ensemble du processus de formation doit également être contrôlé et optimisé en ajustant les hyperparamètres (tels que le nombre de couches de réseau neuronal et le taux d'apprentissage de la descente de gradient). L'ajustement des hyperparamètres est un processus empirique basé sur des ensembles de données, des modèles et des détails du processus de formation. Il doit être basé sur la compréhension des principes de l'algorithme et de l'expérience, à l'aide de l'évaluation du modèle dans l'ensemble de validation pour le réglage des paramètres. De plus, il existe une technologie de réglage automatique des paramètres : recherche par grille, recherche aléatoire, optimisation bayésienne, etc.

4 Évaluation du modèle

Le but direct de l'apprentissage automatique est d'apprendre (d'adapter) un « bon » modèle, non seulement d'avoir une bonne capacité d'apprentissage et de prédiction pour les données d'entraînement dans le processus d'apprentissage, mais aussi d'avoir une bonne capacité de prédiction pour les nouvelles données (capacité générale ), il est donc crucial d’évaluer objectivement les performances du modèle. Techniquement, les performances du modèle sont souvent évaluées sur la base des performances d'indice de l'ensemble d'entraînement et de l'ensemble de test.

4.1 Indicateurs d'évaluation

Évaluer les modèles de classification

Les critères d'évaluation couramment utilisés incluent le taux de précision P, le taux de rappel R et le score F1 moyen harmonique des deux, etc., et la valeur est calculée à partir du nombre correspondant de statistiques de la matrice de confusion :

Le taux de précision fait référence au rapport entre le nombre d'échantillons positifs (TP) correctement classés par le classificateur et le nombre d'échantillons positifs (TP+FP) prédits par le classificateur ; le taux de rappel fait référence au nombre d'échantillons positifs correctement classés par Le classificateur. Le nombre (TP) représente la proportion de tous les échantillons positifs (TP+FN). Le score F1 est la moyenne harmonique de la précision P et du rappel R :

Évaluer les modèles de régression

Les indicateurs d'évaluation couramment utilisés sont l'erreur quadratique moyenne MSE, etc. La rétroaction est l’adéquation entre la valeur prédite et la valeur réelle.

Évaluer le modèle de clustering

Il peut être divisé en deux catégories, l'une consiste à comparer les résultats du clustering avec les résultats d'un « modèle de référence », appelé « indice externe » (index externe) : tel que l'indice Rand, l'indice FM, etc. L'autre consiste à inspecter directement les résultats du clustering sans utiliser de modèle de référence, appelé « index interne » (index interne) : comme la compacité, la séparation, etc.

4.2 Évaluation et optimisation du modèle

L'ensemble d'échantillons de données utilisé pour entraîner le modèle d'apprentissage automatique est appelé ensemble d'apprentissage, l'erreur sur les données d'entraînement est appelée erreur d'entraînement et l'erreur sur les données de test est appelée erreur de test. ) ou erreur de généralisation.

Pour décrire le degré d'ajustement du modèle (apprentissage), le sous-ajustement, le bon ajustement et le surajustement sont couramment utilisés.Nous pouvons évaluer le degré d'ajustement du modèle par l'erreur de formation et l'erreur de test. Du point de vue du processus de formation global, l'erreur de formation et l'erreur de test sont élevées en cas de sous-ajustement et diminuent avec l'augmentation du temps de formation et de la complexité du modèle. Après avoir atteint un point critique d'ajustement optimal, l'erreur d'entraînement diminue et l'erreur de test augmente, et à ce moment-là, elle entre dans la région de surajustement.

Le sous-ajustement signifie que la structure du modèle est trop simple par rapport aux données, de sorte que les lois contenues dans les données ne peuvent pas être apprises. Le surajustement signifie que le modèle ne fait que trop correspondre à l'ensemble de données d'entraînement, de sorte qu'il ne s'adapte pas et ne prédit pas correctement les nouvelles données. Son essence est causée par le bruit statistique appris par le modèle plus complexe à partir des données d'entraînement. Pour analyser l'effet d'ajustement du modèle et optimiser le modèle, les méthodes couramment utilisées sont :

5 Modèle de décision

L'application décisionnelle est l'objectif ultime de l'apprentissage automatique. Elle analyse et interprète les informations de prédiction du modèle et les applique au champ de travail réel. Il convient de noter que l'ingénierie est orientée vers les résultats et que l'effet de l'exécution du modèle en ligne détermine directement le succès ou l'échec du modèle, y compris non seulement sa précision, ses erreurs, etc., mais également sa vitesse d'exécution (complexité temporelle). consommation de ressources (complexité spatiale), prise en compte globale de la stabilité.

6 Combat de projet d'apprentissage automatique (exploration de données)

6.1 Présentation du projet

Les données expérimentales du projet proviennent de la célèbre base de données d'apprentissage automatique UCI, qui contient une grande quantité de données d'exploration de données d'intelligence artificielle. Cet exemple utilise la version de l'ensemble de données sur sklearn : Breast Cancer Wisconsin DataSet (ensemble de données sur le cancer du sein du Wisconsin), ces données proviennent des rapports de cas cliniques de l'hôpital de l'Université du Wisconsin aux États-Unis. Oncologie, le problème de la classification supervisée prédiction. L'idée de modélisation du projet est d'analyser les données de l'ensemble de données sur le cancer du sein, d'ingénierie des fonctionnalités, de construire un modèle de régression logistique pour apprendre les données et de prédire si la catégorie de l'échantillon est une tumeur bénigne.

6.2 Mise en œuvre du code

Importez la bibliothèque Python appropriée, chargez l'ensemble de données sur le cancer, affichez l'introduction des données et convertissez-le au format DataFrame.

import numpy as np  
import pandas as pd
import matplotlib.pyplot as plt

from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.utils import plot_model
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_score, recall_score, f1_score

dataset_cancer = datasets.load_breast_cancer()    # 加载癌细胞数据集

print(dataset_cancer['DESCR'])

df = pd.DataFrame(dataset_cancer.data, columns=dataset_cancer.feature_names)  

df['label'] = dataset_cancer.target

print(df.shape)

df.head()

Analyse exploratoire des données EDA : utilisez la bibliothèque pandas_profiling pour analyser la valeur des données, le taux manquant et la corrélation, etc.

import pandas_profiling

pandas_profiling.ProfileReport(df, title='Breast Cancer DataSet EDA')

Les principales analyses et traitements de l’ingénierie des fonctionnalités sont :

● Il n'y a pas de situation aberrante ou manquante évidente dans la fonction d'analyse, il n'est pas nécessaire de s'en occuper ;

● Des caractéristiques dérivées telles que l'erreur moyenne/standard existent, pas besoin de dérivation de caractéristiques ;

● Combinaison avec la corrélation et d'autres indicateurs pour la sélection des fonctionnalités (méthode de filtrage) ;

● Normaliser les fonctionnalités pour accélérer le processus d'apprentissage du modèle ;

# 筛选相关性>0.99的特征清单列表及标签
drop_feas = ['label','worst_radius','mean_radius']

# 选择标签y及特征x
y = df.label
x = df.drop(drop_feas,axis=1)  # 删除相关性强特征及标签列

# holdout验证法： 按3：7划分测试集 训练集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)

# 特征z-score 标准化
sc = StandardScaler()

x_train = sc.fit_transform(x_train)  # 注：训练集测试集要分别标准化，以免测试集信息泄露到模型训练
x_test = sc.transform(x_test)

Formation de modèle : utilisez Keras pour créer un modèle de régression logistique, entraîner le modèle et observer la perte de l'ensemble de formation du modèle et de l'ensemble de vérification.

_dim = x_train.shape[1]   # 输入模型的特征数

# LR逻辑回归模型
model = Sequential()   

model.add(Dense(1, input_dim=_dim, activation='sigmoid',bias_initializer='uniform'))  # 添加网络层，激活函数sigmoid

model.summary()

plot_model(model,show_shapes=True)

model.compile(optimizer='adam', loss='binary_crossentropy')  #模型编译：选择交叉熵损失函数及adam梯度下降法优化算法

model.fit(x, y, validation_split=0.3, epochs=200)   # 模型迭代训练: validation_split比例0.3, 迭代epochs200次

# 模型训练集及验证集的损失

plt.figure()

plt.plot(model.history.history['loss'],'b',label='Training loss')

plt.plot(model.history.history['val_loss'],'r',label='Validation val_loss')

plt.title('Traing and Validation loss')

plt.legend()

La capacité de généralisation du modèle est évaluée par les performances de l'ensemble de tests F1-score et d'autres indicateurs. Le score f1 de l'ensemble de tests final est de 88 %, ce qui présente de bonnes performances du modèle.

def model_metrics(model, x, y):
    """

    评估指标

    """
    yhat = model.predict(x).round()  # 模型预测yhat，预测阈值按默认0.5划分

    result = {
              'f1_score': f1_score(y, yhat),

              'precision':precision_score(y, yhat),

              'recall':recall_score(y, yhat)
             }

    return result

# 模型评估结果

print("TRAIN")

print(model_metrics(model, x_train, y_train))

print("TEST")

print(model_metrics(model, x_test, y_test))

Cas d'application pratique d'algorithme Cours intensif - Ingénierie des fonctionnalités | Apprentissage automatique graphique

avant-propos

Introduction à l'ingénierie des fonctionnalités

Projet de combat Titanic

1. Type de fonctionnalité

2. Nettoyage des données

2.1 Alignement des données

2.2 Traitement des valeurs manquantes

(1) Suppression et traitement des valeurs manquantes

(2) Remplissage des données et traitement des valeurs manquantes

2.3 Traitement des valeurs aberrantes

(1) Méthode de détection des anomalies

(2) Méthode de gestion des exceptions

3. Construction des fonctionnalités

3.1 Construction des caractéristiques statistiques

3.2 Valeur de la période

3.3 Regroupement des données

3.4 Combinaison de fonctionnalités

4. Transformation des fonctionnalités

4.1 Normalisation

4.2 Normalisation

4.3 Mise à l'échelle de l'amplitude (mise à l'échelle)

4.4 Normalisation vs normalisation

4.5 Transformation non linéaire

4.6 Traitement des variables discrètes

4.7 Réduction de dimensionnalité

5. Sélection des fonctionnalités

5.1 Filtre Filtre

5.2 Emballage emballé

5.3 Intégré Intégré

5.4 Résumé de la sélection des fonctionnalités

6. Suggestions pratiques pour l'ingénierie des fonctionnalités

6.1 Compréhension des données

6.2 Prétraitement des données

6.3 Nettoyage des données

6.4 Construction et transformation des fonctionnalités

6.5 Modèle

Un aperçu du processus de modélisation de l'apprentissage automatique (code Python)

1.1 Définir le problème

1.2 Sélection des données

2 Ingénierie des fonctionnalités

2.1 Analyse exploratoire des données

2.2 Prétraitement des données

Traitement des valeurs aberrantes

Gestion des valeurs manquantes

discrétisation des données

normalisation des données

2.3 Extraction de fonctionnalités

Représentation des caractéristiques

Dérivation des fonctionnalités

sélection de fonctionnalité

réduction de la dimensionnalité des fonctionnalités

3 Formation sur modèle

3.1 Division des ensembles de données

3.3 Processus de formation

4 Évaluation du modèle

4.1 Indicateurs d'évaluation

Évaluer les modèles de classification

Évaluer les modèles de régression

Évaluer le modèle de clustering

4.2 Évaluation et optimisation du modèle

5 Modèle de décision

6 Combat de projet d'apprentissage automatique (exploration de données)

6.1 Présentation du projet

6.2 Mise en œuvre du code

Je suppose que tu aimes