Es ist ein ganz anderes Konzept als in Kapitel 2 Perceptron.
Von der Eingabeebene zur Ausgabeebene werden sie der Reihe nach die 0. Ebene, die 1. Ebene und die 2. Ebene genannt.
Aus der Überprüfung von Kapitel 2 kann es durch die folgende Formel ausgedrückt werden
y = h(b+w1x1+w2x2)
h(x) = 0 (x <= 0)
1 (x > 0)
a = b+w1x1+w2x2
h(a) = 0 (x <= 0)
1 (x > 0)
h(x) = 1 (x >= 0)
0 (x < 0)
Beim Versuch, eine Schrittfunktion als Ausdruck auszudrücken
Da es nicht wie step_function verwendet werden kann (np.array ([1.0, 2.0]))
import numpy as np
x = np.array([-1.0, 1.0, 2.0])
y = x > 0
y
array([False, True, True], dtype=bool)
y = y.astype(np.int)
y
array([0, 1, 1])
Das Obige in einer Funktion zusammenfassen
def step_function(x):
return np.array(x > 0, dtype= np.int)
Kann vertreten werden durch.
h(x) = 1 / 1 + exp(-x)
def sigmoid(x):
return 1/ (1 + np.exp(-x))
x = np.array([-1.0, 1.0, 2.0])
sigmoid(x)
> array([0.2689, 0.73.., 0.88..])
Perceptron hat nur 0,1 Signale, aber NN hat kontinuierliche Signale. Verwenden Sie keine linearen Funktionen für die Aktivierungsfunktion. Die Verwendung der linearen Algebra macht es bedeutungslos, Schichten in einem neuronalen Netzwerk zu vertiefen.
Da es sich um ein Netzwerk ohne versteckte Schichten handelt, ist es nicht möglich, Multi-Layering zu nutzen
Obwohl Sigmoid häufig ist, wird hauptsächlich eine Funktion namens ReLU (Rectified Linear Unit) verwendet. Die ReLU-Funktion kann wie folgt als mathematischer Ausdruck ausgedrückt werden.
h(x) = x (x > 0)
0 (x <= 0)
Implementierung
def relu(x):
return np.maximum(0, x)
A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
np.dot(A, B)
>> array([[19, 22],[43, 50]])
A = np.array([1,2,3],[4,5,6])
B = np.array([[1,2],[3,4],[5,6]])
np.dot(A,B)
>> array([[22,28],[49,64]])
X = np.array([1,2])
W = np.array([1,3,5],[2,4,6])
Y = np.dot(X,W)
print(Y)
>>> [5,11,17]
Eine einfache Formel für ein dreischichtiges neuronales Netzwerk
A = XW = B
W1.shape = (2, 3)
W2.shape = (3, 2)
W3.shape = (2, 2)
A1 = np.dot(X, W1) + B1
Z1 = sigmoid(A1)
A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)
A3 = np.dot(Z2, W3) + B3
Implementierungszusammenfassung
def init_network():
network = {}
network['W1'] = np.array([[0.1, 0.3, 0.5],[0.2,0.4,0.6]])
network['b1'] = np.array([0.1, 0.2, 0.3])
network['W2'] = np.array([[0.1, 0.4],[0.2, 0.5],[0.3,0.6]])
network['b2'] = np.array([0.1, 0.2])
network['W3'] = np.array([[0.1, 0.3],[0.2,0.4]])
network['b3'] = np.array([0.1, 0.2])
return network
def forward(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 = identity_function(a3)
return y
network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y) # [0.3168.., 0.69....]
Die Gleichheitsfunktion gibt die Eingabe so aus, wie sie ist. Die Softmax-Funktion wird durch die folgende Formel ausgedrückt
yk = exp(ak) / nΣi=1 exp(ai)
a = np.array([0.3, 2.9, 4.0])
exp_a = np.exp(a)
sum_exp_a = np.sum(exp_a)
y = exp_a = sum_exp_a
Sie müssen auf Überlauf achten.
def softmax(a):
c = np.max(a)
exp_a = np.exp(a-c) #Überlaufmaßnahmen
sum_exp_a = np.sum(exp_a)
y = exp_a / sum_exp_a
return y
Stellen Sie bei Klassifizierungsproblemen mit 10 Klassen die Anzahl der Ausgabeebenen auf 10 ein.
Bildsatz handgeschriebener Zahlen. Einer der bekanntesten Datensätze. Es besteht aus numerischen Bildern von 0 bis 9.
Es stehen 60.000 Trainingsbilder und 10.000 Testbilder zur Verfügung, die zum Lernen und Inferenzieren verwendet werden.
Eine häufige Verwendung des MNIST-Datensatzes besteht darin, mit Trainingsbildern zu trainieren und zu messen, wie gut das trainierte Modell Testbilder klassifizieren kann.
import sys, os
sys.path.append(os.pardir)
from dataset.mnist import load_mnist
(x_train, t_train), (x_test, t_test) = \
load_mnist(flatten=True, normalize=False)
print(x_train.shape) # (60000, 784)
print(t_train.shape) # (60000,)
print(x_test.shape) # (10000, 784)
print(t_test.shape) # (10000,)
Gibt die gelesenen MNIST-Daten im Format (Trainingsbild, Trainingsetikett) (Testbild, Testetikett) zurück.
import sys, os
sys.path.append(os.pardir)
import numpy as np
from datase.mnist import load_mnist
from PIL import Image
def img_show(img):
pil_img = IMage.fromarray(np.unit8(img))
pil_img.show()
(x_train, t_train), (x_test, t_test) = \
load_mnist(flatten = True, normalize = False)
img = x_train[0]
label = t_train[0]
print(label) # 5
print(img.shape) # (784)
img = img.reshape(28, 28)
print(img.shape) # (28, 28)
img_show(img) #Es werden 5 Bilder angezeigt
Das als flatten = True gelesene Bild wird in einer Dimension als Numpy-Array gespeichert. Wenn es angezeigt wird, muss es auf eine Größe von 28 x 28 umgeformt werden.
Da es in 10 Zahlen klassifiziert ist, gibt es 10 Ausgabeebenen. Es wird auch angenommen, dass es zwei verborgene Schichten gibt, die erste verborgene Schicht hat 50 Neuronen und die zweite Schicht hat 100 Neuronen. Die Zahlen 50 und 100 können auf einen beliebigen Wert eingestellt werden. Zunächst definieren wir drei Funktionen.
def get_date():
(x_train, t_train), (x_test, t_test) = \
load_mnist(normalize=True, flatten=True, one_hot_label=False)
return x_test, t_test
def init_network():
with open("sample_weight.pkl", 'rb') as f:
network = pickle.load(f)
return network
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
x, t = get_date()
network = init_network()
accuracy_cnt = 0
for i in range(len(x)):
y = predict(network, x[i])
p = np.armax(y) #Index des etabliertesten Elements abrufen
if p == t[i]:
accurancy_cnt += 1
print("accurancy:" + str(float(accuracy_cnt) / len(x)))
Laden Sie die trainierten Gewichtsparameter, die in sample_weight.pkl gespeichert sind. Diese Datei enthält Gewichts- und Bias-Parameter. pkl wird im nächsten Kapitel erklärt.
Recommended Posts