[PYTHON] Mémo d'apprentissage automatique d'un ingénieur débutant Partie 1

introduction

Ceci est la partie 1 du mémo d'apprentissage pour "Deep-Learning from scratch".

Opération de tranche facile à oublier

• Vous pouvez utiliser la valeur numérique affichée par [start: step: stop].

tranche

x=[1,2,3,4,5]
#Affichage complet
x[:]
#1 à 2
x[0:2]
#Passer deux des 1, 3 et 5
x[::2]
#Ordre inverse,-Si défini sur 2, sautez deux de l'opposé
x[::-1]

Correspondance de forme numpy

• Si cela n'est pas connu, le prétraitement des données ne peut pas être effectué.

numpy

#Forme 3x2
A = np.array([[1,2], 
              [3,4],
              [5,6]])
#Forme 2 x 1
B = np.array([7,
              8])
#Calcul du produit intérieur
np.dot(A,B)
>>>array([23,53,83])

Implémentation d'un réseau neuronal (chapitre 3)

• Étant donné que vous utilisez Google Colaboratory, vous devez monter Google Drive, sinon vous ne pourrez pas importer un autre fichier Python.

monter

from google.colab import drive
drive.mount('/content/drive')

cd drive/My Drive/deep-learning-from-scratch-master/ch03

• Appel de l'instruction d'importation, numpy, pickle, fonction dans un autre fichier

neuralnet

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  #Paramètres d'importation des fichiers dans le répertoire parent
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax

• Les données d'entraînement et les étiquettes d'entraînement et les données de test et les étiquettes de test sont appelées et stockées à partir de mnist.py, et seuls x_test et t_test sont appelés ici car le traitement d'inférence est effectué à l'aide des données apprises. Les données d'entraînement ne sont pas utilisées car elles ne sont pas destinées à l'entraînement.

neuralnet

def get_data():
    (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
    return x_test, t_test

• "Sample_weight.pkl" est les données de poids entraînées, et le contenu des données est de type dictionnaire et contient {W1 :, W2:, W3:, b1 :, b2:, b3}.

neuralnet

def init_network():
    with open("sample_weight.pkl", 'rb') as f:
        network = pickle.load(f)
    return network

• Stockez les données appelées à partir de "sample_weight.pkl" dans une variable, placez-les dans le modèle, et le résultat sortira sous forme de tableau Numpy. À ce stade, le plus grand nombre du tableau numpy est le nombre prédit.

neuralnet

def predict(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = softmax(a3)

    return y

• La variable t contient des données d'étiquette et l'instruction if détermine si la valeur prédite et l'étiquette correcte correspondent. Ici, il est déterminé combien de réponses correctes sur 10 000 données d'image. Le résultat est Précision: 0,9352.

neuralnet

x, t = get_data()
network = init_network()
accuracy_cnt = 0
for i in range(len(x)):
    y = predict(network, x[i])
    p= np.argmax(y) #Obtenez l'index de l'élément le plus probable
    if p == t[i]:
        accuracy_cnt += 1

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

Traitement par lots (suite au chapitre 3)

• Le réseau neuronal décrit dans l'élément précédent se compose de neurones avec 784 couches d'entrée et 10 couches de sortie. 784 est la taille d'image de 28x28 et 10 est la classification des nombres 0-9. Le paramètre comporte 2 couches cachées, 50 premières couches cachées et 100 secondes couches cachées. Cela correspond à la forme des données entraînées "sample_weight.pkl".
• Dans le traitement par lots, 100 images sur 10 000 données d'image peuvent être utilisées collectivement comme données d'entrée. Cela accélère le processus.
• La partie où axis = 1 est définie pour prendre la valeur maximale dans la direction de la colonne.
• Dans np.sum (p == t [i: i + batch_size]), True est jugé par l'opérateur de comparaison (==) et le nombre est calculé.

Le traitement par lots

x, t = get_data()
network = init_network()

batch_size = 100 #Nombre de lots
accuracy_cnt = 0

#range(start,stop,step)
for i in range(0, len(x), batch_size):
    x_batch = x[i:i+batch_size]
    y_batch = predict(network, x_batch)
    p = np.argmax(y_batch, axis=1)
    accuracy_cnt += np.sum(p == t[i:i+batch_size])

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

référence

Apprentissage profond à partir de zéro