[PYTHON] Apprentissage supervisé de mnist dans la couche entièrement connectée, clustering et évaluation de l'étape finale

Apprentissage supervisé de mnist dans la couche entièrement connectée, clustering et évaluation de l'étape finale

#Importer les bibliothèques requises
import keras
from keras.datasets import mnist

import numpy as np
import pandas as pd
import sklearn
#Afficher les résultats du tracé dans le notebook lors de l'utilisation du notebook Jupyter
import matplotlib.pyplot as plt
%matplotlib inline
Using TensorFlow backend.
feature_dims = range(2, 12)
#Lire les données avec la fonction Keras. Mélangez les données et divisez-les en données d'entraînement et données d'entraînement
(x_train, y_train), (x_test, y_test) = mnist.load_data()

#Convertir les données 2D en valeur numérique
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
#Conversion de type
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
#Diviser par 255 comme nouvelle variable
x_train /= 255
x_test /= 255

# one-Méthode d'encodage à chaud
from keras.utils.np_utils import to_categorical
#10 cours
num_classes = 10
y_train = y_train.astype('int32')
y_test = y_test.astype('int32')
labels = y_test
# one-hot encoding
y_train = to_categorical(y_train, num_classes)
y_test =  to_categorical(y_test, num_classes)
def fitting(feature_dim, x_train, y_train, x_test, y_test):
    #Utilisez Adam pour importer et optimiser les bibliothèques requises
    from keras.models import Sequential
    from keras.layers import Dense, Dropout
    from keras.optimizers import Adam
    import gc

    #La modélisation
    model = Sequential()
    model.add(Dense(512, activation='relu', input_shape=(784,)))
    model.add(Dropout(0.2))
    model.add(Dense(512, activation='relu'))
    model.add(Dropout(0.2))
    model.add(Dense(feature_dim, activation='relu'))  #Ajout d'une couche à retirer en tant que quantité d'entités
    model.add(Dense(10, activation='softmax'))

    model.summary()

    #Taille du lot, nombre d'époques
    batch_size = 128
    epochs = 20

    model.compile(loss='categorical_crossentropy',
                optimizer=Adam(),
                metrics=['accuracy'])
    history = model.fit(x_train, y_train,
                        batch_size=batch_size,
                        epochs=epochs,
                        verbose=1,
                        validation_data=(x_test, y_test))
    score = model.evaluate(x_test, y_test, verbose=0)
    print('Test loss:', score[0])
    print('Test accuracy:', score[1])

#    #Accuracy
#    print(history.history.keys())
#    plt.plot(history.history['accuracy'])
#    plt.plot(history.history['val_accuracy'])
#    plt.title('model accuracy')
#    plt.ylabel('accuracy')
#    plt.xlabel('epoch')
#    plt.legend(['train', 'test'], loc='upper left')
#    plt.show()
#    #loss
#    plt.plot(history.history['loss'])
#    plt.plot(history.history['val_loss'])
#    plt.title('model loss')
#    plt.ylabel('loss')
#    plt.xlabel('epoch')
#    plt.legend(['train', 'test'], loc='upper left')
#    plt.show()
    model.pop() #Supprimez la couche softmax à l'étape finale et utilisez la couche d'entités comme étape finale.
    model.summary()
    result = model.predict(x_test)
    keras.backend.clear_session() #← C'est
    gc.collect()
    from IPython.display import clear_output
    clear_output()
    return (history, model, result)
#model = fitting(10, x_train, y_train, x_test, y_test)
models = [None] * len(feature_dims)
histories = [None] * len(feature_dims)
results = [None] * len(feature_dims)
for i in range(len(feature_dims)):
    (histories[i], models[i], results[i]) = fitting(feature_dims[i], x_train, y_train, x_test, y_test)
