Effectuer (Visualisation> Clustering> Description des fonctionnalités) avec (t-SNE, DBSCAN, Arbre de décision)

Résumé

Je l'ai essayé avec l'idée. En fait, je n'ai pas compris comment cela peut être appliqué.

Essayez-le avec load_boston de sklearn

Importez d'abord ce dont vous avez besoin

import numpy as np
from sklearn import datasets
from sklearn.manifold import TSNE
from matplotlib import pyplot as plt

Chargez boston et essayez de le visualiser avec TSNE Voir visuellement certains clusters apparaître

boston = datasets.load_boston()
model = TSNE(n_components=2)
tsne_result = model.fit_transform(boston.data) 
plt.plot(tsne_result[:,0], tsne_result[:,1], ".")

boston_tsne.png

Essayez de regrouper avec kmeans une fois pour comparaison

from sklearn.cluster import MiniBatchKMeans
#Nombre de clusters`n_clusters`Regardé le graphique TSNE et décidé en sentant
kmeans = MiniBatchKMeans(n_clusters=10, max_iter=300)
kmeans_tsne = kmeans.fit_predict(tsne_result)

#Colorez-le bien
color=cm.brg(np.linspace(0,1,np.max(kmeans_tsne) - np.min(kmeans_tsne)+1))
for i in range(np.min(kmeans_tsne), np.max(kmeans_tsne)+1):
    plt.plot(tsne_result[kmeans_tsne == i][:,0],
             tsne_result[kmeans_tsne == i][:,1],
             ".",
             color=color[i]
             )
    plt.text(tsne_result[kmeans_tsne == i][:,0][0],
             tsne_result[kmeans_tsne == i][:,1][0],
             str(i), color="black", size=16
             )

Les clusters (1,5), (2,8) et (4,7,9) sont séparés, mais structurellement connectés, ce qui n'est pas très souhaitable (pour moi). boston_tsne_kmeans.png

Essayez le clustering avec DBSCAN

from sklearn.cluster import DBSCAN
# `eps`Est le résultat d'essais et d'erreurs
dbscan = DBSCAN(eps=3)
dbscan_tsne = dbscan.fit_predict(tsne_result)

#Colorez-le bien
color=cm.brg(np.linspace(0,1,np.max(dbscan_tsne) - np.min(dbscan_tsne)+1))
for i in range(np.min(dbscan_tsne), np.max(dbscan_tsne)+1):
    plt.plot(tsne_result[dbscan_tsne == i][:,0],
             tsne_result[dbscan_tsne == i][:,1],
             ".",
             color=color[i+1]
             )
    plt.text(tsne_result[dbscan_tsne == i][:,0][0],
             tsne_result[dbscan_tsne == i][:,1][0],
             str(i), color="black", size=16
             )

Dans DBSCAN, c'est souhaitable car les îlots connectés sont dans le même cluster. (-1 est un cluster qui contient des éléments dans le désordre)

boston_tsne_dbscan.png

De plus, générez un arbre de décision et essayez de bien expliquer chaque cluster.

from sklearn import tree
clf = tree.DecisionTreeClassifier()
#dbscan-Le libellé est dû au fait qu'un cluster est généré-À partir de 1
clf.classes_ = np.max(dbscan_tsne) - np.min(dbscan_tsne) + 1
clf.fit(boston.data, dbscan_tsne)

#Générer un fichier de points pour graphviz
with open("boston_tsne_dt.dot", 'w') as f:
    tree.export_graphviz(
        clf,
        out_file=f,
        feature_names=boston.feature_names,
        filled=True,
        rounded=True,  
        special_characters=True,
        impurity=False,
        proportion=False,
        class_names=map(str, range(-1, np.max(dbscan_tsne) - np.min(dbscan_tsne)+1))
    )
dot -T png boston_tsne_dt.dot > boston_tsne_dt.png

Le résultat est illustré dans la figure ci-dessous.

boston_tsne_dt.png

Pour référence, dessinez l'objectif (prix du logement) de chaque grappe.

plt.boxplot([boston.target[dbscan_tsne == i]
             for i in range(np.min(dbscan_tsne), 
                            np.max(dbscan_tsne)+1)],
            labels=range(np.min(dbscan_tsne), 
                         np.max(dbscan_tsne)+1)
            )

boston_tsne_price.png

Considération

Pour résumer ce qui m'intéressait,

Cependant, quand il s'agit de fournir des informations avec cela, je me sens assez méfiant. Au fait, même si vous mélangez boston.target avec les données d'origine, le résultat sera assez proche.

Recommended Posts

Effectuer (Visualisation> Clustering> Description des fonctionnalités) avec (t-SNE, DBSCAN, Arbre de décision)
DBSCAN (clustering) avec scikit-learn
Créer un arbre déterminé avec scikit-learn
Segmentation et regroupement de photos avec DBSCAN