[Apprentissage automatique] Apprentissage supervisé utilisant l'estimation de la densité du noyau Partie 2

Apprentissage supervisé utilisant l'estimation de la densité du noyau

Cet article est écrit par des débutants en apprentissage automatique. Notez s'il vous plaît.

L'article précédent était ici. Le prochain article est ici.

Relation entre l'estimation de la densité du noyau et l'apprentissage supervisé

Je l'ai associé sans autorisation. Pour plus d'informations (pas très détaillées), veuillez vous référer à l'article précédent (https://qiita.com/sorax/items/8663906fae41798a00b8). Le résumé simple est "J'ai essayé d'utiliser l'estimation de la densité du noyau comme classificateur pour l'apprentissage supervisé!".

Orientation objet

J'ai modifié le script résumé dans Article précédent pour le rendre orienté objet. Le nom est "classificateur d'estimation de densité de noyau gaussien", ou "classificateur GKDE" pour faire court. Je viens de le nommer arbitrairement.

↓ Script ↓

import numpy as np

class GKDEClassifier(object):
    
    def __init__(self, bw_method="scotts_factor", weights="None"):
 # Bande passante du noyau
        self.bw_method = bw_method
 # Poids du noyau
        self.weights = weights
        
    def fit(self, X, y):
 Nombre d'étiquettes pour # y
        self.y_num = len(np.unique(y))
 # Liste contenant les fonctions de densité de probabilité estimée
        self.kernel_ = []
 # Stocker la fonction de densité de probabilité
        for i in range(self.y_num):
            kernel = gaussian_kde(X[y==i].T)
            self.kernel_.append(kernel)
        return self

    def predict(self, X):
 # Liste pour stocker les étiquettes prédictives
        pred = []
 #List qui stocke les probabilités par libellé des données de test
        self.p_ = []
 # Stocker la probabilité par étiquette
        for i in range(self.y_num):
            self.p_.append(self.kernel_[i].evaluate(X.T).tolist())
 # ndarray
        self.p_ = np.array(self.p_)
 # Allocation d'étiquettes de prédiction
        for j in range(self.p_.shape[1]):
            pred.append(np.argmax(self.p_.T[j]))
        return pred

Attribuez des étiquettes dans l'ordre 0, 1, 2 ... (dans l'ordre croissant des entiers non négatifs). Peut-être: LabelEncoder

(Ajouté le 05/08/2020: Partie 3 a publié le code modifié)

Méthode \ _ \ _ Init \ _ \ _

Initialise l'objet. Ici, spécifiez les paramètres requis pour l'estimation de la densité du noyau, c'est-à-dire les arguments requis pour l'initialisation de gaussian_kde de SciPy. Cette fois, j'ai défini la même valeur que la valeur par défaut de gaussian_kde.

méthode d'ajustement

L'apprentissage est effectué à l'aide des données des enseignants. Après avoir estimé la densité du noyau avec gaussian_kde, la fonction de densité estimée de l'étiquette 0, la fonction de densité estimée de l'étiquette 1, etc. sont stockées dans l'ordre.

prédire la méthode

Prédire les données de test.

for i in range(self.y_num):
            self.p_.append(self.kernel_[i].evaluate(X.T).tolist())

Ici, les fonctions de densité estimée sont extraites une par une du noyau_ et la densité de probabilité des données de test est calculée.

Les scripts suivants sont foirés. Je voulais l'écrire de manière plus concise, mais il ne s'est pas comporté comme je m'y attendais ... Il y a un débutant en codage. Juste bouge. Il vaut mieux bouger.

C'est pourquoi le classificateur d'estimation de la densité du noyau gaussien orienté objet est complet.

jeu de données sur le vin

Combinaison avec PCA

Le jeu de données sur le vin a 13 fonctionnalités, mais après normalisation, il sera réduit à 4 dimensions. Apprenons et classifions avec les données après réduction de dimension.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# Charger le jeu de données
wine = datasets.load_wine()
X = wine.data
y = wine.target

# Répartition des données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=1, stratify=y)

# Standardisation
sc = StandardScaler()
sc = sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)

# Réduction de dimension
pca = PCA(n_components=4)
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)

# Apprentissage et prédiction
f = GKDEClassifier()
f.fit(X_train_pca, y_train)
y_pred = f.predict(X_test_pca)

Le résultat est ……?

from sklearn.metrics import accuracy_score

print(accuracy_score(y_test, y_pred))
 0.9722222222222222

Hourra. Puisqu'il y a 36 données de test, le taux de réponse correct est de 35/36. C'est plutôt bon.

Aucune réduction de dimension

Que va-t-il se passer?

# Apprentissage et prédiction
f = GKDEClassifier()
f.fit(X_train_std, y_train)
y_pred = f.predict(X_test_std)

print(accuracy_score(y_test, y_pred))
 0.9722222222222222

Résultat: le même.

Ensemble de données circulaire

J'ai créé un ensemble de données circulaire.

from sklearn.datasets import make_circles
from matplotlib import pyplot as plt

X, y = make_circles(n_samples=1000, random_state=1, noise=0.1, factor=0.2)
plt.scatter(X[y==0, 0], X[y==0, 1], c="red", marker="^", alpha=0.5)
plt.scatter(X[y==1, 0], X[y==1, 1], c="blue", marker="o", alpha=0.5)
plt.show()

L'étiquette est différente au centre et sur le bord extérieur. Pouvez-vous le classer correctement?

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=1, stratify=y)

f = GKDEClassifier()
f.fit(X_train, y_train)
y_pred = f.predict(X_test)

print(accuracy_score(y_test, y_pred))
 0.9933333333333333

Conclusion: grande victoire.

finalement

Il a été si bien catégorisé, mais j'ai oublié ce qui est important. Telle est la justesse académique de cette méthode de classification. La prochaine fois, j'en discuterai.

Suite sur Partie 3