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

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)

## 5. Classification des prédictions Maintenant que le modèle est complet, nous prédisons d'abord la probabilité de classification.
#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.

\sigma(z)=\frac{1}{1+\exp(-z)}

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.

L(w)=y\log(p(x,w))+(1-y)\log(1-p(x,w))

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

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

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

Recommended Posts

Retour logistique (pour les débutants) -Code Edition-
Régression linéaire (pour les débutants) -Édition de code-
Ridge Return (pour les débutants) -Code Edition-
Arbre de décision (pour les débutants) -Édition de code-
[Kaggle pour les super débutants] Titanic (retour logistique)
Support Vector Machine (pour les débutants) -Code Edition-
Retour logistique
Retour logistique
Paramètres Spacemacs (pour les débutants)
Techniques de test de code?
Manuel python pour les débutants
Algorithme Dikstra pour les débutants
OpenCV pour les débutants en Python
Qu'est-ce que l'analyse de régression logistique?
[Pour les débutants] kaggle exercice (merucari)
Distribution Linux recommandée pour les débutants
Mémo de code personnel Python
Code de test pour évaluer les décorateurs
CNN (1) pour la classification des images (pour les débutants)
Construction de l'environnement Python3 (pour les débutants)
Vue d'ensemble de Docker (pour les débutants)
Python #function 2 pour les super débutants
Les bases de Seaborn pour les débutants ④ Pairplot
Grammaire de base Python pour les débutants
Apprendre avec l'enseignant (retour) 2 édition avancée
Pandas 100 coups pour les débutants en Python
[Python] Exemple de code pour la grammaire Python
Python #function 1 pour les super débutants
#List Python pour les super débutants
~ Conseils pour les débutants de Python présentés avec amour par Pythonista ③ ~
[Pour les débutants de Kaggle] Titanic (LightGBM)
Mémorandum de commande Linux [pour les débutants]
Raccourci Linux pratique (pour les débutants)
Algorithme d'apprentissage automatique (régression logistique)
Implémentation de la régression logistique avec NumPy
[Pour les débutants] Comment implémenter l'exemple de code O'reilly dans Google Colab