#model.save('model/mnist-10')
#model = keras.models.load_model('model/mnist-10')
#for i in range(len(feature_dims)):
#    models[i].pop() #Supprimez la couche softmax à l'étape finale et utilisez la couche d'entités comme étape finale.
#    models[i].summary()
#result = model.predict(x_test)
#results = [None] * len(feature_dims)
#for i in range(len(feature_dims)):
#    keras.backend.clear_session()
#    results[i] = models[i].predict(x_test)
def tsne(result):
    #t-Réduction de dimension avec SNE
    from sklearn.manifold import TSNE
    tsne = TSNE(n_components=2, random_state = 0, perplexity = 30, n_iter = 1000)
    return tsne.fit_transform(result)
#tsne = tsne(result)
tsnes = [None] * len(feature_dims)
for i in range(len(feature_dims)):
    tsnes[i] = tsne(results[i])
#df = pd.DataFrame(tsne, columns = ['x', 'y'])
#df['label'] = labels
def km(n_clusters, result):
    # k-Cluster au moyen
    from sklearn.cluster import KMeans
    return KMeans(n_clusters).fit_predict(result)
#km = km(10, result)
#df['km'] = km
kms = [None] * len(feature_dims)
for i in range(len(feature_dims)):
    kms[i] = km(10, results[i])
def DBSCAN(n_clusters, result):
    from sklearn.cluster import DBSCAN
    db = DBSCAN(eps=0.2, min_samples=n_clusters).fit(result)
    return db.labels_
#dbscan = DBSCAN(20, result)
#df['DBSCAN'] = dbscan
def hierarchy(result):
    from scipy.cluster.hierarchy import linkage, dendrogram
    result1 = linkage(result, 
                  metric = 'braycurtis', 
                  #metric = 'canberra', 
                  #metric = 'chebyshev', 
                  #metric = 'cityblock', 
                  #metric = 'correlation', 
                  #metric = 'cosine', 
                  #metric = 'euclidean', 
                  #metric = 'hamming', 
                  #metric = 'jaccard', 
                  #method= 'single')
                  method = 'average')
                  #method= 'complete')
                  #method='weighted')
    return result1
#hierarchy = hierarchy(result)
#display(hierarchy)
#def cluster_visualization(x, y, label, cluster, method, n_clusters):
def cluster_visualization(x, y, label, cluster):
    plt.figure(figsize = (30, 15))
    plt.subplot(1,2,1)
    plt.scatter(x, y, c=label)
#    for i in range(10):
#        tmp_df = df[df['label'] == i]
#        plt.scatter(tmp_df['x'], tmp_df['y'], label=i)
#    plt.legend(loc='upper left', bbox_to_anchor=(1,1))
    plt.subplot(1,2,2)
    plt.scatter(x, y, c=cluster)
#    for i in range(n_clusters):
#        tmp_df = df[df[method] == i]
#        plt.scatter(tmp_df['x'], tmp_df['y'], label=i)
#    plt.legend(loc='upper left', bbox_to_anchor=(1,1))
for i in range(len(feature_dims)):
    cluster_visualization(tsnes[i][:,0], tsnes[i][:,1], labels, kms[i])

output_17_0.png

output_17_1.png

output_17_2.png

output_17_3.png

output_17_4.png

output_17_5.png

output_17_6.png

output_17_7.png

output_17_8.png

output_17_9.png

# https://qiita.com/mamika311/items/75c24f6892f85593f7e7
from sklearn.metrics.cluster import adjusted_rand_score
for i in range(len(feature_dims)):
    print("dim:" + str(feature_dims[i]) + " RMI: " + str(adjusted_rand_score(labels, kms[i])))
dim:2 RMI: 0.36573507862590254
dim:3 RMI: 0.49974179932107105
dim:4 RMI: 0.6248257814760337
dim:5 RMI: 0.8225287029746797
dim:6 RMI: 0.8495039832620757
dim:7 RMI: 0.8417680081349097
dim:8 RMI: 0.8423268187793562
dim:9 RMI: 0.8450473012143238
dim:10 RMI: 0.836035505993697
dim:11 RMI: 0.8815919206871302
# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.normalized_mutual_info_score.html
# https://qiita.com/kotap15/items/38289edfe822005e1e44
from sklearn.metrics import normalized_mutual_info_score
#display(normalized_mutual_info_score(labels, df['km']))
for i in range(len(feature_dims)):
    print("dim:" + str(feature_dims[i]) + " NMI: " + str(normalized_mutual_info_score(labels, kms[i])))
