3 Machine Learning Lab Guide-Teacher Version

Machine Translated by Google
Technologie et application de l'intelligence artificielle
Apprentissage automatique
Guide du laboratoire
Version enseignant
Huawei Technologies CO., LTD.
Contenu
1 Ingénierie des fonctionnalités sur les données de crédit privées des banques .................................. ......................... 1
1.1 Introduction................................................ .................................................. .................................................. ............................1
1.1.1 À propos de ce laboratoire ................................................. .................................................. .................................................. .......................1
1.1.2 Objectifs ....................................................... .................................................. .................................................. ..................................1 1.1.3
Contexte de l'affaire............. .................................................. .................................................. .................................................1
1.2 Prétraitement des données.............................................. .................................................. .................................................. ...............2
1.2.1 Contexte.................................................. .................................................. .................................................. ................................2
1.2.2 Procédure.................................................. .................................................. .................................................. ...............................2
1.3 Sélection des fonctionnalités .................................................. .................................................. .................................................. ....................5
1.3.1 Contexte.................................................. .................................................. .................................................. .......................5
1.3.2 Méthodes de sélection des fonctionnalités.............................................. .................................................. .................................................. 5
1.3.3 Filtre............................................................. .................................................. .................................................. .......................................5
1.3.4 Enveloppe .................................................. .................................................. .................................................. ..................................8
1.3.5 Embarqué .................................................. .................................................. .................................................. ..............................9
1.3.6 Suppression des variables.................................................. .................................................. .................................................. ...............dix
1.4 Construction des fonctionnalités.................................................. .................................................. .................................................. ..........dix
1.4.1 Contexte.................................................. .................................................. .................................................. .........................dix
1.4.2 Construction d'entités polynomiales......................................... .................................................. ....................................dix
2 Prévision de défaut de crédit privé ................................................ .................................................. .... 12
2.1 Présentation................................................................ .................................................. .................................................. ..................................12
2.1.1 Objectifs ....................................................... .................................................. .................................................. ..................................12 2.1.2
Contexte.............. .................................................. .................................................. .................................................. ....12
2.2 Procédure .................................................. .................................................. .................................................. ..............................13
2.2.1 Lecture des données.............................................. .................................................. .................................................. .......................13
2.2.2 Affichage des valeurs manquantes ...................................... .................................................. .................................................. ..13 2.2.3
Fractionner l'ensemble de données ...................................... .................................................. .................................................. ...............14 2.2.4
Normalisation des données (prétraitement des données) .................. .................................................. ..................................15 2.2.5 Traitement
du problème de déséquilibre de classe (prétraitement) .................................................. .......................................15
2.2.6 Exécution d'une recherche de grille (modélisation) ....................................... .................................................. ..................................15
2.2.7 Vérification des performances (évaluation) ......................................... .................................................. ..................................16 2.2.8
Enregistrement du modèle ................ .................................................. .................................................. ..................................................17
3 Prédiction de survie du Titanic .................................................. .................................................. ..... 18
3.1 Présentation................................................................ .................................................. .................................................. .......................18
3.1.2 Objectifs ....................................................... .................................................. .................................................. ................................18
3.1.3 Ensembles de données et cadres ................................................ .................................................. ..................................................18
3.2 Procédure .................................................. .................................................. .................................................. ..................................19
3.2.1 Importation de bibliothèques associées.......................................... .................................................. ..................................................19 3.2.
2 Importation d'ensembles de données.............................................. .................................................. .................................................. ..........19
3.2.3 Prétraitement des données.................................................. .................................................. .................................................. ............23
3.2.4 Construire un modèle ................................................ .................................................. .................................................. ..................25
4 Régression linéaire ....................................................... .................................................. .................................. 27
4.1 Présentation................................................................ .................................................. .................................................. .......................27
4.1.2 Objectifs ....................................................... .................................................. .................................................. ................................27
4.2 Procédure .................................................. .................................................. .................................................. ..............................27
4.2.1 Préparation des données.............................................. .................................................. .................................................. .......................27
4.2.2 Définition des fonctions associées .................................................. .................................................. ...............................................28
4.2.3 Démarrage de l'itération.............................................. .................................................. .................................................. .................29 4.3
Réflexion et pratiques .................................. .................................................. .................................................. .......................34 4.3.1 Questions
1.................. .................................................. .................................................. .................................................. ...34
4.3.2 Questions 2.................................................. .................................................. .................................................. ................................34
5 Analyse des catégories de fleurs .................................................. .................................................. .................. 35
5.1 Présentation................................................................ .................................................. .................................................. .......................35
5.2 Code d'expérience ....................................................... .................................................. .................................................. ................35
5.2.1 Importation de bibliothèques associées.......................................... .................................................. ...............................................35 5.2.
2 Importation d'un jeu de données.............................................. .................................................. .................................................. .........35 5.2.3
Fractionnement de l'ensemble de données ...................... .................................................. .................................................. ..................35 5.2.4
Exécution de la modélisation ...................... .................................................. .................................................. ................................36
5.2.5 Effet après le prétraitement des données ...................................... .................................................. .......................................38
6 Prévisions des prix des logements à Boston .................................................. .................................................. ........ 40
6.1 Présentation................................................................ .................................................. .................................................. .......................40
6.1.2 Objectifs ....................................................... .................................................. .................................................. ..................................40
6.1.3 Ensemble de données et cadre d'expérience ...... .................................................. .................................................. .........40
6.2 Procédure .................................................. .................................................. .................................................. ..............................41
6.2.1 Présentation de la dépendance .................................................. .................................................. .......................................41
6.2.2 Chargement de l'ensemble de données, affichage des attributs de données et visualisation des données............... ..................................42
6.2.3 Fractionnement et prétraitement de l'ensemble de données ...... .................................................. .................................................. 43 6.2.4
Exécution de la modélisation sur l'ensemble de données à l'aide de divers modèles de régression .................................. ............43 6.2.5
Ajustement des hyperparamètres de recherche de grille.............. .................................................. .......................................44
7 Analyse du groupe d'utilisateurs du site Web de commerce électronique ...................... .......................................
47
7.1 Présentation................................................................ .................................................. .................................................. .......................47
7.2 Code d'expérience ....................................................... .................................................. .................................................. ..................47
7.2.1 Utilisation de sklearn pour la modélisation......................................... .................................................. ..................................................47
7.2 .2 Sélection de la valeur optimale de k ...................................... .................................................. .......................................50
Guide du laboratoire d'apprentissage automatique Version enseignant Page 1
1 Ingénierie des fonctionnalités sur le secteur privé des banques
Données de crédit
1.1 Introduction
1.1.1 À propos de ce laboratoire
L'ingénierie des fonctionnalités est un processus d'extraction de fonctionnalités à partir de données brutes. Les données et les
fonctionnalités déterminent la limite supérieure de l'apprentissage automatique, tandis que les modèles et les algorithmes aident à
approcher en permanence cette limite supérieure. L'ingénierie et la construction des caractéristiques visent à permettre aux
caractéristiques extraites de représenter au maximum les caractéristiques essentielles des données, de sorte qu'un modèle construit
sur la base de ces caractéristiques ait un bon effet de prédiction sur des ensembles de données inconnus.
1.1.2 Objectifs
À l'issue de cette tâche, vous serez en mesure de :
Maîtrisez la méthode de sélection de fonctionnalités basée sur Python.
Maîtrisez la méthode d'extraction de caractéristiques basée sur Python.
Maîtriser la méthode de construction de fonctionnalités basée sur Python.
1.1.3 Contexte de l'affaire
Avec le développement des services financiers en ligne, la banque H prévoit d'évaluer les risques des clients en utilisant l'approbation
en ligne pour réduire les coûts de maind'œuvre et améliorer l'efficacité de l'approbation. L'approbation en ligne nécessite un modèle
de contrôle des risques plus strict et plus précis pour contrôler les risques financiers de l'entreprise. Par conséquent, l'ingénieur
algorithmique A doit terminer l'ingénierie des fonctionnalités et la construction d'un modèle de risque de crédit avant de construire le
modèle basé sur les données historiques de crédit client. L'ingénieur A doit effectuer les opérations suivantes :
Prétraitement des données
Sélection des fonctionnalités
Construction de fonctionnalités
1.2 Prétraitement des données
1.2.1 Contexte
Les données brutes collectées par le serveur principal de la banque peuvent présenter des problèmes tels que des valeurs
manquantes, des caractères brouillés, des champs redondants et des formats de données incohérents. Pour améliorer la qualité des
données, l'ingénieur A doit d'abord nettoyer les données.
1.2.2 Procédure
1.2.2.1 Importation de données
Code:
importer des pandas en tant que pd
df=pd.read_csv('./credit.csv',index_col=0)
df.head()
Production:
1.2.2.2 Traitement des valeurs manquantes
Étape 1 Affichez les valeurs manquantes.
Les valeurs manquantes dans les données peuvent être causées par des défaillances de la machine, des erreurs de saisie manuelle
ou des attributs de service. La méthode de traitement des valeurs manquantes varie selon la cause.
missingno est un outil de visualisation des valeurs manquantes. Vous pouvez exécuter la commande suivante pour afficher la
distribution des valeurs manquantes dans les données :
Code:
import missingno # Importe le paquet missingno.
missingno.matrix(df)
Production:
Comme le montre la figure cidessus, les champs Nation, Marriage_State, Highest Education, House_State, Industry, Title et Duty
contiennent un grand nombre de valeurs manquantes. Dans Pandas, isnull()
peut déterminer les valeurs manquantes dans les données, et isnull().sum() peut compter le nombre de valeurs manquantes et vérifier
davantage les taux de valeurs manquantes dans les champs.
Code:
df_missing = pd.DataFrame(df.isnull().sum()/df.shape[0],columns=['missing_rate']).reset_index()
df_missing.sort_values(by='missing_rate',ascending=False)[ :15]
Production:
Étape 2 Remplissez les valeurs manquantes avec le mode.
Pandas fournit fillna() pour remplir les valeurs manquantes et mode() pour remplir les valeurs manquantes avec le mode.
Vous devez construire une boucle for pour traiter plusieurs champs contenant des valeurs manquantes et remplir les valeurs
manquantes avec le mode.
# Définissez la liste des champs avec des valeurs manquantes.
missing_col = ['Title','Industrie','House_State','Nation','Marriage_State','Highest Education','Devoir']
# Utilisez la boucle for pour traiter les valeurs manquantes dans les champs multiples.
pour col dans missing_col :
df[col]=df[col].fillna(int(df[col].mode()))
Une fois le traitement terminé, vérifiez le taux manquant de chaque champ.
df_missing_2 = pd.DataFrame(df.isnull().sum()/df.shape[0],columns=['missing_rate']).reset_index()
df_missing_2.sort_values(by='missing_rate',ascending=False)[ :15]
Voici les méthodes de gestion des valeurs manquantes :
1. Suppression directe : supprime les champs de service non importants dont le taux manquant est supérieur
plus de 80 %.
2. Remplissage des données : remplit les valeurs manquantes avec les valeurs déterminées, les valeurs des indicateurs
statistiques et les prévisions de valeurs manquantes basées sur l'algorithme.
3. Traitement séparé : traite les échantillons avec des valeurs manquantes comme une seule catégorie.
Fin
1.3 Sélection des fonctionnalités
1.3.1 Contexte
Si des caractéristiques excessives sont obtenues après le prétraitement des données, le modèle peut être instable et avoir une
faible capacité de généralisation. En conséquence, la complexité informatique augmente de façon exponentielle. Par conséquent,
l'ingénieur A doit filtrer au préalable les caractéristiques qui ne sont pas importantes pour le résultat de la prédiction.
1.3.2 Méthodes de sélection des fonctionnalités
Voici les méthodes de sélection des fonctionnalités :
Filtre : filtre les caractéristiques en fonction des indicateurs statistiques des vecteurs de caractéristiques et
celles communes aux vecteurs caractéristiques et aux variables cibles.
Wrapper : tente d'utiliser différents sousensembles de fonctionnalités pour la modélisation et d'utiliser le modèle
précision comme indicateur d'évaluation pour les sousensembles de fonctionnalités.
Embedded : évalue les pondérations des caractéristiques pendant la formation du modèle et note les
l'importance des fonctionnalités.
1.3.3 Filtre
Étape 1 Analysez le tableau croisé.
Appliquez la méthode crosstab() pour dessiner un tableau croisé en utilisant la variable House_State et la variable cible Target
comme exemple.
cross_table = pd.crosstab(df.House_State,columns = df.Target,margins=True)
cross_table_rowpct = cross_table.div(cross_table['All'],axis = 0) cross_table_rowpct
Dans la sortie, le taux par défaut est de 0,019 lorsque House_State est défini sur 1 et de 0,045 lorsque House_State est défini
sur 2. Si les taux par défaut sont considérés comme identiques, la variable House_State n'affecte pas la prédiction par défaut.
L'analyse par tableau croisé ne peut être utilisée que pour un jugement et une analyse préliminaires.
Le test du chi carré est en outre nécessaire pour déterminer si la différence numérique a une signification
statistique.
Étape 2 Effectuez le test du chi carré.
Séparez les variables indépendantes et les variables dépendantes des données brutes et sélectionnez
des variables catégorielles parmi les variables indépendantes.
Le champ Cible est une variable cible et est affecté à y. La colonne avec la variable cible supprimée est
affectée à X en tant que variable indépendante. X_category indique une variable catégorielle.
X = df.drop('Cible',axe=1) y =
df['Cible']
X_category=df[['Nation','Birth_Lieu','Sexe','Marriage_State','Highest
Education','House_State','Work_Years','Title','Devoir','Industrie']]
Importez le package de test chicarré chi2 de sklearn.feature_selection et utilisez chi2() pour calculer
les valeurs chicarré de chaque variable catégorielle et variable cible.
from sklearn.feature_selection import chi2
(chi2,pval) = chi2(X_category,y) dict_feature = {}
for i,j in zip(X_category.columns.values,chi2):
dict_feature[i]=j ls = trié(dict_feature.
items(),key=lambda item:item[1],reverse=True)
ls
Étape 3 Testez la corrélation variable continue.
Si deux variables indépendantes continues sont fortement corrélées, supprimez l'une des deux variables
indépendantes ou extrayez les informations communes des deux variables indépendantes.
nominal_features = ['Nation','Lieu_de_naissance','Sexe','État_mariage','Éducation la plus
élevée','État_maison','Années_travail','Unit_Kind','Titre', 'Profession','Devoir','Industrie ']
caractéristiques_numériques = [col_ pour col_ dans df.columns si col_ pas dans
caractéristiques_nominales ] caractéristiques_numériques.pop(0) # Supprime le premier élément
de la liste.
X_num = df[numerical_features]
Le paramètre méthode indique la méthode de calcul du coefficient de corrélation. Les options sont les
suivantes :
pearson : coefficient de corrélation de Pearson.
kendall : coefficient de corrélation pour les variables catégorielles non ordonnées.
spearman : coefficient de corrélation de Spearman, qui est principalement utilisé pour l'analyse de
corrélation de données non linéaires et non distribuées normalement.
importer matplotlib.pyplot en tant que plt
importer seaborn en tant que sns
corr_matrix = X_num.corr(method='pearson')
plt.figure(figsize=(25, 15)) sns.heatmap(corr_matrix,
annot= True) # Afficher la corrélation entre la carte thermique et les variables de manière visuelle.
Calculer le coefficient de corrélation entre variables indépendantes continues et sélectionner
la combinaison de variables indépendantes dont le coefficient de corrélation est supérieur à 0,8.
cols_pair = []
pour index_ dans corr_matrix.index :
pour col_ dans corr_matrix.columns : si
corr_matrix.loc[index_,col_] >= 0,8 et index_!=col_ et (col_,index_) pas dans cols_pair :
paire_cols.append((index_,col_))
paire_cols
Fin
1.3.4 Emballage
Dans la méthode de sélection wrapper, différents sousensembles de caractéristiques sont utilisés pour la
modélisation, la précision du modèle est utilisée comme indicateur d'évaluation pour les sousensembles de
caractéristiques et un modèle de base est sélectionné pour effectuer une formation en plusieurs tours. Après
chaque cycle d'entraînement, les caractéristiques de certains coefficients de pondération sont supprimées, puis le
cycle d'entraînement suivant est effectué sur la base du nouvel ensemble de fonctionnalités. La méthode RFE() du
sousmodule feature_selection dans sklearn est appelée. Le modèle de régression logistique LogisticRegressio()
est utilisé comme modèle de base à invoquer et les paramètres seront transférés dans ce modèle.
Enveloppe :
estimateur : modèle d'entraînement de base, qui est un modèle de régression logistique dans cet exemple.
n_features_to_select : indique le nombre de fonctionnalités retenues.
fit(X,y) : invoque et entraîne un modèle.
depuis sklearn.feature_selection importer RFE depuis
sklearn.linear_model importer LogisticRegression
x_rfe=RFE(estimator=LogisticRegression(), n_features_to_select=20).fit(X, y) print(x_rfe.n_features_ )
impression(x_rfe.support_ )
imprimer(x_rfe.ranking_ )
print(x_rfe.estimator_ )
Production:
20
[ Vrai Vrai Faux Vrai Vrai Vrai Faux Vrai Vrai Vrai Faux Faux Vrai Faux Vrai Vrai
Faux Vrai Vrai Vrai Vrai Vrai Vrai Faux Faux Faux Vrai Faux] [ 1 1 9 1 1 1 10 1 1 1 1
6 3 1 11 1 1 8 1 1 1 1 1 1 1 5 4 7 1 2]
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True, intercept_scaling=1,
max_iter=100, multi_class='warn', n_jobs=None, penalty='l2', random_state=None, solver='warn ',
tol=0.0001, verbeux=0, warm_start=Faux)
La valeur de retour de la méthode RFE() est la sortie, qui peut être l'une des suivantes :
n_features_ : nombre de fonctionnalités sélectionnées, c'estàdire la valeur
Paramètre n_features_to_select transféré dans la méthode RFE().
support_ : indique que les fonctionnalités sélectionnées sont affichées à leurs positions correspondantes.
True indique que la fonctionnalité est conservée et False indique que la fonctionnalité est supprimée.
classement_ : indique le classement des fonctionnalités. ranking_[i] correspond au classement de la i ème
caractéristique. La valeur 1 indique la fonctionnalité optimale. Les caractéristiques sélectionnées sont les 20
caractéristiques correspondant à la valeur 1, à savoir les caractéristiques optimales.
estimateur_ : renvoie les paramètres du modèle de base.
1.3.5 Embarqué
La méthode intégrée utilise un modèle d'apprentissage automatique pour l'entraînement afin d'obtenir des coefficients de pondération
de caractéristiques, et sélectionne des caractéristiques dans l'ordre décroissant des coefficients de pondération.
Les méthodes intégrées courantes sont basées sur l'un des éléments suivants :
Modèle linéaire et régularisation
Sélection de fonctionnalités d'un modèle d'arbre
Dans le modèle arborescent, l'importance d'une caractéristique est déterminée par la profondeur du nœud feuille.
Dans cette expérience, la forêt aléatoire est utilisée pour calculer l'importance d'une caractéristique.
La méthode de classification de forêt aléatoire dans le sousmodule sklearn.ensemble est invoquée pour entraîner le modèle à l'aide
de la méthode fit(X,y).
de sklearn.ensemble importer RandomForestClassifier
rfc=RandomForestClassifier()
rfc.fit(X,y)
Une fois la formation du modèle terminée, la valeur d'évaluation du poids de chaque caractéristique est imprimée.
cols=[i pour i dans X.columns]
sorted_feature=sorted(zip(map(lambda x:round(x,4),rfc.feature_importances_),cols),reverse=True) sorted_feature
Production:
[(0.1315, 'Ast_Curr_Bal'),
(0.1286, 'Age'), (0.0862,
'Year_Income'), (0.0649,
'Std_Cred_Limit'), (0.043,
'ZX_Max_Account_Number'), (0.0427,
'Highest Education'), (0.0416,
'ZX_Link_Max_Overdue_Amount'), (0.0374,
'ZX_Max_Link_Banks'), (0.0355, 'Industrie'), (0.0354,
'ZX_Max_Overdue_Duration'), (0.0311,
'ZX_Total_Overdu_Months'), (0.0305,
'Marriage_State30'), (0.0305, 'Marriage_State30'),
(0.0305, 'Marriage_State30'), (0.0305,
'Marriage_State30'), (0.0305, 'Marriage_State30'),
(0.0305, 'Marriage_State30'), , 'Devoir'), (0.0292,
'Couple_Year_Revenu'), (0.0279,
'ZX_Credit_Max_Overdu_Amount'), (0.0246,
'ZX_Max_Overdue_Account'), (0.0241,
'ZX_Max_Credit_Banks'), (0.0221, 'ZX_Max_Credits'),
(0.0205, ' Lieu de naissance'), (0.0195, 'Loan_Curr_Bal'),
(0.0173, 'L12_Month_Pay_Amount'), (0.015,
'ZX_Credit_Max_Overdue_Duration'), (0.013, 'Title'),
(0.0097, 'ZX_Credit_Total_Overdue_Months'), (0.0096,
'Nation' ), (0.0084, 'Sexe'), (0.0079, 'Années_travail'),
(0.0064, 'ZX_Max_Overdue_Credits'),
(0.0059, 'House_State'), (0.0,
'Couple_L12_Month_Pay_Amount')]
1.3.6 Suppression des variables
Sur la base des résultats des trois méthodes de sélection de variables précédentes, les variables qui ont un faible
poids d'impact du modèle sont supprimées.
del_cols
=['Sexe','House_State','Couple_Year_Income','Loan_Curr_Bal','ZX_Max_Credit_Banks','ZX_Max_Overd
ue_Credits','ZX_Credit_Max_Overdu_Amount','ZX_Credit_Max_Overdue_Duration']
df_select = df.drop(del_cols,axis=1) df_select.head()
1.4 Construction des fonctionnalités
1.4.1 Contexte
La sélection des fonctionnalités est utilisée pour déterminer l'importance de chaque fonctionnalité pour la construction
du modèle et supprimer les variables qui ont peu d'impact sur la construction du modèle afin de réduire les dimensions.
La construction de caractéristiques consiste à découvrir manuellement certaines caractéristiques importantes du
modèle à partir de données brutes. D'une part, une nouvelle variable peut être construite en combinant plusieurs
caractéristiques différentes basées sur la compréhension du service ; d'autre part, des variables de fenêtres temporelles
différentes peuvent être divisées selon un attribut temporel.
L'ingénieur A a terminé le filtrage préliminaire des caractéristiques, supprimé certaines variables qui ont peu d'impact
sur le modèle et tente maintenant de construire de nouvelles caractéristiques pour améliorer la précision du modèle.
1.4.2 Construction de caractéristiques polynomiales
La construction de caractéristiques polynomiales consiste à explorer l'impact de variables complexes sur la variable
cible grâce à la transformation de produits pour les caractéristiques existantes. Les fonctions polynomiales()
La méthode dans le sousmodule sklearn.preprocessing est utilisée pour l'interaction des fonctionnalités. Les variables
avec des scores plus élevés dans le modèle, c'estàdire Ast_Curr_Bal, Age, Year_Income et Std_Cred_Limit, sont
sélectionnées pour construire une caractéristique polynomiale.
PolynomialFeatures(degree=3) : spécifie le degré 3 d'interaction entre les variables, c'estàdire construit un polynôme
dont la somme des puissances de deux variables est 3.
from sklearn.preprocessing import PolynomialFeatures
poly_feature = df[['Ast_Curr_Bal','Age','Year_Income','Std_Cred_Limit']] # Sélectionnez les champs
utilisés pour construire la fonction polynomiale. poly_trans = PolynomialFeatures(degree = 3) ptf =
poly_trans.fit(poly_feature) # Appelez la méthode fit() pour construire la caractéristique polynomiale.
poly_feature = poly_trans.transform(poly_feature) # Convertir les données.
Pour vérifier la corrélation entre la variable nouvellement générée et la variable cible, construisez
d'abord un ensemble de données contenant la variable cible et la variable nouvellement générée.
poly_features=pd.DataFrame(poly_feature,columns
=poly_trans.get_feature_names(['Ast_Curr_Bal','Age','Year_Income','Std_Cred_Limit']))
poly_features['Target']=y
poly_features.head()
La fonction corr() permet de calculer le coefficient de corrélation entre la variable nouvellement
générée et la variable cible.
poly_corrs = poly_features.corr()['Target'].sort_values()
print("cinq entités avec les plus petits coefficients de corrélation : \n",poly_corrs.head(5))
print("cinq entités avec les plus grands coefficients de corrélation : \ n",poly_corrs.tail(5))
Production:
Cinq caractéristiques avec les plus petits coefficients de corrélation :
Age^3 0.010601
Age^2 0.009275
Age^2 Std_Cred_Limit 0.008064
Age 0.007356 Age Std_Cred_Limit
0.006834 Nom : Target, dtype :
float64 1,000000 1 NaN
Nom : Cible, dtype : float64
2 Prévision de défaut de crédit privé
2.1 Présentation
Sous l'impact d'Internet, les institutions financières souffrent de troubles internes et externes. D'une part, les
institutions financières sont confrontées à une forte concurrence et à une pression de performance de la part
des grandes entreprises financières et technologiques ; d'autre part, de plus en plus de groupes criminels
utilisent les technologies de l'intelligence artificielle (IA) pour accroître l'efficacité de la criminalité. Ces détails de
risque sont cachés dans chaque phase de transaction. Si elles ne sont pas empêchées, les pertes seront
irréparables. Par conséquent, les institutions financières imposent des exigences de plus en plus élevées en
matière de précision de la gestion des risques et d'efficacité des approbations.
Cette expérience discutera du problème et effectuera la pratique étape par étape du point de vue de l'énoncé du
problème, de la répartition, du classement des priorités, de la conception de la solution, de l'analyse des points
clés, du résumé et des suggestions, et cultivera la réflexion sur la mise en œuvre du projet et mettra en œuvre
l'analyse du défaut de crédit privé prédiction à partir de zéro.
2.1.1 Objectifs
Comprendre l'importance de la prédiction de défaut de crédit.
Maîtriser le processus de développement des projets de Big Data Mining.
Maîtriser les algorithmes courants de prédiction des défauts de crédit privés.
Comprendre l'importance du traitement des données et de l'ingénierie des fonctionnalités.
Maîtriser les méthodes courantes de prétraitement des données et d'ingénierie des fonctionnalités
Maîtriser les principes algorithmiques de régression logistique et XGBoost, et comprendre
les paramètres clés.
2.1.2 Contexte
Le cas dans ce document est pour référence seulement. La procédure réelle peut varier. Pour plus de détails,
consultez les documents produits correspondants.
La société vient de mettre en place une équipe projet pour la prédiction des défauts de crédit privés. L'ingénieur
A a été nommé responsable du développement hors ligne du projet. Ce projet vise à :
Identifiez les clients à haut risque de manière efficace et précise à l'aide des nouvelles technologies.
Rendre les modes de risque basés sur des données en utilisant des méthodes scientifiques.
Fournir une mesure objective des risques.
Réduire les jugements subjectifs.
Améliorer l'efficacité de la gestion des risques.
Économisez les coûts de maind'œuvre.
L'objectif ultime est de produire les résultats, afin que les départements opérationnels frontaux puissent identifier
en temps opportun les transactions présentant des risques de défaut de crédit afin d'éviter les pertes de l'entreprise.
2.2 Procédure
2.2.1 Lecture des données
Tout d'abord, importez le jeu de données. Ce document utilise un module tiers de Pandas pour importer l'ensemble
de données.
import pandas as pd #
Utilisez pd.read_csv pour lire le jeu de données. (Le jeu de données est stocké dans le répertoire courant afin qu'il puisse être lu
directement.) # ./credit.csv indique le répertoire courant. La barre oblique (/) ici doit être dans la même direction que celle d'un
répertoire du système d'exploitation Linux (OS).
# Dans le système d'exploitation Windows, la barre oblique inverse (\) est utilisée. Par conséquent, la barre oblique dans le chemin du fichier doit être la même que
celle du système d'exploitation Linux.
# N'oubliez pas d'utiliser le symbole de la barre oblique dans la même touche du clavier que le point d'interrogation (?).
data=pd.read_csv('./credit.csv')
# Un avertissement de module auxiliaire peut être importé.
avertissements d'importation warnings.filterwarnings('ignorer')
# Ce module peut aider à filtrer de nombreux avertissements redondants et gênants.
# Après la lecture des données, quelques opérations simples peuvent être effectuées, par exemple : #
Exécutez la commande suivante pour afficher toutes les données. data # Exécutez la commande
suivante pour afficher les 10 premières lignes de données. data.head(10)
# Exécutez la commande suivante pour afficher la longueur et la largeur des données au format matriciel. data.shape
2.2.2 Affichage des valeurs manquantes
# Vérifiez l'état des données manquantes de manière visuelle.
# La bibliothèque tierce missingno est utilisée. import
missingno missingno.matrix(data)
# De nombreuses valeurs manquent et doivent être remplies.
# Il existe de nombreuses méthodes de remplissage. Les valeurs manquantes peuvent être remplies avec des valeurs moyennes, des
médianes et le mode.
#Les types numériques incluent les discrets et les continus.
# Si les valeurs moyennes sont utilisées, une nouvelle valeur discrète peut être générée. Par conséquent, le mode est utilisé pour la simplicité.
missname=[i pour i dans data if data[i].isnull().sum()>0]
pour moi dans missname:
data[i]=data[i].fillna(int(data[i].mode()))
#isnull() est utilisé pour déterminer si une valeur est nulle. Si oui, True est renvoyé. Sinon, False est renvoyé.
# En Python, 1 est égal à True et 0 est égal à False.
# Par conséquent, sum() est utilisé pour le jugement. Si le résultat est supérieur à 0, True s'affiche.
# Les entités avec des valeurs manquantes sont placées dans la liste des noms manquants.
#fillna() est utilisé pour remplir les valeurs vides avec le mode.
2.2.3 Fractionner l'ensemble de données
Ensuite, divisez le jeu de données. Avant de diviser l'ensemble de données, supprimez l'index car il n'est pas
important et interfère avec le jugement du modèle, et supprimez la cible (résultat) qui ne peut pas être utilisée
comme entrée dans le modèle.
X=data.drop(['No_Client','Cible'],axe=1)
y=données['Cible']
X équivaut à une variable indépendante en mathématiques et y équivaut à une variable dépendante. Importez
la fonction de fractionnement du jeu de données pour fractionner le jeu de données.
depuis sklearn.model_selection importer train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.1,shuffle=True)
X_train est l'ensemble d'apprentissage et y_train est la réponse à l'ensemble d'apprentissage. X_test est
l'ensemble de test et y_test est la réponse à l'ensemble de test. test_size=0.1 indique que le rapport de la
ensemble de formation à l'ensemble de test est de 9:1. shuffle indique que l'ensemble d'apprentissage et l'ensemble de test
sont mélangés.
2.2.4 Normalisation des données (prétraitement des données)
Une fois l'ensemble de données divisé, normalisez les données.
depuis sklearn.preprocessing importer StandardScaler
std_scaler=StandardScaler().fit(X)
X_train_std=std_scaler.transform(X_train)
X_test_std=std_scaler.transform(X_test)
La standardisation consiste à s'assurer que les données sont conformes à la distribution normale. Dans les environnements
naturels, la distribution aléatoire réelle est similaire à la distribution normale et un point d'agrégation apparaît. Une distribution
aléatoire complètement équilibrée n'est pas naturelle mais intentionnelle. Dans les commandes précédentes, la fonction de
normalisation StandardScaler() est d'abord déclarée. La fonction d'ajustement suivante est utilisée pour obtenir l'écart type et la
valeur moyenne de l'ensemble de données. Ensuite, transform est utilisé pour transformer les données.
2.2.5 Traitement du problème de déséquilibre de classe (prétraitement)
Ensuite, traitez le problème du déséquilibre des classes, qui concerne principalement la différence entre le nombre de résultats
positifs et le nombre de résultats négatifs des données. Dans cet ensemble de données, le nombre de défaillants (représenté
par 1) est très petit, et le nombre de non défaillants (représenté par 0) est très grand. Par conséquent, le modèle tend à
déterminer les personnes comme non défaillantes en raison d'un déséquilibre de classe. Vérifiez d'abord le rapport de résultat
actuel.
depuis le compteur d'importation de collections
Compteur(y_train)
# Utilisez les collections de la bibliothèque standard pour interroger les résultats.
# Importez la bibliothèque tierce imblearn.
de imblearn importer over_sampling
fixtool=over_sampling.SMOTE()
X_train_fix,y_train_fix=fixtool.fit_resample(X_train_std,y_train)
# X_train_fix et y_train_fix sont les données corrigées.
# Ensuite, vérifiez le nombre d'échantillons.
Compteur(y_train_fix)
# Vérifiez le y_train_fix corrigé au lieu du y_train d'origine.
2.2.6 Effectuer une recherche de grille (modélisation)
depuis sklearn.model_selection importer cross_val_score
de sklearn.linear_model importer LogisticRegression
# Déclarez l'algorithme de régression logistique et définissez max_iter (le nombre maximum de temps d'entraînement) sur 500.
# Effectuez un jugement basé sur la réflexion de vérification croisée pour aider à diviser l'ensemble de données.
# cv=5 indique que le jeu de données est divisé en cinq parties égales.
lr_model = LogisticRegression(solver='liblinear',max_iter=500)
cv_scores = cross_val_score(lr_model,X_train_fix,y_train_fix,scoring='roc_auc',cv=5)
# Appliquez la recherche de grille pour trouver les paramètres optimaux grâce à la traversée.
# Importer le module de recherche de grille.
from sklearn.model_selection import GridSearchCV # C
indique le coefficient de régularisation.
c_range=[0.001,0.01,0.1,1.0] # solveurs indique la méthode
d'optimisation. solveurs=['liblinéaire','lbfgs','newtoncg','sag']
# Combinez le coefficient de régularisation avec la méthode d'optimisation en utilisant la méthode du dictionnaire.
tuned_parameters=dict(solveur=solveurs,C=c_range)
# Déclarez l'algorithme de régression logistique.
lr_model=Régression Logistique(solver='liblinear',max_iter=500)
# Déclarez l'algorithme de recherche de grille et décrivez la méthode de vérification croisée.
grid=GridSearchCV(lr_model,tuned_parameters,cv=5,scoring='roc_auc')
# Effectuez une
formation. grille.fit(X_train_fix,y_train_fix)
# Vérifiez la précision optimale.
impression(grid.best_score_)
# Vérifiez quels paramètres sont optimaux.
impression(grid.best_params_)
2.2.7 Vérification des performances (évaluation)
Ensuite, vérifiez le résultat.
from sklearn.metrics import precision_score,precision_score,recall_score,roc_auc_score # Utilisez les
paramètres optimaux obtenus pour la modélisation. lr_model=Régression
Logistique(C=grid.best_params_['C'],solver=grid.best_params_['solver'],max_iter=500 ) lr_model.fit(X_train_fix,y_train_fix)
# Construire une fonction pour renvoyer le résultat de la
vérification. def scoree(model,X,y,name=None):
y_predict=model.predict(X)
# Utilisez le paramètre predict pour prédire le résultat. if
name : print(name,':') print('accuracy score is:
{}'.format(accuracy_score(y,y_predict))) print('precision
score is:{}'.format(precision_score(y,y_predict) ))) print('le score de rappel
est :{}'.format(recall_score(y,y_predict))) print('aic:
{}'.format(roc_auc_score(y,y_predict)))
# Sortir les données de performance de l'ensemble
d'entraînement. scoree(lr_model,X_train_fix,y_train_fix)
# Sortie des données de performance de l'ensemble de
test. score (lr_model,X_test_std,y_test)
2.2.8 Enregistrement du modèle
Enregistrez le modèle.
# Importation de la bibliothèque
joblib import joblib # La fonction
de vidage est utilisée pour enregistrer les modèles. Entrez le modèle formé et le nom du modèle dans la fonction de vidage
pour enregistrer le modèle.
# Le fichier modèle doit être suffixé par .pkl.
joblib.dump(lr_model,'lr_model.pkl')
# Chargez à nouveau le modèle
enregistré. loadmodel=joblib.load('lr_model.pkl')
# Une fois le modèle chargé, utilisezle directement pour la prédiction.
loadmodel.predict(X_test_std)
3 Prédiction de survie du Titanic
3.1 Présentation
Cette expérience vise à prédire si les passagers du Titanic peuvent survivre sur la base des ensembles de
données du Titanic.
3.1.2 Objectifs
À la fin de cette tâche, vous serez en mesure de : Utiliser
les ensembles de données Titanic ouverts sur Internet comme données d'entrée du modèle.
Construire, former et évaluer des modèles d'apprentissage automatique Comprendre le
processus global de création d'un modèle d'apprentissage automatique.
3.1.3 Ensembles de données et cadres
Cette expérience est basée sur train.csv et test.csv. test.csv contient le résultat indiquant si les passagers peuvent
survivre. Cet ensemble de données n'a pas de cible, c'estàdire aucun résultat, et peut être utilisé comme
ensemble de données du monde réel. Les paramètres impliqués sont les suivants : PassengerId : identifiant
du passager Pclass : classe de cabine (classe 1/2/3) Name : nom du passager Sex : genre Age : âge
SibSp : nombre de frères et sœurs/nombre de conjoints Parch : nombre de parents/nombre d'enfants
Billet : numéro de billet.
Tarif : prix du billet
Cabine : cabine No.
Embarqué : port d'embarquement
3.2 Procédure
3.2.1 Importation de bibliothèques associées
importer des pandas en tant que
pd importer numpy en tant que
np importer au hasard en tant que rnd
importer seaborn en tant que
sns importer matplotlib.pyplot en tant
que plt %matplotlib en ligne
depuis sklearn.linear_model importer LogisticRegression depuis
sklearn.svm importer SVC, LinearSVC depuis sklearn.ensemble
importer RandomForestClassifier depuis sklearn.neighbors importer
KNeighborsClassifier depuis sklearn.naive_bayes importer GaussianNB
depuis sklearn.linear_model importer Perceptron depuis
sklearn.linear_model importer SGDClassifier depuis sklearn.tree importer
DecisionTreeClassifier
3.2.2 Importation de jeux de données
Étape 1 Lire les données.
train_df = pd.read_csv('./train.csv') test_df =
pd.read_csv('./test.csv') combiner = [train_df,
test_df]
Étape 2 Affichez les données.
print(train_df.columns.values)
Les cinq premières lignes de données sont affichées.
train_df.head()
Les cinq dernières lignes de données sont affichées.
L'aperçu des données permet de vérifier si certaines données manquent et quel est le type de données.
train_df.info()
test_df.info()
Les informations de type numérique associées aux données permettent de vérifier la valeur moyenne et d'autres
statistiques.
train_df.describe()
Les informations sur le type de caractère permettent de vérifier le nombre de types, le type avec la valeur maximale
et la fréquence.
train_df.describe(include=['O'])
Étape 3 Vérifiez la probabilité de survie correspondant à chaque caractéristique en fonction des statistiques.
train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False).mean().sort_values(by='Survived',
ascending=False)
Les données intuitives montrent que les passagers des cabines de classe 1 ont plus de chances de survivre.
train_df[["SibSp", "Survived"]].groupby(['SibSp'], as_index=False).mean().sort_values(by='Survived',
ascending=False)
La probabilité de survie peut être directement déterminée par le nombre de frères et sœurs.
train_df[["Sexe", "Survived"]].groupby(['Sex'], as_index=False).mean().sort_values(by='Survived',
ascending=False)
Lorsque la probabilité de survie est déterminée par le sexe, un déséquilibre évident se produit.
g = sns.FacetGrid(train_df, col='Survived')
g.map(plt.hist, 'Age', bins=20)
Comme le montre la figure précédente, la plupart des jeunes passagers sont décédés.
grid = sns.FacetGrid(train_df, col='Survived', row='Pclass', size=2.2, aspect=1.6)
grid.map(plt.hist, 'Age', alpha=.5, bins=20) grid .add_legend()
La figure suivante montre la probabilité de survie déterminée en fonction de la cabine et de l'âge.
Fin
3.2.3 Prétraitement des données
Comme les ensembles de données ont des valeurs manquantes, combinez les ensembles de données et remplissez les valeurs manquantes avec des
données.
Étape 1 Combinez les ensembles de données.
data=pd.concat([train_df,test_df],ignore_index=True)
Étape 2 Recherchez les valeurs manquantes.
data.isnull().sum()
Étape 3 Remplissez les valeurs manquantes avec des données.
Traiter les ensembles de données en utilisant différentes méthodes selon les besoins. Par exemple, remplissez les
paramètres Fare et Embarked ayant peu de valeurs manquantes avec le mode.
data['Embarqué'].fillna(str(data['Embarqué'].mode()[0]),inplace=True)
data['Tarif'].fillna(int(data['Tarif'].mode( )[0]),en place=Vrai)
Utilisez la valeur d'âge moyen.
data['Age'].fillna(data['Age'].mean(),inplace=True)
Supprimez les données moins importantes. Avant cela, attribuez d'abord une valeur à Target.
Target=data['Survived']
data=data.drop(['Cabine','Nom','Ticket','Survived'],axis=1)
Vérifiez si des valeurs manquantes existent toujours.
data.isnull().sum()
Étape 4 Convertissez les données.
Convertissez certaines données de type caractère en données de type numérique pour l'entrée du modèle. Pour ce faire,
vérifiez d'abord le nombre de types.
data['Sexe'].value_counts()
Utilisez la fonction de recherche pour obtenir chaque valeur de type caractère et remplacezla par une valeur de type numérique.
data['Sexe']=data['Sexe'].replace(['homme','femme'],[0,1])
data['Embarqué']=data['Embarqué'].replace(['S','C','Q'],[0,1,2])
test.csv ne peut pas être utilisé comme jeu de test de formation car il ne contient pas de cible. train.csv contient 891 éléments de données
(avec cible), qui doivent être extraits.
X=données[:891]
y=Cible[:891]
Fin
3.2.4 Construction d'un modèle
Cette section décrit comment créer un modèle. Pour créer un modèle, divisez l'ensemble d'apprentissage et l'ensemble de test.
Étape 1 Divisez le jeu de données.
train_x,test_x,train_y,test_y=train_test_split(X,y)
Étape 2 Entraînez un modèle.
L'algorithme de régression logistique, l'algorithme de forêt aléatoire et AdaBoost sont utilisés pour la formation.
de sklearn.linear_model importer LogisticRegression
de sklearn.ensemble importer RandomForestClassifier
de l'ensemble d'importation sklearn
modèle=Régression Logistique()
model.fit(X,y)
print('logR',model.score(X,y))
modèle=RandomForestClassifier()
model.fit(X,y)
print('RFC',model.score(X,y))
modèle=ensemble.AdaBoostClassifier()
model.fit(X,y)
print('AdaBoost',model.score(X,y))
Comme indiqué cidessus, l'algorithme de forêt aléatoire a un bon effet.
Étape 3 Prédire les données.
model.predict(data[891:])
Fin
4 Régression linéaire
4.1 Présentation
Cette expérience utilise le code Python de base et les données les plus simples pour reproduire la manière dont un
algorithme de régression linéaire itère et s'adapte à la distribution de données existante.
Les modules NumPy et Matplotlib sont utilisés dans l'expérience. NumPy est utilisé pour le calcul et Matplotlib est
utilisé pour le dessin.
4.1.2 Objectifs
À la fin de cette tâche, vous serez en mesure de : Être
familiarisé avec les instructions Python de base. Maîtriser la
procédure de mise en œuvre de la régression linéaire.
4.2 Procédure
4.2.1 Préparation des données
Définissez au hasard dix éléments de données, avec les données dans une relation linéaire.
Convertissez les données dans un format de tableau afin que les données puissent être directement calculées lorsque
la multiplication et l'addition sont utilisées.
Code:
# Importez les modules requis NumPy pour le calcul et Matplotlib pour le dessin. import numpy as np
import matplotlib.pyplot as plt #Ce code est utilisé uniquement pour Jupyter Notebook. %matplotlib en
ligne
# Définissez les données et convertissez la liste en tableau.
x=[3,21,22,34,54,34,55,67,89,99] x = np.tableau(x) y =
[1,10,14,34,44,36,22,67, 79,90] y = np.tableau(y)
# Affichez les données via le graphique en nuage de
points. plt.scatter (x,y)
Production:
Figure 41 Nuage de points
4.2.2 Définition des fonctions associées
Fonction modèle : définit le modèle de régression linéaire wx+b.
Fonction de perte : calcule l'erreur quadratique moyenne.
Fonction d'optimisation : calcule les dérivées partielles de w et b en utilisant la méthode de descente de
gradient.
Code:
# Le modèle de régression linéaire de base est wx+b. Dans cet exemple, le modèle est ax+b car un espace à deux dimensions est
utilisé.
def model(a,b,x):
retourner a*x+b
# La fonction de perte d'erreur quadratique moyenne est la fonction de perte la plus couramment utilisée dans le modèle
de régression linéaire.
def loss_function(a,b,x,y):
num=len(x)
prédire=modèle(a,b,x)
return (0.5/num)*(np.square(predicty)).sum()
# La fonction d'optimisation utilise principalement les dérivées partielles pour mettre à jour a et b.
def optimiser(a,b,x,y):
num=len(x)
prédire=modèle(a,b,x)
da = (1.0/num) * ((predict y)*x).sum() db = (1.0/
num) * ((predict y).sum()) a = a Lr*da
b = b Lr*db
retourner a, b
# Effectue une itération de fonction pour renvoyer a et b.
def itérer(a,b,x,y,times): for i in
range(times): a,b =
optimiser(a,b,x,y) return a,b
4.2.3 Itération de démarrage
Étape 1 Initialisez le modèle d'optimisation itératif.
Code:
# Initialiser et afficher les paramètres.
a = np.aléatoire.rand(1)
print(a) b
= np.random.rand(1)
Lr = 1e4
a,b = itérer(a,b,x,y,1)
prédiction=modèle(a,b,x) loss
= loss_function(a, b, x, y) print(a,b,loss)
plt.scatter( x,y) plt.plot(x,prédiction)
Production:
Figure 42 Première itération
Étape 2 Effectuez la deuxième itération et affichez les valeurs des paramètres, les valeurs de perte et
effet de visualisation.
Code:
prédiction=modèle(a,b,x)
loss = loss_function(a, b, x, y)
print(a,b,loss)
plt.scatter(x,y)
plt.plot(x,prediction)
Production:
Figure 43 Deuxième itération
Étape 3 Effectuez la troisième itération et affichez les valeurs des paramètres, les valeurs de perte et
Code:
loss = loss_function(a,b,x,y)
print(a,b,loss)
plt.scatter(x,y)
Production:
Figure 44 Troisième itération
Étape 4 Effectuez la quatrième itération et affichez les valeurs des paramètres, les valeurs de perte et
Code:
print(a,b,loss)
plt.scatter(x,y)
Production:
Figure 45 Quatrième itération
Étape 5 Effectuez la cinquième itération et affichez les valeurs des paramètres, les valeurs de perte et la visualisation
effet.
Code:
print(a,b,loss)
plt.scatter(x,y)
Production:
Figure 46 Cinquième itération
Étape 6 Effectuez la 10 000ème itération et affichez les valeurs des paramètres, les valeurs de perte et
Code:
loss = loss_function(a, b, x, y)
print(a,b,loss)
plt.scatter(x,y)
Production:
Figure 47 10 000ème itération
Fin
4.3 Réflexion et pratiques
4.3.1 Questions 1
La valeur de perte doitelle revenir à zéro lorsque les données brutes sont modifiées ?
4.3.2 Questions 2
Quelle est la fonction de Lr lors de la modification de Lr ?
5 Analyse des catégories de fleurs
5.1 Présentation
Cette expérience utilise un ensemble de données avec une petite quantité d'échantillons. L'ensemble de données comprend les données open
source Iris fournies par scikitlearn. Le projet de prédiction Iris est un modèle de classification simple. En utilisant ce modèle, vous pouvez comprendre
l'utilisation de base et les méthodes de traitement des données de la bibliothèque d'apprentissage automatique sklearn.
5.2 Code d'expérience
5.2.1 Importation de bibliothèques associées
importer numpy en tant que np
5.2.2 Importation d'un jeu de données
L'ensemble de données est les données intégrées de sklearn. Par conséquent, aucun jeu de données externe ne doit être importé.
à partir de sklearn.datasets importer load_iris
data=load_iris()
x = données.données
y = données.cible
Selon le code précédent, x est spécifié comme une caractéristique et y comme une étiquette. L'ensemble de données comprend un total de 150
échantillons et quatre caractéristiques : la longueur des sépales, la largeur des sépales, la longueur des pétales et la largeur des pétales.
5.2.3 Fractionner l'ensemble de données
Divisez les données en un ensemble d'apprentissage et un ensemble de test.
train_X,test_X,train_y,test_y=train_test_split(x,y)
Afficher la taille des données après le fractionnement.
Taille des données avant le fractionnement :
forme x
Taille des données après le fractionnement :
train_X.forme
5.2.4 Exécution de la modélisation
5.2.4.1 Régression logistique
Importez le modèle d'algorithme à utiliser.
depuis sklearn.linear_model importer LogisticRegression
depuis sklearn.neighbors importer KNeighborsClassifier
depuis sklearn importer svm depuis sklearn.tree importer
DecisionTreeClassifier
La régression logistique est utilisée pour la modélisation en premier. La méthode multiclasse un contre un (OvO) est utilisée par défaut
pour la régression logistique.
model = LogisticRegression()
model.fit(train_X,train_y)
print('Logistic Regression:',model.score(test_X,test_y))
Comme décrit cidessus, la régression logistique a un bon effet.
5.2.4.2 SVM
Utilisez la machine à vecteurs de support (SVM) pour la classification. La méthode multiclasse un contre le reste (OvR) est utilisée par
défaut pour la SVM.
model = svm.SVC()
print('SVM:',model.score(test_X,test_y))
5.2.4.3 Arbre décisionnel
Utilisez l'algorithme de l'arbre de décision.
model=DecisionTreeClassifier()
print('Decision Tree',model.score(test_X,test_y))
5.2.4.4 Algorithme des Kplus proches voisins
Utilisez l'algorithme des k plus proches voisins.
model=KNeighborsClassifier(n_neighbors=3)
model.fit(train_X,train_y) print('
KNN',model.score(test_X,test_y))
Trois voisins sont définis pour l'algorithme des k plus proches voisins. Un autre nombre de voisins peut être essayé
pour une meilleure précision.
Par conséquent, la méthode de récursivité est utilisée pour trouver le nombre optimal de voisins.
t=[]
for i in range(1,11):
model=KNeighborsClassifier(n_neighbors=i)
model.fit(train_X,train_y) print('neighbor:{},acc:
{}'.format(i,model. score(test_X,test_y)))
t.append(model.score(test_X,test_y)) plt.plot([i for i in range(1,11)],t)
Comme le montre la figure cidessus, l'algorithme des k plus proches voisins a un effet optimal lorsqu'il existe un voisin
le plus proche.
5.2.5 Effet après le prétraitement des données
Envisagez la normalisation des données avant la modélisation.
depuis sklearn.preprocessing importer StandardScaler
std=StandardScaler()
train_X_std=std.fit_transform(train_X)
test_X_std=std.transform(test_X)
print('after',train_X_std.std(axis=0),train_X_std.mean(axis=0))
Après normalisation, l'écart type est de 1 et la valeur moyenne est infiniment proche de
0.
model = svm.SVC()
model.fit(train_X_std,train_y)
print('SVM:',model.score(test_X_std,test_y))
Ensuite, utilisez le SVM pour effectuer la modélisation après la normalisation. Remplacez les noms de données de l'ensemble
d'apprentissage et de l'ensemble de test par de nouveaux noms.
Comme décrit cidessus, la précision SVM est également améliorée après la normalisation.
6 Prévisions des prix des logements à Boston
6.1 Présentation
Cette expérience utilise un ensemble de données avec une petite quantité d'échantillons. L'ensemble de données comprend les
données open source sur les prix des logements à Boston fournies par scikitlearn. Le projet de prévision des prix des logements
de Boston est un modèle de régression simple. En utilisant ce modèle, vous pouvez comprendre l'utilisation de base et les méthodes
de traitement des données de la bibliothèque d'apprentissage automatique sklearn.
6.1.2 Objectifs
Utilisez l'ensemble de données sur les prix des logements de Boston ouvert sur Internet comme données d'entrée du modèle.
Construire, former et évaluer des modèles d'apprentissage automatique
Comprendre le processus global de création d'un modèle d'apprentissage automatique.
Maîtriser l'application de la formation de modèles d'apprentissage automatique, de la recherche de grille et des
indicateurs d'évaluation.
Maîtriser l'application des API associées.
6.1.3 Ensemble de données et cadre d'expérience
Cette expérience est basée sur l'ensemble de données sur le prix des logements à Boston, qui contient 506 échantillons avec
13 caractéristiques. Chaque enregistrement de données contient des informations détaillées sur la maison et ses environs. Pour
être précis, l'ensemble de données comprend les fonctionnalités suivantes :
CRIM : taux de criminalité par habitant et par ville
ZN : proportion de terrains résidentiels zonés pour les terrains de plus de 25 000 pi2
INDUS : proportion d'acres d'activités non commerciales par commune
CHAS : variable fictive Charles River (= 1 si le secteur délimite la rivière ; 0 sinon)
NOX : Concentration d'oxyde nitrique
RM : nombre moyen de pièces par logement
AGE : proportion de logements occupés par leur propriétaire construits avant 1940
DIS : distances pondérées vers cinq centres d'emploi de Boston
RAD : indice d'accessibilité aux autoroutes radiales
TAXE : taux de la taxe foncière sur la valeur totale par tranche de 10 000 $
PTRATIO : ratio élèvesenseignant par commune
B : 1000(Bk – 0.63)^2 où Bk est la proportion de Noirs par commune
LSTAT : % de statut inférieur de la population L'objectif est d'obtenir la valeur
médiane des logements occupés par leur propriétaire dans l'unité de 1000 $.
Le cadre sklearn est utilisé pour fournir les données sur les prix des logements à Boston et des fonctions
telles que le fractionnement, la normalisation et l'évaluation des ensembles de données, et intégrer divers
algorithmes d'apprentissage automatique courants. De plus, XGBoost optimisé à partir de l'arbre de
décision boosté par gradient (GBDT) est utilisé comme algorithme intégral.
6.2 Procédure
6.2.1 Présentation de la dépendance
Code:
# Empêcher les avertissements inutiles.
avertissements d'importation
warnings.filterwarnings("ignorer")
#Introduisez le package de base de la science des
données. importer numpy en tant que np importer matplotlib
en tant que mpl importer matplotlib.pyplot en tant que plt
importer pandas en tant que pd importer scipy.stats en
tant que st importer seaborn en tant que sns ##Définir des
attributs pour éviter les caractères brouillés en chinois.
mpl.rcParams['font.sansserif'] = [u'SimHei']
mpl.rcParams['axes.unicode_minus'] = Faux
#Introduisez l'apprentissage automatique, le prétraitement, la sélection de modèles et les indicateurs d'évaluation.
de sklearn.preprocessing importer StandardScaler de sklearn.model_selection importer train_test_split de
sklearn.model_selection importer GridSearchCV de sklearn.metrics importer r2_score
#Importez le jeu de données Boston utilisé cette fois. à
partir de sklearn.datasets importer load_boston
#Introduire des algorithmes.
from sklearn.linear_model import RidgeCV, LassoCV, LinearRegression, ElasticNet #Comparé à SVC,
c'est la forme de régression de SVM. à partir de sklearn.svm, importez les algorithmes SVR #Integrate.
de sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor de xgboost import
XGBRegressor
6.2.2 Chargement de l'ensemble de données, affichage des attributs de données et
visualisation des données
Étape 1 Chargez l'ensemble de données sur le prix des logements à Boston et affichez les attributs associés.
Code:
#Charger l'ensemble de données sur les prix des logements
à Boston. boston = load_boston()
#x caractéristiques et y
étiquettes. x = boston.données
y = boston.cible
#Afficher les attributs associés.
print('Feature column name')
print(boston.feature_names)
print("Exemple de volume de données : %d, nombre d'éléments : %d"% x.shape)
print("Objectif de volume de données : %d"% y. forme[0])
Production:
Noms des colonnes de fonctionnalités : ['CRIM' 'ZN' 'INDUS' 'CHAS' 'NOX' RM' 'AGE' DIS' 'RAD' 'TAX' PTRATIO' 'B'
'LSTAT'], quantité d'échantillons : 506, quantité de fonctionnalités : 13, quantité d'échantillons cible : 506
Étape 2 Convertir les données au format de trame de données
Code:
x = pd.DataFrame(boston.data, columns=boston.feature_names) x.head()
Production:
Figure 61 Informations sur les cinq premiers échantillons
Étape 3 Visualisez la distribution des étiquettes.
Code:
sns.distplot(tuple(y), kde=False, fit=st.norm)
Production:
Figure 62 Répartition des données cible
Fin
6.2.3 Fractionnement et prétraitement de l'ensemble de données
Code:
#Segmentez les données.
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=28)
#Standardiser le jeu de données.
ss = StandardScaler()
x_train = ss.fit_transform(x_train)
x_test = ss.transform(x_test)
x_train[0:100]
Production:
Tableaux : ([–0,35451414, –0,49503678, –0,15692398, ..., –0,01188637, 0,42050162, –0,29153411], [–
0,38886418, 0,49503678, 0,02431196, ..., 0,35398749, 0,37314392, 0,97290358], [0,50315442,
0,49503678, 1,03804143, ..., 0,81132983, 0,4391143, 1,18523567], ..., [–0,34444751, –0,49503678, –
0.15692398, ..., –0.01188637, 0.4391143, –1.11086682], [–0.39513036, 2.80452783, –0.87827504, ..., 0.35398749, 0.4391143, –
1.28120919], [–0.38081287, 0.41234349, –0.74566303, ..., 0.30825326 , 0,19472652, –0,40978832]])
6.2.4 Exécution de la modélisation sur l'ensemble de données à l'aide de divers
modèles de régression
Code:
#Définissez le nom du modèle.
noms = ['LinerRegression',
'Crête',
'Lasso',
'forêt aléatoire',
'GBDT',
'Régression vectorielle de support',
'ElasticNet',
'XgBoost']
#Définir le modèle. # cv
est l'idée de validation croisée ici. modèles =
[RégressionLinéaire(),
RidgeCV(alphas=(0.001,0.1,1),cv=3),
LassoCV(alphas=(0.001,0.1,1),cv=5),
RandomForestRegressor(n_estimators=10),
GradientBoostingRegressor(n_estimators=30), SVR( ),
ElasticNet(alpha=0.001,max_iter=10000), XGBRegressor()]
# Générez les scores R2 de tous les modèles de régression.
#Définir la fonction de notation R2. def
R2(modèle,x_train, x_test, y_train, y_test):
model_fitted = model.fit(x_train,y_train) y_pred =
model_fitted.predict(x_test) score = r2_score(y_test,
y_pred) score de retour
#Traverse tous les modèles pour
marquer. for name,model in zip(names,models):
score = R2(model,x_train, x_test, y_train, y_test) print("{}:
{:.6f}, {:.4f}".format(name,score .mean(),score.std()))
Production:
6.2.5 Réglage des hyperparamètres de recherche de grille
Étape 1 Construire un modèle.
Code:
'''
'noyau' : fonction du noyau
'C' : facteur de régularisation SVR
'gamma' : coefficient de la fonction noyau 'rbf', 'poly' et 'sigmoïde', qui affecte les performances du modèle
'''
paramètres =
{ 'kernel' : ['linear', 'rbf'],
'C' : [0.1, 0.5,0.9,1,5],
'gamma' : [0.001,0.01,0.1,1]
}
#Utilisez la recherche par grille et effectuez une
validation croisée. modèle = GridSearchCV(SVR(), param_grid=paramètres,
cv=3) model.fit(x_train, y_train)
Production:
Étape 2 Obtenez les paramètres optimaux.
Code:
print("Liste des paramètres optimaux :", model.best_params_)
print("Modèle optimal :", model.best_estimator_) print("Valeur
R2 optimale :", model.best_score_)
Production:
Liste de paramètres optimale : {'C' : 5, 'gamma' : 0,1, 'kernel' : 'rbf'}
Modèle optimal : SVR(C=5, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma=0.1, kernel='rbf',
max_iter=1, shrinking=True, tol=0.001, verbose= Faux)
Valeur R2 optimale : 0,797481706635164
Étape 3 Visualisez la sortie.
Code:
##Effectuer une visualisation.
ln_x_test = range(len(x_test))
y_predict = model.predict(x_test)
#Définissez la toile.
plt.figure(figsize=(16,8), facecolor='w')
#Dessiner avec une ligne continue
rouge. plt.plot (ln_x_test, y_test, 'r', lw=2, label=u'Valeur')
#Dessiner avec une ligne continue
verte. plt.plot (ln_x_test, y_predict, 'g', lw = 3, label=u'Valeur estimée de l'algorithme SVR, $R^2$=%.3f' %
(model.best_score_))
#Afficher dans un schéma.
plt.legend(loc ='en haut à
gauche') plt.grid(True)
plt.title(u"Boston Housing Price Forecast (SVM)")
plt.xlim(0, 101)
plt.show()
Production:
Figure 63 Résultat visualisé
Fin
sept
Groupe d'utilisateurs du site Web de commerce électronique
Une analyse
7.1 Présentation
k
Cette expérience effectue une modélisation basée sur l'algorithme
means en utilisant le jeu de données
virtuel généré automatiquement par sklearn pour obtenir des catégories d'utilisateurs. Il s'agit d'une expérience
k de
de regroupement, qui permet de découvrir la méthode de sélection de la valeur optimale et
md'observer
anière visualisée.
l'effet
7.2 Code d'expérience
7.2.1 Utilisation de sklearn pour la modélisation
Étape 1 Importez les bibliothèques.
importer numpy en tant que np
Étape 2 Créez un jeu de données.
Créez des données virtuelles pour le modèle d'algorithme.
à partir de sklearn.datasets importer make_blobs
X, y = make_blobs(n_samples=2000,centers=2,n_features=2)
L'outil intégré de sklearn est utilisé pour créer les données virtuelles, qui sont scientifiques et conformes à une
distribution normale. Les réglages des paramètres sont les suivants :
n_samples : défini sur 2 000, indiquant que 2 000 points d'échantillonnage sont définis.
centres : défini sur 2, indiquant que les données ont en fait deux centres.
n_features : défini sur 2, indiquant le nombre de fonctionnalités.
Pour faciliter l'illustration dans le système de coordonnées, seules deux entités sont utilisées.
Étape 3 Appliquer le k signifie algorithme.
depuis sklearn.cluster importer KMeans
y_pred = KMeans(n_clusters=5).fit_predict(X)
n_clusters=5 : indique que cinq clusters de données sont attendus. Cependant, il n'y a que deux catégories de
données.
Étape 4 Visualisez la sortie.
plt.figure(figsize=(10,10))
plt.scatter(X[:, 0], X[:, 1])
plt.figure(figsize=(10,10))
plt.scatter(X[:, 0], X[:, 1],c=y_pred)
Production:
Des données différentes sont générées à chaque fois. Par conséquent, le diagramme de sortie peut être
différent de celui du laboratoire. Pour générer les mêmes données, ajoutez le paramètre random_state lors de
la génération des données.
X, y = make_blobs(n_samples=2000,centers=2,n_features=2,random_state=3)
Dans cet exemple, random_state est défini sur 3. De cette manière, les mêmes données peuvent être générées pour la
même entrée de données.
Étape 5 Utilisez plus de fonctionnalités pour la comparaison.
X, y = make_blobs(n_samples=2000,centers=3,n_features=10,random_state=30)
Dans cet exemple, dix fonctionnalités sont utilisées pour générer des données, random_state est défini sur 30 et il existe
trois catégories en théorie.
y_pred = KMeans(n_clusters=5).fit_predict(X)
plt.figure(figsize=(10,10)) plt.subplot(121)
plt.scatter(X[:, 0], X[:, 1]) plt .subplot(122)
plt.scatter(X[:, 0], X[:, 1],c=y_pred)
Fin
7.2.2 Sélection de la valeur optimale de k
Dans les étapes précédentes, kla valeur est définie manuellement. Dans les environnements réels,
le nombre de centres est inconnu. Il faut donc trouver le meilleur k évaluer.
importer au hasard
centres=random.randint(1,30)
n_features=random.randint(1,30)
X, y = make_blobs(n_samples=2000,centers=centers,n_features=n_features)
Tout d'abord, générez deux nombres aléatoires allant de 1 à 30 (indiquant que le nombre de vrais
centres dans les données est inconnu) et utilisez un nombre aléatoire d'entités.
temp=[]
pour je dans la plage (1,50):
modèle=KMeans(n_clusters=i)
model.fit(X)
temp.append(model.inertia_)
Ensuite, perform k signifie le regroupement en utilisant une méthode récursive. L'attribut .inertia_
renvoie la distance entre le point d'attribut et le centre.
plt.figure(1 , figsize = (15 ,6))
plt.plot(np.arange(1 , 50) , temp , 'o')
''
plt.plot(np.arange(1 , 50) , temp , , alpha = 0.5)
plt.xlabel('Nombre de clusters') , plt.ylabel('Inertie')
plt.show()
Visualisez le résultat à l'aide d'un outil de visualisation.
Le résultat varie à chaque fois en raison de l'impact des nombres aléatoires. Comme le montre la
figure précédente, le point tournant apparaît à la position correspondant à la valeur 21.
Donc 21 est la valeur optimale k évaluer.

3 Machine Learning Lab Guide-Teacher Version

Transféré par

Droits d'auteur :

Formats disponibles

3 Machine Learning Lab Guide-Teacher Version

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

3 Machine Learning Lab Guide-Teacher Version

Transféré par

Droits d'auteur :

Formats disponibles

Machine Translated by Google

du passager Pclass : classe de cabine (classe 1/2/3) Name : nom du passager Sex : genre Age : âge

Vous aimerez peut-être aussi