[PYTHON] <Kurs> Tiefes Lernen: Tag 1 NN
Tiefes Lernen
[Deep Learning: Tag 1 NN] (https://qiita.com/matsukura04583/items/6317c57bc21de646da8e) [Deep Learning: Day2 CNN] (https://qiita.com/matsukura04583/items/29f0dcc3ddeca4bf69a2) [Deep Learning: Tag 3 RNN] (https://qiita.com/matsukura04583/items/9b77a238da4441e0f973) [Deep Learning: Tag 4 Stärkung des Lernens / Tensorflusses] (https://qiita.com/matsukura04583/items/50806b750c8d77f2305d)
Deep Learning: Tag 1 NN (Vorlesungszusammenfassung)
-
Was Sie mit Neural Network (NN) tun können
-
Zurück
-
Erwartete Ergebnisse
-
Aktienkursprognose
-
Umsatzprognose
-
Rangliste
-
Prognose für das Pferderennen
-
Prognose des Beliebtheitsrankings
-
Klassifizierung
-
Identifizierung von Katzenfotos
-
Handschriftliche Zeichenerkennung
-
Klassifizierung des Blumentyps
-
Neuronales Netz︓ Regression (ungefähre Funktion, die kontinuierliche reelle Werte annimmt)
-
[Rückgabeanalyse] • Lineare Regression • Baum zurückgeben • Zufälliger Wald • Neuronales Netz (NN)
-
Neuronales Netz︓ Klassifizierung (Geschlecht (männlich oder weiblich) und Tierart Analyse zur Vorhersage diskreter Ergebnisse)
-
[Klassifikationsanalyse] • Bayesianische Klassifikation • Logistische Regression • Zufälliger Wald • Neuronales Netz (NN)
Abschnitt 1) Eingabeebene zur Zwischenebene
- Wenn Sie das Gewicht als großes W ausdrücken, es als Bias b ausdrücken und beide zusammen vorschlagen, ist es ein komplizierter Punkt, es als kleines w auszudrücken.
- Die mittlere Ebene kann unendlich eingestellt werden.
Abschnitt 2) Aktivierungsfunktion
- In einem neuronalen Netzwerk eine nichtlineare Funktion, die die Größe der Ausgabe an die nächste Schicht bestimmt.
- Es hat die Funktion, das EIN / AUS und die Stärke des Signals zur nächsten Schicht in Abhängigkeit vom Wert des Eingangswerts zu bestimmen.
- ** Aktivierungsfunktion für mittlere Schicht **
- Schrittfunktion
Formel
f(x) = \left\{
\begin{array}{ll}
1 & (x \geq 0) \\
0 & (x \lt 0)
\end{array}
\right.
python
def
step_function(x):
if x > 0:
return 1
else:
return 0
- Sigmaid (logistische) Funktion
Formel
f(u) = \frac{1}{1+e^{-u}}
python
def sigmoid(x):
return 1/(1 + np.exp(-x))
Es ist eine Funktion, die sich langsam zwischen 0 und 1 ändert, und es ist möglich geworden, die Stärke des Signals in den Zustand zu übertragen, in dem die Schrittfunktion nur EIN / AUS hat, was die Ausbreitung prädiktiver neuronaler Netze ausgelöst hat. Aufgabe Bei großen Werten ist die Änderung der Ausgabe gering, was zu einem Problem beim Verschwinden des Gradienten führen kann.
- ReLU-Funktion
f(x) = \left\{
\begin{array}{ll}
x & (x \gt 0) \\
0 & (x \leq 0)
\end{array}
\right.
python
def relu(x):
return
np.maximum(0, x)
Die derzeit am häufigsten verwendete Aktivierungsfunktion Gute Ergebnisse wurden erzielt, indem dazu beigetragen wurde, das Problem des Verschwindens des Gradienten zu vermeiden und es spärlich zu machen.
- Gradient Verschwinden Problem ・ Wir werden die Spärlichkeit im Detail diskutieren, nachdem wir die stochastische Gradientenabstiegsmethode erklärt haben.
- ** Aktivierungsfunktion für Ausgabeebene **
- Softmax-Funktion
- Gleiche Zuordnung
- Sigmaid-Funktion (Logistikfunktion)
Abschnitt 3) Ausgabeschicht
3-1 Fehlerfunktion
Fehlerberechnung Fehlerfunktion = quadratischer Fehler
En(w)=\frac{1}{2}\sum_{j=1}^{I} (y_j-d_j)^2 = \frac{1}{2}||(y-d)||^2
3-2 Aktivierungsfunktion der Ausgabeschicht
- Unterschied zur mittleren Ebene der Ausgabeebene
- [Wertstärke]
- Zwischenschicht︓ Passen Sie die Signalstärke vor und nach dem Schwellenwert an
- Ausgangsschicht ︓ Die Signalgröße (Verhältnis) wird unverändert konvertiert
- [Wahrscheinlichkeitsausgabe]
- Bei Klassifizierungsproblemen sollte die Ausgabe der Ausgabeschicht auf den Bereich 0 bis 1 begrenzt sein und die Summe sollte 1 sein.
- Die in der Ausgabeschicht und der Zwischenschicht verwendeten Aktivierungsfunktionen sind unterschiedlich
- Gekreuzte Entropie
En(w)=-\sum_{i=1}^Id_ilog y_i
python
#Kreuzentropie
def cross_entropy_error(d, y):
if y.ndim == 1:
d = d.reshape(1, d.size)
y = y.reshape(1, y.size)
#Lehrerdaten sind eins-hot-Konvertieren Sie für den Vektor in den Index der richtigen Bezeichnung
if d.size == y.size:
d = d.argmax(axis=1)
batch_size = y.shape[0]
return -np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size
Ein One-Hot-Vektor ist ein Vektor wie (0,1,0,0,0,0), wobei eine Komponente 1 ist und die verbleibenden Komponenten alle 0 sind. (Referenz) Was ist ein One-Hot-Vektor?
Abschnitt 4) Gradientenabstiegsmethode
- Gradientenabstiegsmethode
- Vollgekoppelte NN - Gradientenabstiegsmethode
- Erstellen eines Netzwerks, das Fehler durch Lernen minimiert
- Der Zweck besteht darin, einen Parameter zu finden, der den Fehler E (w) minimiert.
- Optimieren Sie die Parameter mithilfe der Gradientenabstiegsmethode
- Die Lernrate $ \ varepsilon $ verändert den Effekt des Lernens erheblich
+
$ W ^ {(t + 1)} = W ^ {(t)} - \ varepsilon \ nabla E (\ varepsilon ist die Lernrate) $
$ \ nabla E = \ frac {\ partielles E} {\ partielles W} = [\ frac {\ partielles E} {\ partielles w_1} fra ･ fra \ frac {\ partielles E} {\ partielles w_M}] $
Mehrere Algorithmen zur Bestimmung der Lernrate der Gradientenabstiegsmethode und zur Verbesserung der Konvergenz. Das Papier wird veröffentlicht + Momentum + AdaGrad + Adadelta + Adam
(Referenz) Erläuterung der Gradientenabstiegsmethode
-
Probabilistische Gradientenabstiegsmethode
-
$ W ^ {(t + 1)} = W ^ {(t)} - \ varepsilon \ nabla E (\ varepsilon ist die Lernrate) $ ・ ・ ・ Gradientenabstiegsmethode
Die Gradientenabstiegsmethode ist der Durchschnitt aller Stichproben Fehler
+ $ W ^ {(t + 1)} = W ^ {(t)} - \ varepsilon \ nabla En (\ varepsilon ist die Lernrate) $ ・ ・ ・ Probabilistische Gradientenabstiegsmethode
Die probabilistische Gradientenabstiegsmethode ist der Fehler zufällig ausgewählter Stichproben -
Vorteile der probabilistischen Gradientenabstiegsmethode
-
Reduzierung der Berechnungskosten bei langen Daten
-
Reduzieren Sie das Risiko der Konvergenz mit unerwünschten lokalen Minimallösungen
-
Sie können online lernen
-
[(Referenz) Erläuterungsstelle für die stochastische Gradientenabstiegsmethode](https://qiita.com/YudaiSadakuni/items/ece07b04c685a64eaa01#%E7%A2%BA%E7%8E%87%E7%9A%84%E5% 8B% BE% E9% 85% 8D% E9% 99% 8D% E4% B8% 8B% E6% B3% 95)
-
Mini-Batch-Gradienten-Abstiegsmethode + $ W ^ {(t + 1)} = W ^ {(t)} - \ varepsilon \ nabla En (\ varepsilon ist die Lernrate) $ ・ ・ ・ Probabilistische Gradientenabstiegsmethode
Die probabilistische Gradientenabstiegsmethode ist der Fehler zufällig ausgewählter Stichproben
$ W ^ {(t + 1)} = W ^ {(t)} - \ varepsilon \ nabla Et (\ varepsilon ist die Lernrate) $ ・ ・ ・ Mini-Batch-Gradienten-Abstiegsmethode
Die Mini-Batch-Gradientenabstiegsmethode ist ein Satz zufällig extrahierter Daten () Mini-Batch-Durchschnittsfehler von Proben, die zu $ D_t $
gehören
Vorteile der Mini-Batch-Gradientenabstiegsmethode Effektive Nutzung von Computerressourcen, ohne die Vorzüge der stochastischen Gradientenabstiegsmethode zu beeinträchtigen → Thread-Parallelisierung mit CPU und SIMD-Parallelisierung mit GPU
Abschnitt 5) Methode zur Fehlerrückübertragung
Fehlergradientenberechnung - Backpropagation-Methode
[Methode zur Fehlerrückübertragung] Der berechnete Fehler wird in der Reihenfolge von der Seite der Ausgangsschicht unterschieden und vor der vorherigen Schicht auf die Schicht übertragen. Eine Methode zur analytischen Berechnung des Differenzwerts jedes Parameters mit der Mindestberechnung
Durch Rückrechnung des Differentials aus dem Berechnungsergebnis (= Fehler) kann das Differential berechnet werden, wobei unnötige rekursive Berechnungen vermieden werden.
python
#Fehler bei der Weitergabe
def backward(x, d, z1, y):
print("\n#####Starten Sie die Fehlerrückübertragung#####")
grad = {}
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
#Delta auf der Ausgangsschicht
delta2 = functions.d_sigmoid_with_loss(d, y)
#Steigung von b2
grad['b2'] = np.sum(delta2, axis=0)
#W2 Gradient
grad['W2'] = np.dot(z1.T, delta2)
#Delta in der mittleren Schicht
delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)
#Steigung von b1
grad['b1'] = np.sum(delta1, axis=0)
#W1 Gradient
grad['W1'] = np.dot(x.T, delta1)
print_vec("Teilweise Differenzierung_dE/du2", delta2)
print_vec("Teilweise Differenzierung_dE/du2", delta1)
print_vec("Teilweise Differenzierung_Gewicht 1", grad["W1"])
print_vec("Teilweise Differenzierung_Gewicht 2", grad["W2"])
print_vec("Teilweise Differenzierung_Bias 1", grad["b1"])
print_vec("Teilweise Differenzierung_Bias 2", grad["b2"])
return grad
Berücksichtigung des Bestätigungstests
[P10] Beschreibe in Deep Learning, was du versuchst, in zwei Zeilen oder weniger. Welcher der folgenden Werte ist das ultimative Ziel der Optimierung? Alles auswählen. ① Eingabewert [X] ② Ausgabewert [Y] ③ Gewicht [W] ④ Vorspannung [b] ⑤ Gesamteingabe [u] ⑥ Zwischenschicht-Eingabe [z] ⑦ Lernrate [ρ]
⇒ [Diskussion] Schließlich zielt Deep Learning darauf ab, die Parameter zu bestimmen, die den Fehler minimieren. Das ultimative Ziel der Optimierung der Werte ist (3) Gewicht [W] und (4) Vorspannung [b].
[P12] Bringen Sie das folgende Netzwerk auf Papier.
- Eingabeebene︓ 2 Knoten 1 Ebene
- Zwischenschicht︓ 3 Knoten 2 Schichten
- Ausgabeebene: 1 Knoten 1 Ebene
⇒ [Diskussion]
Es ist leicht zu verstehen, wenn Sie es selbst schreiben.
[P19] Bestätigungstest Lassen Sie uns ein Beispiel für die Klassifizierung von Tieren in dieses Schema aufnehmen
⇒ [Diskussion]
[P21] Bestätigungstest
Schreiben Sie diesen Ausdruck in Python
u=w_1x_1+w_2x_2+w_3x_3+w_4x_4+b=Wx+b..(1.2)
⇒ [Diskussion]
pyhon
u1=np.dot(x,W1)+b1
[P23] Bestätigungstest Extrahieren Sie den Code, der die mittlere Ebene darstellt
⇒ [Diskussion]
pyhon
#Gesamteingabe der verborgenen Ebene
u1 = np.dot(x, W1) + b1
#Gesamtausgabe der verborgenen Ebene
z1 = functions.relu(u1)
- Die RELU-Funktion wird separat erklärt.
[P26] Bestätigungstest Erklären Sie den Unterschied zwischen linear und nichtlinear mit einem Diagramm.
[P34] Bestätigungstest
Voll gekoppelte NN-Einzelschicht, mehrere Knoten
Extrahieren Sie den relevanten Teil aus dem verteilten Quellcode.
⇒ [Diskussion]
Dies ist der Teil, weil die Aktivierungsfunktion f (u) eine Sigmoidfunktion ist.
python
z1 = functions.sigmoid(u)
[P34] Bestätigungstest Fehlerberechnung Fehlerfunktion = quadratischer Fehler
En(w)=\frac{1}{2}\sum_{j=1}^{I} (y_j-d_j)^2 = \frac{1}{2}||(y-d)||^2
・ Beschreiben Sie, warum Sie statt Subtraktion quadrieren ・ Beschreiben Sie, was 1/2 der folgenden Formel bedeutet.
⇒ [Diskussion] ・ Um die Dispersion als Plus auszudrücken ・ 1/2 ist der Durchschnittswert (Referenz) Die Seite hier war leicht zu verstehen Die Bedeutung und Berechnungsmethode der Methode der kleinsten Quadrate - So finden Sie die Regressionslinie
- Ursprünglich wird im Fall eines Klassifizierungsproblems der Kreuzentropiefehler für die Fehlerfunktion verwendet, daher lautet der Code
** loss = cross_entropy_error (d, y) **
Der Code lautet
** loss = functions.mean_squared_error (d, y) **
, da der Fehler verwendet wird.
[P51] Bestätigungstest (S3_2 Ausgabe Layer_Aktivierungsfunktion) Softmax-Funktion
①f(i,u)=\frac{e^{u_i}②}{\sum_{k=1}^{k}e^{u_k}③}
Zeigen Sie den Quellcode, der den Formeln (1) bis (3) entspricht, und erklären Sie ihn zeilenweise.
python
def softmax(x):
if x.ndim == 2:#Wenn es zweidimensional wäre
x = x.Tx
x = x-np.max(x, axis=0)
y = np.exp(x) /np.sum(np.exp(x), axis=0)
return y.T
x = x -np.max(x) #Überlaufmaßnahmen
return np.exp(x) / np.sum(np.exp(x))
① ・ ・ ・ ・ y (Rückkehr von der Rückkehr y.T) P ・ ・ ・ p np.exp (x) Teil P ・ ・ ・ p np.sum (np.exp (x), Achse = 0) Teil
(Lernreferenz) Was bedeutet die Achse und Anzahl der Dimensionen von NumPy (ndim)
[P53] Bestätigungstest(S3_2 Ausgabeschicht_Aktivierungsfunktion)
Gekreuzte Entropie
①~Zeigen Sie den Quellcode an, der der Formel in 2 entspricht, und erklären Sie den Prozess zeilenweise.
```math
En(w)=-\sum_{i=1}^Id_ilog y_i
⇒ [Diskussion] · Rückkehr-np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size ・ 1/2 nimmt den Durchschnittswert
python
# Kreuzentropie
def cross_entropy_error(d, y):
if y.ndim == 1:
d = d.reshape(1, d.size)
y = y.reshape(1, y.size)
# Wenn es sich bei den Lehrerdaten um One-Hot-Vector handelt, konvertieren Sie sie in den Index des richtigen Antwortetiketts
if d.size == y.size:
d = d.argmax(axis=1)
batch_size = y.shape[0]
return -np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size
- 『1e-7 ”wird hinzugefügt, da es sich um eine feine Zahl handelt, damit der Protokollteil nicht Null wird. +Lehrerdaten sind eins-heißer Vektor oder nicht(Lehrerdaten sind Ganzzahlen usw.)Ist wichtig. einer-Wenn es sich nicht um einen heißen Vektor handelt, müssen Sie eine andere Funktion verwenden, die Keras verwendet.
[P56] Bestätigungstest(S4-Gradientenabstiegsmethode) Suchen Sie den geeigneten Quellcode für die Gradientenabstiegsfunktion.
⇒ [Diskussion]
python
# Error
loss = functions.cross_entropy_error(d, y)
grad = rückwärts (x, d, z1, y) # Entspricht dem Teil ②
for key in ('W1', 'W2', 'b1', 'b2'):
Netzwerk [Schlüssel] - = Lernrate * Grad [Schlüssel] # ①
[P65] Bestätigungstest(S4-Gradientenabstiegsmethode) Fassen Sie zusammen, was Online-Lernen ist. ⇒ [Diskussion] Online-Lernen bedeutet, dass ein Lernmodell nur mit neu erfassten Daten erstellt werden kann. Es kann gedreht werden, ohne vorhandene Daten zu verwenden.
[P69] Bestätigungstest(S4-Gradientenabstiegsmethode)
Erklären Sie die Bedeutung dieser Formel in einem Diagramm.
+
⇒ [Diskussion]
(〇〇〇) (〇〇〇) (〇〇〇)
Set 1 Set 2 Set 3
Addieren Sie in diesem Fall die Fehler, indem Sie einen beliebigen Datensatz als Mini-Batch-Satz verwenden, und 1/3
[P78] Bestätigungstest(S5-Fehlerrückverbreitungsmethode)
Die Fehlerrückverteilungsmethode kann unnötige rekursive Verarbeitung vermeiden. Extrahieren Sie den Quellcode, der die Ergebnisse der bereits durchgeführten Berechnungen enthält.
python
# Fehler bei der Weitergabe
def backward(x, d, z1, y):
print ("\ n ##### Fehler beim Start der Rückübertragung #####")
grad = {}
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
#Delta in der Ausgabeschicht ## Berechnen Sie hier die Ableitung der Funktion, die die Sigmoidfunktion und die Kreuzentropie kombiniert, und ersetzen Sie sie durch "delta2".
delta2 = functions.d_sigmoid_with_loss(d, y)
# b2 Gradient ## Verwenden von "delta2"
grad['b2'] = np.sum(delta2, axis=0)
# W2 Gradient ## Mit "delta2"
grad['W2'] = np.dot(z1.T, delta2)
# Delta in der mittleren Ebene ## Mit "delta2"
delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)
Gradient von # b1
grad['b1'] = np.sum(delta1, axis=0)
# W1 Gradient
grad['W1'] = np.dot(x.T, delta1)
print_vec ("teilweise differenziertes_dE / du2", Delta2)
print_vec ("teilweise differenziertes_dE / du2", Delta1)
print_vec ("teilweise differenziertes_gewicht 1", grad ["W1"])
print_vec ("teilweise differenziertes_gewicht 2", grad ["W2"])
print_vec ("teilweise differenzierte_Bias 1", grad ["b1"])
print_vec ("teilweise differenzierte_Bias 2", grad ["b2"])
return grad
[P83] Suchen Sie den Quellcode, der den beiden Leerzeichen entspricht(S5-Fehlerrückverbreitungsmethode)
python
# Delta auf der Ausgangsschicht
delta2 = functions.d_mean_squared_error(d, y)
python
# Delta auf der Ausgangsschicht
# W2 Gradient
grad['W2'] = np.dot(z1.T, delta2)
#Übung
DN06_Jupyter Übung
python
# Lass es uns versuchen #
# Vorwärtsausbreitung (Einzelschicht / Einzeleinheit)
# Gewicht
W = np.array([[0.1], [0.2]])
## Versuchen wir die _ Array-Initialisierung
W = np.zeros(2)
W = np.ones (2) # Hier auswählen
W = np.random.rand(2)
W = np.random.randint(5, size=(2))
print_vec ("Gewicht", W)
# vorspannen
b = 0.5
## Versuchen wir es mit der numerischen Initialisierung
b = np.random.rand () # Zufallszahl von 0 bis 1 # Hier auswählen
# b = np.random.rand () * 10 -5 # -5 ~ 5 Zufallszahlen
print_vec ("Bias", b)
# Eingegebener Wert
x = np.array([2, 3])
print_vec ("Eingabe", x)
# Gesamteingabe
u = np.dot(x, W) + b
print_vec ("Gesamteingabe", u)
# Zwischenschichtausgabe
z = functions.relu(u)
print_vec ("Zwischenschichtausgabe", z)
Gewicht [1. 1.]
vorspannen 0.15691869859919338
Eingang [2 3]
Gesamteingabe 5.156918698599194
Zwischenschichtausgabe 5.156918698599194
python
# Lass es uns versuchen #
# Vorwärtsausbreitung (einzelne Schicht / mehrere Einheiten)
# Gewicht
W = np.array([
[0.1, 0.2, 0.3],
[0.2, 0.3, 0.4],
[0.3, 0.4, 0.5],
[0.4, 0.5, 0.6]
])
## Versuchen wir die _ Array-Initialisierung
W = np.zeros((4,3))
W = np.ones ((4,3)) # Hier auswählen
W = np.random.rand(4,3)
W = np.random.randint(5, size=(4,3))
print_vec ("Gewicht", W)
# vorspannen
b = np.array([0.1, 0.2, 0.3])
print_vec ("Bias", b)
# Eingegebener Wert
x = np.array([1.0, 5.0, 2.0, -1.0])
print_vec ("Eingabe", x)
# Gesamteingabe
u = np.dot(x, W) + b
print_vec ("Gesamteingabe", u)
# Zwischenschichtausgabe
z = functions.sigmoid(u)
print_vec ("Zwischenschichtausgabe", z)
Gewicht [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]
vorspannen [0.1 0.2 0.3]
Eingang [ 1. 5. 2. -1.]
Gesamteingabe [7.1 7.2 7.3]
Zwischenschichtausgabe [0.99917558 0.99925397 0.99932492]
python
# Lass es uns versuchen #
# Klassifizierung mehrerer Klassen
# 2-3-4 Netzwerk
# !! Versuchen wir es mit _ Ändern wir die Knotenkonfiguration auf 3-5-4
# Stellen Sie Gewicht und Vorspannung ein
# Erstellen Sie Natework
def init_network():
print ("##### Netzwerkinitialisierung #####")
#Lass es uns versuchen
#_ Zeigt die Form jedes Parameters an
#_ Zufällige Generierung des Netzwerkanfangswertes
network = {}
network['W1'] = np.array([
[0.1, 0.4, 0.7, 0.1, 0.3],
[0.2, 0.5, 0.8, 0.1, 0.4],
[0.3, 0.6, 0.9, 0.2, 0.5]
])
network['W2'] = np.array([
[0.1, 0.6, 0.1, 0.6],
[0.2, 0.7, 0.2, 0.7],
[0.3, 0.8, 0.3, 0.8],
[0.4, 0.9, 0.4, 0.9],
[0.5, 0.1, 0.5, 0.1]
])
network['b1'] = np.array([0.1, 0.2, 0.3, 0.4, 0.5])
network['b2'] = np.array([0.1, 0.2, 0.3, 0.4])
print_vec ("Gewicht 1", Netzwerk ['W1'])
print_vec ("Gewicht 2", Netzwerk ['W2'])
print_vec ("Bias 1", Netzwerk ['b1'])
print_vec ("Bias 2", Netzwerk ['b2'])
return network
# Prozess erstellen
# x: Eingabewert
def forward(network, x):
print ("##### Propagierung starten #####")
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
Gesamteingabe der Ebene Nr. 1
u1 = np.dot(x, W1) + b1
Gesamtleistung der Schicht Nr. 1
z1 = functions.relu(u1)
Gesamteingabe für # 2 Ebenen
u2 = np.dot(z1, W2) + b2
# Ausgabewert
y = functions.softmax(u2)
print_vec ("Gesamteingabe 1", u1)
print_vec ("Zwischenschichtausgabe 1", z1)
print_vec ("Gesamteingabe 2", u2)
print_vec ("Ausgabe 1", y)
print ("Gesamtausgabe:" + str (np.sum (y)))
return y, z1
## Vorläufige Daten
# Eingegebener Wert
x = np.array([1., 2., 3.])
# Zielausgabe
d = np.array([0, 0, 0, 1])
# Netzwerkinitialisierung
network = init_network()
# Ausgabe
y, z1 = forward(network, x)
# Error
loss = functions.cross_entropy_error(d, y)
## Anzeige
print ("\ n ##### Ergebnisanzeige #####")
print_vec ("Ausgabe", y)
print_vec ("Trainingsdaten", d)
print_vec ("Fehler", Verlust)
#####Netzwerkinitialisierung##### Gewicht 1 [[0.1 0.4 0.7 0.1 0.3] [0.2 0.5 0.8 0.1 0.4] [0.3 0.6 0.9 0.2 0.5]]
Gewicht 2 [[0.1 0.6 0.1 0.6] [0.2 0.7 0.2 0.7] [0.3 0.8 0.3 0.8] [0.4 0.9 0.4 0.9] [0.5 0.1 0.5 0.1]]
Bias 1 [0.1 0.2 0.3 0.4 0.5]
Bias 2 [0.1 0.2 0.3 0.4]
#####Starten Sie die Vorwärtsausbreitung##### Gesamteingabe 1 [1.5 3.4 5.3 1.3 3.1]
Zwischenschichtausgabe 1 [1.5 3.4 5.3 1.3 3.1]
Gesamteingabe 2 [4.59 9.2 4.79 9.4 ]
Ausgabe 1 [0.00443583 0.44573018 0.00541793 0.54441607]
Gesamtausgabe: 1.0
#####Ergebnisanzeige##### Ausgabe [0.00443583 0.44573018 0.00541793 0.54441607]
Trainingsdaten [0 0 0 1]
Error 0.6080413107681358
python
# Lass es uns versuchen #
# Rückkehr
# 2-3-2 Netzwerk
# !! Versuchen wir es mit _ Ändern wir die Knotenkonfiguration auf 3-5-4
# Stellen Sie Gewicht und Vorspannung ein
# Erstellen Sie Natework
def init_network():
print ("##### Netzwerkinitialisierung #####")
network = {}
network['W1'] = np.array([
[0.1, 0.4, 0.7, 0.1, 0.3],
[0.2, 0.5, 0.8, 0.1, 0.4],
[0.3, 0.6, 0.9, 0.2, 0.5]
])
network['W2'] = np.array([
[0.1, 0.6, 0.1, 0.6],
[0.2, 0.7, 0.2, 0.7],
[0.3, 0.8, 0.3, 0.8],
[0.4, 0.9, 0.4, 0.9],
[0.5, 0.1, 0.5, 0.1]
])
network['b1'] = np.array([0.1, 0.2, 0.3, 0.4, 0.5])
network['b2'] = np.array([0.1, 0.2, 0.3, 0.4])
print_vec ("Gewicht 1", Netzwerk ['W1'])
print_vec ("Gewicht 2", Netzwerk ['W2'])
print_vec ("Bias 1", Netzwerk ['b1'])
print_vec ("Bias 2", Netzwerk ['b2'])
return network
# Prozess erstellen
def forward(network, x):
print ("##### Propagierung starten #####")
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
# Gesamteingabe der verborgenen Ebene
u1 = np.dot(x, W1) + b1
# Gesamtausgabe der ausgeblendeten Ebene
z1 = functions.relu(u1)
# Gesamteingabe der Ausgabeebene
u2 = np.dot(z1, W2) + b2
# Gesamtausgabe der Ausgabeebene
y = u2
print_vec ("Gesamteingabe 1", u1)
print_vec ("Zwischenschichtausgabe 1", z1)
print_vec ("Gesamteingabe 2", u2)
print_vec ("Ausgabe 1", y)
print ("Gesamtausgabe:" + str (np.sum (z1)))
return y, z1
# Eingegebener Wert
x = np.array([1., 2., 3.])
network = init_network()
y, z1 = forward(network, x)
# Zielausgabe
d = np.array([2., 3.,4.,5.])
# Error
loss = functions.mean_squared_error(d, y)
## Anzeige
print ("\ n ##### Ergebnisanzeige #####")
print_vec ("Zwischenschichtausgabe", z1)
print_vec ("Ausgabe", y)
print_vec ("Trainingsdaten", d)
print_vec ("Fehler", Verlust)
#####Netzwerkinitialisierung##### Gewicht 1 [[0.1 0.4 0.7 0.1 0.3] [0.2 0.5 0.8 0.1 0.4] [0.3 0.6 0.9 0.2 0.5]]
Gewicht 2 [[0.1 0.6 0.1 0.6] [0.2 0.7 0.2 0.7] [0.3 0.8 0.3 0.8] [0.4 0.9 0.4 0.9] [0.5 0.1 0.5 0.1]]
Bias 1 [0.1 0.2 0.3 0.4 0.5]
Bias 2 [0.1 0.2 0.3 0.4]
#####Starten Sie die Vorwärtsausbreitung##### Gesamteingabe 1 [1.5 3.4 5.3 1.3 3.1]
Zwischenschichtausgabe 1 [1.5 3.4 5.3 1.3 3.1]
Gesamteingabe 2 [4.59 9.2 4.79 9.4 ]
Ausgabe 1 [4.59 9.2 4.79 9.4 ]
Gesamtausgabe: 14.6
#####Ergebnisanzeige##### Zwischenschichtausgabe [1.5 3.4 5.3 1.3 3.1]
Ausgabe [4.59 9.2 4.79 9.4 ]
Trainingsdaten [2. 3. 4. 5.]
Error 8.141525
python
# Lass es uns versuchen #
# Binäre Klassifizierung
# 2-3-1 Netzwerk
# !! Versuchen wir es mit _ Ändern wir die Knotenkonfiguration in 5-10-1
# Stellen Sie Gewicht und Vorspannung ein
# Erstellen Sie Natework
def init_network():
print ("##### Netzwerkinitialisierung #####")
network = {}
network['W1'] = np.array([
[0.1, 0.3, 0.5,0.1, 0.3, 0.5,0.1, 0.3, 0.5, 0.6],
[0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.7],
[0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.7],
[0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.7],
[0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.2, 0.4, 0.6,0.7]
])
network['W2'] = np.array([
[0.1],
[0.1],
[0.1],
[0.1],
[0.1],
[0.1],
[0.1],
[0.1],
[0.1],
[0.1]
])
network['b1'] = np.array([0.1, 0.3, 0.5,0.1, 0.3, 0.5,0.1, 0.3, 0.5, 0.6])
network['b2'] = np.array([0.1])
return network
# Prozess erstellen
def forward(network, x):
print ("##### Propagierung starten #####")
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
# Gesamteingabe der verborgenen Ebene
u1 = np.dot(x, W1) + b1
# Gesamtausgabe der ausgeblendeten Ebene
z1 = functions.relu(u1)
# Gesamteingabe der Ausgabeebene
u2 = np.dot(z1, W2) + b2
# Gesamtausgabe der Ausgabeebene
y = functions.sigmoid(u2)
print_vec ("Gesamteingabe 1", u1)
print_vec ("Zwischenschichtausgabe 1", z1)
print_vec ("Gesamteingabe 2", u2)
print_vec ("Ausgabe 1", y)
print ("Gesamtausgabe:" + str (np.sum (z1)))
return y, z1
# Eingegebener Wert
x = np.array([1., 2., 3., 4., 5.])
# Zielausgabe
d = np.array([1])
network = init_network()
y, z1 = forward(network, x)
# Error
loss = functions.cross_entropy_error(d, y)
## Anzeige
print ("\ n ##### Ergebnisanzeige #####")
print_vec ("Zwischenschichtausgabe", z1)
print_vec ("Ausgabe", y)
print_vec ("Trainingsdaten", d)
print_vec ("Fehler", Verlust)
#####Netzwerkinitialisierung##### #####Starten Sie die Vorwärtsausbreitung##### Gesamteingabe 1 [ 3. 6.2 9.4 3. 6.2 9.4 3. 6.2 9.4 11. ]
Zwischenschichtausgabe 1 [ 3. 6.2 9.4 3. 6.2 9.4 3. 6.2 9.4 11. ]
Gesamteingabe 2 [6.78]
Ausgabe 1 [0.99886501]
Gesamtausgabe: 66.8
#####Ergebnisanzeige##### Zwischenschichtausgabe [ 3. 6.2 9.4 3. 6.2 9.4 3. 6.2 9.4 11. ]
Ausgabe [0.99886501]
Trainingsdaten [1]
Error 0.0011355297129812408 ⇒ [Diskussion] Es wurde festgestellt, dass sich das Ausgabeergebnis in Abhängigkeit von der Größe der Zwischenschicht stark ändert. Wie bestimmen Sie die Anzahl der Einheiten? Es fiel mir schwer, mich für die Mittelklasse zu entscheiden. Zögern Sie nicht, denn die Anzahl der Einheiten in der Eingabeebene muss mit der Dimension der Daten übereinstimmen. Und Sie müssen nicht über die Anzahl der Einheiten in der Ausgabeebene nachdenken, wenn Sie so viele Einheiten wie die Anzahl der klassifizierten Klassen vorbereiten. Ich würde gerne herausfinden, ob die Approximation funktioniert, wenn die Anzahl der mittleren Schichten enorm erhöht wird. Ich fand es auch schwierig, Gewichte und Vorurteile festzulegen.
DN15_Jupyter-Übung 2
python
# Lass es uns versuchen #
# Beispielfunktion
# KI, die den Wert von y vorhersagt
def f(x):
y = 3 * x[0] + 2 * x[1]
return y
# Grundeinstellung
def init_network():
# print ("##### Netzwerkinitialisierung #####")
network = {}
nodesNum = 10
network['W1'] = np.random.randn(2, nodesNum)
network['W2'] = np.random.randn(nodesNum)
network['b1'] = np.random.randn(nodesNum)
network['b2'] = np.random.randn()
# print_vec ("Gewicht 1", Netzwerk ['W1'])
# print_vec ("Gewicht 2", Netzwerk ['W2'])
# print_vec ("Bias 1", Netzwerk ['b1'])
# print_vec ("Bias 2", Netzwerk ['b2'])
return network
# Vorwärtsausbreitung
def forward(network, x):
# print ("##### Start der sequentiellen Weitergabe #####")
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
u1 = np.dot(x, W1) + b1
#z1 = functions.relu(u1)
## Lass es uns versuchen
z1 = functions.sigmoid (u1) # Wählen Sie Sigmoid aus und versuchen Sie es
u2 = np.dot(z1, W2) + b2
y = u2
# print_vec ("Gesamteingabe 1", u1)
# print_vec ("Zwischenschichtausgabe 1", z1)
# print_vec ("Gesamteingabe 2", u2)
# print_vec ("Ausgabe 1", y)
# print ("Gesamtausgabe:" + str (np.sum (y)))
return z1, y
# Fehler bei der Weitergabe
def backward(x, d, z1, y):
# print ("\ n ##### Fehler beim Start der Rückübertragung #####")
grad = {}
W1, W2 = network['W1'], network['W2']
b1, b2 = network['b1'], network['b2']
#Delta in der Ausgabeebene
delta2 = functions.d_mean_squared_error(d, y)
Gradient von # b2
grad['b2'] = np.sum(delta2, axis=0)
# W2 Gradient
grad['W2'] = np.dot(z1.T, delta2)
# Delta in der mittleren Schicht
#delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)
## Versuchen wir #Select Sigmaid und versuchen Sie es
delta1 = np.dot(delta2, W2.T) * functions.d_sigmoid(z1)
delta1 = delta1[np.newaxis, :]
Gradient von # b1
grad['b1'] = np.sum(delta1, axis=0)
x = x[np.newaxis, :]
# W1 Gradient
grad['W1'] = np.dot(x.T, delta1)
# print_vec ("teilweise differenziertes_gewicht 1", grad ["W1"])
# print_vec ("teilweise differenziertes Gewicht 2", grad ["W2"])
# print_vec ("teilweise differenzierte_Bias 1", grad ["b1"])
# print_vec ("teilweise differenzierte_Bias 2", grad ["b2"])
return grad
# Erstellen Sie Beispieldaten
data_sets_size = 100000
data_sets = [0 for i in range(data_sets_size)]
for i in range(data_sets_size):
data_sets[i] = {}
# Stellen Sie einen zufälligen Wert ein
# data_sets[i]['x'] = np.random.rand(2)
## Versuchen wir es mit _ Eingabewerteinstellung # Wählen Sie diese Option aus, um es zu versuchen
data_sets [i] ['x'] = np.random.rand (2) * 10 -5 # -5 bis 5 Zufallszahlen
# Zielausgabe einstellen
data_sets[i]['d'] = f(data_sets[i]['x'])
losses = []
# Lernrate
learning_rate = 0.07
# Anzahl der Auszüge
epoch = 1000
# Parameterinitialisierung
network = init_network()
# Zufällige Datenextraktion
random_datasets = np.random.choice(data_sets, epoch)
# Wiederholter Hangabstieg
for dataset in random_datasets:
x, d = dataset['x'], dataset['d']
z1, y = forward(network, x)
grad = backward(x, d, z1, y)
# Gradient auf Parameter anwenden
for key in ('W1', 'W2', 'b1', 'b2'):
network[key] -= learning_rate * grad[key]
# Error
loss = functions.mean_squared_error(d, y)
losses.append(loss)
print ("##### Ergebnisanzeige #####")
lists = range(epoch)
plt.plot(lists, losses, '.')
# Grafik anzeigen
plt.show()
⇒ [Diskussion]
Durch den Wechsel von der Relu-Funktion zur Sigmoid-Funktion wurde die Varianz im Diagramm näher an 0 erweitert. Ebenfalls,-Durch Auswahl einer Zufallszahl von 5 bis 5 wurde die DN16_Fertigstellungsauftrag (Produktionsauftrag)
+(Problem) Erstellen Sie Deep Learninng mit IRIS-Daten
###Design Erstellen Sie ein Modell, das voraussagt, indem Sie IRIS-Daten im Verhältnis 2: 1 zwischen Trainingsdaten und Testdaten trainieren.
- Eingabeebene: 4 Dimensionen *Versteckte Ebene: 6 Dimensionen *Ausgabeebene: 3D (aufgrund eines 3-Klassen-Klassifizierungsproblems) *Bindung zwischen Schichten: Dicht *Eingabeebene → Aktivierungsfunktion für versteckte Ebenen: relu *Versteckte Ebene → Aktivierungsfunktion der Ausgabeebene: Softmax *Optimierung: Gradientenabstiegsmethode *Verlustfunktion: Kreuzentropie
python
import numpy as np
# Hyperparameter
INPUT_SIZE = 4 # Anzahl der Eingabeknoten
HIDDEN_SIZE = 6 # Anzahl der Neuronen in der mittleren Schicht (versteckte Schicht)
OUTPUT_SIZE = 3 # Anzahl der Neuronen in der Ausgabeschicht
TRAIN_DATA_SIZE = 50 # Verwenden Sie TRAIN_DATA_SIZE als Trainingsdaten von 150 Daten. Der Rest wird als Lehrerdaten verwendet.
LEARNING_RATE = 0.1 # Lernrate
EPOCH = 1000 # Anzahl der wiederholten Lernvorgänge (Anzahl der Epochen)
# Daten lesen
# Den Iris-Datensatz finden Sie hier. Da die Daten nach Typ mit einer Überschrift angeordnet sind, bereiten Sie CSV-Daten so vor, dass 150 Daten in 3 Typen und jeweils 10 Fällen gemischt werden.
https://gist.github.com/netj/8836201
x = np.loadtxt('/content/drive/My Drive/DNN_code/data/iris.csv', delimiter=',',skiprows=1, usecols=(0, 1, 2, 3))
raw_t = np.loadtxt('/content/drive/My Drive/DNN_code/data/iris.csv', delimiter=',',skiprows=1,dtype="unicode", usecols=(4,))
t = np.zeros([150])
for i in range(0,150):
vari = raw_t[i]
#print(vari,raw_t[i],i)
if ("Setosa" in vari):
t[i] = int(0)
elif ("Versicolor" in vari):
t[i] = int(1)
elif ("Virginica" in vari):
t[i] = int(2)
else:
print ("Fehler", i)
a = [3, 0, 8, 1, 9]
a = t.tolist()
a_int = [int(n) for n in a]
print(a_int)
a_one_hot = np.identity(10)[a_int]
a_one_hot = np.identity(len(np.unique(a)))[a_int]
print(a_one_hot)
train_x = x[:TRAIN_DATA_SIZE]
train_t = a_one_hot[:TRAIN_DATA_SIZE]
test_x = x[TRAIN_DATA_SIZE:]
test_t = a_one_hot[TRAIN_DATA_SIZE:]
print("train=",TRAIN_DATA_SIZE,train_x,train_t)
print("test=",test_x,test_t)
# Gewichtungs- / Bias-Initialisierung # Der Anfangswert (für die Verwendung von ReLU)
W1 = np.random.randn(INPUT_SIZE, HIDDEN_SIZE) / np.sqrt(INPUT_SIZE) * np.sqrt(2)
W2 = np.random.randn(HIDDEN_SIZE, OUTPUT_SIZE)/ np.sqrt(HIDDEN_SIZE) * np.sqrt(2)
# Vom Anfangswert Null einstellen
b1 = np.zeros(HIDDEN_SIZE)
b2 = np.zeros(OUTPUT_SIZE)
# ReLU-Funktion
def relu(x):
return np.maximum(x, 0)
# Softmax-Funktion
def softmax(x):
if x.ndim == 2:
x = x.T
x = x - np.max(x, axis=0)
y = np.exp(x) / np.sum(np.exp(x), axis=0)
return y.T
x = x --np.max (x) # Überlaufmaßnahmen
return np.exp(x) / np.sum(np.exp(x))
# Kreuzentropiefehler
def cross_entropy_error(y, t):
if y.shape != t.shape:
raise ValueError
if y.ndim == 1:
return - (t * np.log(y)).sum()
elif y.ndim == 2:
return - (t * np.log(y)).sum() / y.shape[0]
else:
raise ValueError
# Vorwärtsausbreitung
def forward(x):
global W1, W2, b1, b2
return softmax(np.dot(relu(np.dot(x, W1) + b1), W2) + b2)
# Testergebnisse testen
test_y = forward(test_x)
print ("Vor dem Lernen =", (test_y.argmax (Achse = 1) == test_t.argmax (Achse = 1)). Summe (), '/', 150 --TRAIN_DATA_SIZE)
# Lernschleife
for i in range(EPOCH):
# Weitergabe mit Datenspeicherung
y1 = np.dot(train_x, W1) + b1
y2 = relu(y1)
train_y = softmax(np.dot(y2, W2) + b2)
# Berechnung der Verlustfunktion
L = cross_entropy_error(train_y, train_t)
wenn i% 100 == 0: # 100 Rest
print("L=",L)
# Gradientenberechnung
a1 = (train_y - train_t) / TRAIN_DATA_SIZE
b2_gradient = a1.sum(axis=0)
W2_gradient = np.dot(y2.T, a1)
a2 = np.dot(a1, W2.T)
a2[y1 <= 0.0] = 0
b1_gradient = a2.sum(axis=0)
W1_gradient = np.dot(train_x.T, a2)
# Parameteraktualisierung
W1 = W1 - LEARNING_RATE * W1_gradient
W2 = W2 - LEARNING_RATE * W2_gradient
b1 = b1 - LEARNING_RATE * b1_gradient
b2 = b2 - LEARNING_RATE * b2_gradient
# Ergebnisanzeige
# L-Wert der endgültigen Trainingsdaten
L = cross_entropy_error(forward(train_x), train_t)
print ("L-Wert der endgültigen Trainingsdaten =", L)
# Testergebnisse testen
test_y = forward(test_x)
print ("Nach dem Lernen =", (test_y.argmax (Achse = 1) == test_t.argmax (Achse = 1)). Summe (), '/', 150 --TRAIN_DATA_SIZE)
(Ergebnis) Vor dem Lernen = 42/ 100 L= 4.550956552060894 L= 0.3239415165787326 L= 0.2170679838829666 L= 0.04933110713361697 L= 0.0273865499319481 L= 0.018217122389043848 L= 0.013351028977015358 L= 0.010399165844496665 L= 0.008444934117102367 L= 0.007068429052588092 L-Wert der endgültigen Trainingsdaten= 0.0060528995955394386 Nach dem Lernen = 89/ 100
⇒ [Diskussion]
- Q1.Was ist der Zweck der Aufgabe? Welche Art von Gerät kann getan werden
Der Zweck der Aufgabe ist es, den grundlegenden Mechanismus des tiefen Lernens durchgehend zu lernen. Sie kann durch Anpassen der Anzahl der Zwischenschichten und der Hyperparameter entwickelt werden. - Q２.Was bedeutet es, eine Aufgabe mit einer Klassifizierungsaufgabe zu lösen?
Für Klassifizierungsaufgaben können Sie lernen, Trainings- und Testdaten zu generieren. - Q３.Was sind IRIS-Daten? Zwei Zeilen
Daten, die für das Lernen von maschinellem Lernen und tiefem Lernen vorbereitet wurden.
Basierend auf der Klassifizierung von drei Arten von Iris werden vier Merkmalsgrößen bereitgestellt.
Recommended Posts