[PYTHON] Un débutant en apprentissage automatique a essayé la RBM

en premier...

Message de Qiita Beginner. C'est difficile à voir ... ou quelque chose comme ça, tout le monde peut le faire! S'il vous plaît, pardonnez-moi ... Jusqu'au dernier, il a été réalisé par M. Zero, qui n'a aucune connaissance de l'apprentissage automatique et de l'intelligence artificielle. (Au début, quelle était l'époque? Qu'est-ce que la précision? Ww)

Qu'est-ce que RBM

RBM(Restricted Boltzmann machine) C'est une sorte de méthode de pré-formation en Deep Learning, et c'est une sorte de modèle qui s'accorde parfaitement avec AutoEncoder, qui est souvent entendu. Le modèle a été inventé entre 1984 et 1986, dans l'espoir d'un avantage en mécanique statistique. Il est connu comme un modèle très pratique car il s'agit d'un modèle de génération qui permet des discussions sur une distribution de probabilité, contrairement à Autoencoder, qui reçoit des entrées et détermine la sortie de manière déterministe.

Deep Learning from RBM ~ With Black Magic ~

Je ne suis pas sûr ...

J'ai beaucoup cherché!

Alors ... Il y a quelque chose qui s'appelle BernoulliRBM dans scikit learn! je dois le faire

la mise en oeuvre

Pour le moment, exécutez-le avec un jeu de données appelé MNIST!

RBM.ipynb

import numpy as np
import matplotlib.pyplot as plt

from scipy.ndimage import convolve
from sklearn import linear_model, datasets, metrics
from sklearn.model_selection import train_test_split
from sklearn.neural_network import BernoulliRBM
from sklearn.pipeline import Pipeline
from sklearn.base import clone

#Ensemble de données utilisé
from keras.datasets import fashion_mnist
from keras.datasets import mnist

from keras.layers import Input, Dense
from keras.models import Model
from keras import layers, models

import time
import numpy

Pour le moment, l'importation ressemble à ce qui précède

Ensuite, faites comme indiqué dans l'exemple (de nombreuses pièces ne savent pas comment traiter)

RBM.ipynb

def nudge_dataset(X, Y):
    """
    This produces a dataset 5 times bigger than the original one,
    by moving the 8x8 images in X around by 1px to left, right, down, up
    """
    direction_vectors = [
        [[0, 1, 0],
         [0, 0, 0],
         [0, 0, 0]],

        [[0, 0, 0],
         [1, 0, 0],
         [0, 0, 0]],

        [[0, 0, 0],
         [0, 0, 1],
         [0, 0, 0]],

        [[0, 0, 0],
         [0, 0, 0],
         [0, 1, 0]]]

    def shift(x, w):
        return convolve(x.reshape((8, 8)), mode='constant', weights=w).ravel()

    X = np.concatenate([X] +
                       [np.apply_along_axis(shift, 1, X, vector)
                        for vector in direction_vectors])
    Y = np.concatenate([Y for _ in range(5)], axis=0)
    return X, Y


# Load Data
# (x_train, y_train), (x_test, y_test) = mnist.load_data()
# X, y = mnist.load_data()
# X = np.asarray(X, 'float32')
# X, Y = nudge_dataset(X, y)
# X = (X - np.min(X, 0)) / (np.max(X, 0) + 0.0001)  # 0-1 scaling

# X_train, X_test, Y_train, Y_test = train_test_split(
#     X, Y, test_size=0.2, random_state=0)

# (X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()

X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.
X_train = X_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
X_test = X_test.reshape((len(x_test), np.prod(x_test.shape[1:])))

# Models we will use
logistic = linear_model.LogisticRegression(solver='newton-cg', tol=1)
rbm = BernoulliRBM(random_state=0, verbose=True)

rbm_features_classifier = Pipeline(
    steps=[('rbm', rbm), ('logistic', logistic)])

# #############################################################################
# Training

# Hyper-parameters. These were set by cross-validation,
# using a GridSearchCV. Here we are not performing cross-validation to
# save time.
rbm.learning_rate = 0.06
rbm.n_iter = 10
# More components tend to give better prediction performance, but larger
# fitting time
rbm.n_components = 100
logistic.C = 6000

# Training RBM-Logistic Pipeline
rbm_features_classifier.fit(X_train, Y_train)

# Training the Logistic regression classifier directly on the pixel
raw_pixel_classifier = clone(logistic)
raw_pixel_classifier.C = 100.
raw_pixel_classifier.fit(X_train, Y_train)

# #############################################################################
# Evaluation

Y_pred = rbm_features_classifier.predict(X_test)
print("Logistic regression using RBM features:\n%s\n" % (
    metrics.classification_report(Y_test, Y_pred)))

Y_pred = raw_pixel_classifier.predict(X_test)
print("Logistic regression using raw pixel features:\n%s\n" % (
    metrics.classification_report(Y_test, Y_pred)))

Désolé pour le code source sale ... Je dois supprimer le commentaire ... C'est difficile d'écrire du beau code ...

J'utilise Bernoulli RBM de la bibliothèque sklearn. Dans cet exemple, nous construisons un pipeline de classification à l'aide de l'extracteur de fonctionnalités Bernoulli RBM et du classificateur de régression logistique. À titre de comparaison, nous présentons une régression logistique sur les valeurs brutes des pixels.

[Code source RBM (sklearn)](https://scikit-learn.org/stable/auto_examples/neural_networks/plot_rbm_logistic_classification.html#sphx-glr-auto-examples-neural-networks-plot-rbm-logistic-classification -py)

résultat

MNIST...Accuracy: 0.97 Fashion-MNIST...Accuracy: 0.79

Il faudra beaucoup de temps pour augmenter le nombre d'époques, alors réglez le nombre d'époques à 10 (pas de temps pour soumettre l'affectation ...)

Conclusion

J'ai essayé de copier et d'implémenter le code source, mais il a fallu beaucoup de temps pour le trouver ... Je dois comprendre plus! J'ai pensé. Après cela, un graphique? J'ai pensé qu'il serait plus facile de comprendre si je pouvais afficher la fonction de perte et ainsi de suite.

Je le posterai petit à petit désormais. Je veux publier un docker et un contenu Web ... J'ai hâte de travailler avec vous.