[PYTHON] Retour logistique (pour les débutants) -Code Edition-

Cette fois, nous résumerons la mise en œuvre de la régression logistique.

■ Procédure logistique

Nous allons procéder avec les 6 étapes suivantes.

1. Préparation du module
2. Préparation des données
3. Visualisation des données
4. Créez un modèle
5. Classification des prédictions
6. Évaluation du modèle
   

1. Préparation du module

Tout d'abord, importez les modules requis.

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

#Module de visualisation
import seaborn as sns

#Module pour lire le jeu de données
from sklearn.datasets import load_iris

#Module de normalisation (normalisation distribuée)
from sklearn.preprocessing import StandardScaler

#Module qui sépare les données d'entraînement et les données de test
from sklearn.model_selection import train_test_split

#Module pour effectuer une régression logistique
from sklearn.linear_model import LogisticRegression

#Module pour évaluer la classification
from sklearn.metrics import classification_report

#Modules qui gèrent les matrices de confusion
from sklearn.metrics import confusion_matrix

2. Préparation des données

Cette fois, nous utiliserons l'ensemble de données iris pour la classification binaire.

Commencez par récupérer les données, normalisez-les, puis divisez-les.

#Chargement du jeu de données iris
iris = load_iris()

#Diviser en variable objective et variable explicative
X, y = iris.data[:100, [0, 2]], iris.target[:100]

#Standardisation (normalisation distribuée)
std = StandardScaler()
X = std.fit_transform(X)

#Divisez en données d'entraînement et en données de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)

Afin d'effectuer une classification binaire, l'ensemble de données est spécifié jusqu'à la 100e ligne (Setosa / Versicolor uniquement). Nous avons également réduit les variables explicatives à deux pour faciliter le tracé. (Longueur sépale / Longueur pétale uniquement)

En normalisation, par exemple, lorsqu'il y a des quantités de caractéristiques à 2 et 4 chiffres (variables explicatives), l'influence de ces dernières devient grande. L'échelle est alignée en définissant la moyenne sur 0 et la variance sur 1 pour toutes les quantités d'entités.

Dans random_state, la valeur de départ est fixée de sorte que le résultat de la division des données soit le même à chaque fois.

3. Visualisation des données

Tracons les données avant la classification par régression logistique.

#Création d'objets de dessin et de sous-tracés
fig, ax = plt.subplots()

#Graphique de Setosa
ax.scatter(X_train[y_train == 0, 0], X_train[y_train == 0, 1], 
           marker = 'o', label = 'Setosa')

#Parcelle Versicolor
ax.scatter(X_train[y_train == 1, 0], X_train[y_train == 1, 1],
           marker = 'x', label = 'Versicolor')

#Paramètres d'étiquette d'axe
ax.set_xlabel('Sepal Length')
ax.set_ylabel('Petal Length')

#Paramètres de la légende
ax.legend(loc = 'best')

plt.show()

Tracé avec des entités correspondant à Setosa (y_train == 0) (0: Sepal Length sur l'axe horizontal, 1: Petal Length sur l'axe vertical) Tracé avec des entités (0: Sepal Lengh sur l'axe horizontal, 1: Petal Length sur l'axe vertical) correspondant à Versicolor (y_train == 1)

Résultat de sortie

4. Créez un modèle

Créez une fonction d'exécution de régression logistique (instance) et appliquez-la aux données d'entraînement.

#Créer une instance
logreg = LogisticRegression()

#Créer un modèle à partir des données d'entraînement
logreg.fit(X_train, y_train)

#Prédire la probabilité de classification
y_proba = logreg.predict_proba(X_test)[: , 1]
print(y_proba)

Résultat de sortie

y_proba: [0.02210131 0.99309888 0.95032727 0.04834431 0.99302674 0.04389388
 0.10540851 0.99718459 0.90218405 0.03983599 0.08000775 0.99280579
 0.99721384 0.78408501 0.08947531 0.01793823 0.99798469 0.01793823
 0.99429762 0.9920454 ]

La fonction sigmoïde génère un nombre compris entre 0 et 1. Plus il est proche de 0, plus la probabilité de Setosa est élevée, et plus elle est proche de 1, plus la probabilité de Versicolor est élevée.

Ensuite, prédisons le résultat de la classification.

#Prédire les résultats de la classification
y_pred = logreg.predict(X_test)
print(y_pred)

Résultat de sortie

y_pred: [0 1 1 0 1 0 0 1 1 0 0 1 1 1 0 0 1 0 1 1]

Appliquez la fonction d'erreur d'entropie croisée à la valeur sortie par la fonction sigmoïde plus tôt. Les valeurs proches de 0 sont classées comme 0: Setosa et les valeurs proches de 1 sont classées comme 1: Versicolor.

6. Évaluation du modèle

Cette fois, ce sera une classification (classification binaire), nous allons donc évaluer à l'aide d'une matrice de confusion.

#Créer une matrice de confusion
classes = [1, 0]
cm = confusion_matrix(y_test, y_pred, labels=classes)

#Trame de données
cmdf = pd.DataFrame(cm, index=classes, columns=classes)

#Tracez la matrice de confusion
sns.heatmap(cmdf, annot=True)

Résultat de sortie

Ensuite, recherchez la valeur numérique de l'indice d'évaluation.

#Affiche le taux de précision, le taux de rappel et la valeur F
print(classification_report(y_test, y_pred))

Résultat de sortie

À partir de ce qui précède, nous avons pu évaluer la classification à Setosa et Versicolor.

■ Enfin

En régression logistique, nous allons créer et évaluer un modèle basé sur les étapes 1 à 6 ci-dessus.

Cette fois, pour les débutants, je n'ai résumé que l'implémentation (code). En regardant le timing dans le futur, je voudrais écrire un article sur la théorie (formule mathématique).

Merci pour la lecture.