Implémentation d'un réseau de neurones à deux couches 2

Suite de l'article précédent Implémentation d'un réseau neuronal à deux couches Nous avons créé un réseau de neurones à deux couches et appris MNIST. Confirmation de l'exactitude des prévisions des résultats appris. Reportez-vous au chapitre 4 du Deep Learning à partir de zéro

TwoLayerNet.py


import numpy as np

class TwoLayerNet:
    
    def __init__(self,input_size,hidden_size,output_size,weight_init_std=0.01):
        #Initialisation du poids
        self.params = {}
        #784 *Matrice de 50 poids
        self.params['W1'] = weight_init_std * np.random.randn(input_size,hidden_size)
        #50 *10 matrice de poids
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size,output_size)
        #Biais, autant de couches cachées
        self.params['b1'] = np.zeros(hidden_size)
        #Biais, autant que le nombre de couches de sortie
        self.params['b2'] = np.zeros(output_size)
    
    def sigmoid(self,x):
        return 1 / (1 + np.exp(-x))
    
    def softmax(self,a):
        c = np.max(a)
        exp_a = np.exp(a - c)#Mesures de débordement
        sum_exp_a = np.sum(exp_a)
        y = exp_a / sum_exp_a
        return y
    
    def _numerical_gradient_1d(self,f, x):
        h = 1e-4 # 0.0001
        grad = np.zeros_like(x)

        for idx in range(x.size):
            tmp_val = x[idx]
            x[idx] = float(tmp_val) + h
            fxh1 = f(x) # f(x+h)

            x[idx] = tmp_val - h 
            fxh2 = f(x) # f(x-h)
            grad[idx] = (fxh1 - fxh2) / (2*h)

            x[idx] = tmp_val #Restaurer la valeur

        return grad


    def numerical_gradient(self,f, X):
        if X.ndim == 1:
            return self._numerical_gradient_1d(f, X)
        else:
            grad = np.zeros_like(X)

            for idx, x in enumerate(X):
                grad[idx] = self._numerical_gradient_1d(f, x)

            return grad

    def cross_entropy_error(self,y,t):
        if y.ndim == 1:
            t = t.reshape(1,t.size)
            y = y.reshape(1,y.size)
        batch_size = y.shape[0]
        return -np.sum(t * np.log(y)) / batch_size
    
    def predict(self,x):
        W1,W2 = self.params['W1'],self.params['W2']
        b1,b2 = self.params['b1'],self.params['b2']
        
        a1 = np.dot(x,W1) + b1 #a = Wx + b
        z1 = self.sigmoid(a1)
        a2 = np.dot(z1,W2) + b2
        z2 = self.softmax(a2)
        
        return z2
    
    def loss(self, x, t):
        y = self.predict(x)
        
        return self.cross_entropy_error(y,t)
    
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y,axis=1)
        t = np.argmax(t,axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
    
    def gradient(self,x,t):
        loss_W = lambda W: self.loss(x,t)
        grads = {}
        grads['W1'] = self.numerical_gradient(loss_W,self.params['W1'])
        grads['W2'] = self.numerical_gradient(loss_W,self.params['W2'])
        grads['b1'] = self.numerical_gradient(loss_W,self.params['b1'])
        grads['b2'] = self.numerical_gradient(loss_W,self.params['b2'])
        
        return grads

Similaire à la fois précédente, l'apprentissage par mini-lots (taille 50) a été effectué 500 fois à partir des données MNIST. Cette fois, la précision (acc) est calculée avec 50 boucles pour une époque.

LearningMNIST.py


#coding: utf-8
import numpy as np
from sklearn.datasets import fetch_mldata
from sklearn.preprocessing import OneHotEncoder

mnist = fetch_mldata('MNIST original', data_home=".")

x_train = mnist['data'][:60000]
t_train = mnist['target'][:60000]

t_train = t_train.reshape(1, -1).transpose()
# encode label
encoder = OneHotEncoder(n_values=max(t_train)+1)
t_train = encoder.fit_transform(t_train).toarray()

x_test = mnist['data'][60000:]
t_test = mnist['target'][60000:]

t_test = t_test.reshape(1, -1).transpose()
# encode label
encoder = OneHotEncoder(n_values=max(t_test)+1)
t_test = encoder.fit_transform(t_test).toarray()

x_train = x_train.astype(np.float64)
x_train /= x_train.max()
x_test = x_test.astype(np.float64)
x_test /= x_test.max()

train_loss_list = []
train_acc_list = []
test_acc_list = []

#hyper parameter
iters_num = 2
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

#Nombre d'itérations par époque
#iter_per_epoch = max(train_size / batch_size, 1)
iter_per_epoch = 50

network = TwoLayerNet(input_size=784,hidden_size=50,output_size=10)

iters_num = 500
for i in range(iters_num):
    batch_mask = np.random.choice(train_size,batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    grad = network.gradient(x_batch,t_batch)
    
    for key in ('W1','W2','b1','b2'):
        network.params[key] -= learning_rate * grad[key]
        
    loss = network.loss(x_batch,t_batch)
    train_loss_list.append(loss)
    #Calculer la précision de la reconnaissance pour chaque époque
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

Le résultat est le graphique ci-dessous, l'axe vertical est la précision et l'axe horizontal est le nombre d'époques.

MNIST_acc.jpg

La précision s'améliore à chaque époque.

Recommended Posts

Implémentation d'un réseau de neurones à deux couches 2
J'ai essayé de mettre en œuvre un réseau de neurones à deux couches
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
Implémentation d'un réseau neuronal à 3 couches (pas d'apprentissage)
Implémentation de réseaux neuronaux "flous" avec Chainer
Visualisez la couche interne du réseau neuronal
Implémenter un réseau neuronal à 3 couches
Implémentation de réseau neuronal en python
Implémentation de réseau neuronal (NumPy uniquement)
L'histoire de la création d'un réseau neuronal de génération musicale
Mise en œuvre de l'optimisation bayésienne des hyper paramètres du réseau de neurones (Chainer + GPyOpt)
Bases de PyTorch (2) -Comment créer un réseau de neurones-
Apprentissage des classements à l'aide d'un réseau neuronal (implémentation RankNet par Chainer)
Implémentation simple d'un réseau neuronal à l'aide de Chainer
Mise en place d'un filtre à particules simple
PRML Chapitre 5 Implémentation Python du réseau neuronal
Qu'est-ce que le réseau neuronal convolutif?
Théorie et implémentation simples des réseaux neuronaux
Touchez l'objet du réseau neuronal
Construction d'un réseau neuronal qui reproduit XOR par Z3
Comprendre le nombre de paramètres d'entrée / sortie du réseau neuronal convolutif
Composez avec un réseau neuronal! Run Magenta
Implémentation de réseau neuronal simple à l'aide de la préparation Chainer-Data-
Implémentation de réseau neuronal simple à l'aide de la description du modèle Chainer-
Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow
Réseau neuronal paramétrique
Implémentation simple d'un réseau de neurones à l'aide de Chainer ~ Définition d'un algorithme d'optimisation ~
Expérimentez avec divers algorithmes d'optimisation sur le réseau neuronal
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Vérification de la normalisation des lots avec un réseau neuronal multicouche
Reconnaissance des nombres manuscrits par un réseau neuronal multicouche
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Implémentation d'un réseau neuronal à 3 couches
[Python] Implémentation du clustering à l'aide d'un modèle gaussien mixte
Entraînez les données MNIST avec PyTorch en utilisant un réseau neuronal
Présentation de DNC (Differentiable Neural Computers) + Implémentation par Chainer
Implémenter un réseau neuronal convolutif
Implémentation python de la classe de régression linéaire bayésienne
Implémentation de la séquence de Fibonacci
Implémenter le réseau neuronal à partir de zéro
Expérience de réseau de neurones pliable
Bases des programmes réseau?
Un mémorandum sur la mise en œuvre des recommandations en Python
Comment dessiner facilement la structure d'un réseau de neurones sur Google Colaboratory à l'aide de "convnet-tiroir"
J'ai essayé un réseau de neurones convolutifs (CNN) avec un tutoriel TensorFlow sur Cloud9-Classification des images manuscrites-
J'ai essayé de mettre en œuvre le modèle de base du réseau neuronal récurrent
Créez une application Web qui reconnaît les nombres avec un réseau neuronal
Implémentation de VGG16 à l'aide de Keras créé sans utiliser de modèle entraîné
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Une implémentation Python simple de la méthode k-voisinage (k-NN)
Un diagramme de réseau a été créé avec les données du COVID-19.
Essayez de créer un réseau de neurones en Python sans utiliser de bibliothèque
J'ai fait un générateur de réseau neuronal qui fonctionne sur FPGA
Série d'accélération CNN ~ FCNN: Introduction du réseau neuronal convolutif de Fourier ~
La méthode d'initialisation des paramètres de poids dans un réseau neuronal est résumée avec implémentation (valeurs initiales de Xavier, He et al., Etc.)
Implémentation informatique quantique de Quantum Walk 2
Implémentation de TF-IDF à l'aide de gensim
Remarque sur la compilation du noyau
Réseau de neurones avec Python (scikit-learn)
3. Distribution normale avec un réseau neuronal!
Explication et mise en œuvre de SocialFoceModel
Un petit mémorandum d'openpyxl