[PYTHON] Maschinelles Lernen eines jungen Ingenieurs Teil 1

Einführung

Dies ist Teil 1 des Lernmemos für "Deep-Learning von Grund auf neu".

Slice-Operation, die leicht zu vergessen ist

• Sie können den durch [Start: Schritt: Stopp] angezeigten numerischen Wert bedienen.

Scheibe

x=[1,2,3,4,5]
#Volle Anzeige
x[:]
#1 bis 2
x[0:2]
#Überspringen Sie zwei von 1, 3 und 5
x[::2]
#Umgekehrte Reihenfolge,-Wenn auf 2 gesetzt, überspringen Sie zwei vom Gegenteil
x[::-1]

Numpy Form Match

• Wenn dies nicht bekannt ist, kann keine Datenvorverarbeitung durchgeführt werden.

numpy

#3x2 Form
A = np.array([[1,2], 
              [3,4],
              [5,6]])
#2 x 1 Form
B = np.array([7,
              8])
#Berechnung des inneren Produkts
np.dot(A,B)
>>>array([23,53,83])

Implementierung eines neuronalen Netzwerks (Kapitel 3)

• Da Sie Google Colaboratory verwenden, müssen Sie Google Drive bereitstellen, da Sie sonst keine weitere Python-Datei importieren können.

montieren

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

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

• Aufruf der Importanweisung, Numpy, Pickle, Funktion in einer anderen Datei

neuralnet

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
import numpy as np
import pickle
from dataset.mnist import load_mnist
from common.functions import sigmoid, softmax

• Trainingsdaten und Trainingsetikett sowie Testdaten und Testetikett werden von mnist.py aufgerufen und gespeichert, und hier werden nur x_test und t_test aufgerufen, da die Inferenzverarbeitung unter Verwendung der gelernten Daten durchgeführt wird. Trainingsdaten werden nicht verwendet, da sie nicht zum Lernen dienen.

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" sind trainierte Gewichtsdaten, und der Inhalt der Daten ist vom Wörterbuchtyp und enthält {W1:, W2 :, W3 :, b1:, b2 :, b3}.

neuralnet

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

• Speichern Sie die von "sample_weight.pkl" aufgerufenen Daten in einer Variablen, fügen Sie sie in das Modell ein, und das Ergebnis wird als Numpy-Array ausgegeben. Zu diesem Zeitpunkt ist die größte Zahl im Numpy-Array die vorhergesagte Zahl.

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

• Die Variable t enthält Etikettendaten, und die if-Anweisung bestimmt, ob der vorhergesagte Wert und die korrekte Etikettenübereinstimmung übereinstimmen. Hier wird ermittelt, wie viele richtige Antworten aus 10.000 Bilddaten stammen. Das Ergebnis ist Genauigkeit: 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) #Holen Sie sich den Index des wahrscheinlichsten Elements
    if p == t[i]:
        accuracy_cnt += 1

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

Stapelverarbeitung (Fortsetzung in Kapitel 3)

• Das im vorherigen Punkt beschriebene neuronale Netzwerk besteht aus Neuronen mit 784 Eingangsschichten und 10 Ausgangsschichten. 784 ist die Bildgröße von 28x28 und 10 ist die Klassifizierung der Zahlen 0-9. Die Einstellung hat zwei verborgene Schichten, die erste verborgene Schicht hat 50 Neuronen und die zweite verborgene Schicht hat 100 Neuronen. Dies entspricht der Form der trainierten Daten "sample_weight.pkl".
• Bei der Stapelverarbeitung können 100 von 10.000 Bilddaten gemeinsam als Eingabedaten verwendet werden. Dies beschleunigt den Prozess.
• Der Teil, bei dem Achse = 1 ist, wird so eingestellt, dass er den Maximalwert in Spaltenrichtung annimmt.
• In np.sum (p == t [i: i + batch_size]) wird True vom Vergleichsoperator (==) beurteilt und die Zahl berechnet.

Stapelverarbeitung

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

batch_size = 100 #Anzahl der Chargen
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)))

Referenz

Deep Learning von Grund auf neu