dim:2 NMI: 0.5759443563915843
dim:3 NMI: 0.6735454178249051
dim:4 NMI: 0.7745736983918213
dim:5 NMI: 0.8626814016489588
dim:6 NMI: 0.8759626968874756
dim:7 NMI: 0.8766399602087444
dim:8 NMI: 0.8830520742914061
dim:9 NMI: 0.8706715369843739
dim:10 NMI: 0.8721342625213994
dim:11 NMI: 0.8992713472017846
def shilhouette(clusters, x_test):
    from sklearn.metrics import silhouette_samples
    from matplotlib import cm
    plt.figure(figsize = (10, 10))
    cluster_labels=np.unique(clusters)
    n_clusters=cluster_labels.shape[0]
    silhouette_vals=silhouette_samples(x_test,clusters,metric='euclidean')
    y_ax_lower,y_ax_upper=0,0
    yticks=[]
    for i,c in enumerate(cluster_labels):
        c_silhouette_vals=silhouette_vals[clusters==c]
        print(len(c_silhouette_vals))
        c_silhouette_vals.sort()
        y_ax_upper +=len(c_silhouette_vals)
        color=cm.jet(float(i)/n_clusters)
        plt.barh(range(y_ax_lower,y_ax_upper),
                c_silhouette_vals,
                height=1.0,
                edgecolor='none',
                color=color
                )
        yticks.append((y_ax_lower+y_ax_upper)/2.)
        y_ax_lower += len(c_silhouette_vals)

    #Si le coefficient de silhouette est 1, vous pouvez bien regrouper.
    #De plus, lorsque la largeur de la silhouette est égale en moyenne en termes de nombre de clusters, cela indique que l'ensemble des données peut être divisé également.
    #Cette largeur de division=Une méthode de réglage possible consiste à optimiser k de sorte que les largeurs des barres de silhouette soient égales et que le coefficient de silhouette se rapproche de 1..

    #Tracez une ligne à la position moyenne
    silhouette_avg=np.mean(silhouette_vals)
    plt.axvline(silhouette_avg,color="red",linestyle="--")
    plt.ylabel("Cluster")
    plt.xlabel("Silhouette coefficient")
for i in range(len(feature_dims)):
    shilhouette(kms[i], x_test)
1228
2862
388
406
760
398
304
1653
1194
807
1350
1053
620
969
1312
1081
1720
544
270
1081
633
753
2140
711
320
786
926
1060
888
1783
1076
842
998
740
938
1022
861
1265
1425
833
855
850
884
858
1007
1118
979
911
1180
1358
1132
860
936
962
923
835
844
1533
974
1001
891
784
1096
892
1040
910
1562
914
904
1007
890
947
1127
710
1018
902
960
902
1178
1366
1189
1002
1538
903
947
918
925
771
927
880
1133
914
923
950
986
890
954
1023
816
1411

output_21_1.png

output_21_2.png

output_21_3.png

output_21_4.png

output_21_5.png

output_21_6.png

output_21_7.png

output_21_8.png

output_21_9.png

output_21_10.png

Recommended Posts

Apprentissage supervisé de mnist dans la couche entièrement connectée, clustering et évaluation de l'étape finale
Apprenez mnist non supervisé avec l'encodeur automatique et le cluster et évaluez les variables latentes
Apprentissage non supervisé de mnist avec encodeur automatique variationnel, clustering et évaluation des variables latentes
Extraire la couleur de l'objet dans l'image avec le clustering Mask R-CNN et K-Means
Visualisation de l'état de tir de la couche cachée du modèle appris dans le tutoriel TensorFlow MNIST
Comptez le nombre de paramètres dans le modèle d'apprentissage en profondeur
À propos des tests dans la mise en œuvre de modèles d'apprentissage automatique