Einführung

Dies ist ein Lernrekord, als ich die Rabbit Challenge mit dem Ziel absolvierte, die Qualifikation der Japan Deep Learning Association (JDLA) E zu bestehen, die am 19. und 20. Januar 2021 stattfinden wird.

Rabbit Challenge ist ein Kurs, der die Unterrichtsmaterialien verwendet, die aus dem aufgezeichneten Video des Schulbesuchskurses "Deep Learning-Kurs, der vor Ort vernichtet werden kann" bearbeitet wurden. Es gibt keine Unterstützung für Fragen, aber es ist ein billiger Kurs (der niedrigste Preis ab Juni 2020) für die E-Qualifikationsprüfung.

Bitte überprüfen Sie die Details über den unten stehenden Link.

Liste der Themen

Angewandte Mathematik Maschinelles Lernen Deep Learning (Tag 1) Deep Learning (Tag 2) Deep Learning (Tag 3) Deep Learning (Tag 4)

Abschnitt 1: Umsetzungsübung

Tensorflow

Lineare Regression

Ändern Sie den Rauschwert für die Funktion $ d = 3x + 2 $

--Ändern Sie die Funktion $ d $ in $ d = -6x + 3 $ und ändern Sie den Rauschwert

→ Es wurde bestätigt, dass der Fehler umso größer und die Vorhersagegenauigkeit umso geringer ist, je größer der Rauschwert ist.

Nichtlineare Regression

Der Rauschwert für die Funktion von $ d = -0,4x ^ 3 + 1,6x ^ 2-2,8x + 1 $ wurde geändert

--Ändern Sie die Funktion $ d $ in $ d = 2.1x ^ 3-1.2x ^ 2-4.8x + 2 $ und ändern Sie den Rauschwert

→ Es wurde bestätigt, dass der Fehler umso größer und die Vorhersagegenauigkeit umso geringer ist, je größer der Rauschwert ist.

Klassifizierung 1 Schicht (mnist)

Klassifizierung 3 Schichten (Mnist)

Versteckte Ebene vergrößern → Es wurde bestätigt, dass die Vorhersagegenauigkeit umso höher ist, je größer die verborgene Schicht ist.
Optimierer ändern

Klassifikation CNN (mnist)

keras

Lineare Regression

Einfaches Perceptron

`Simple_perceptron`


#Modul laden
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
 
#Initialisieren Sie eine Zufallszahl mit einem festen Wert
np.random.seed(0)

#Erstellen eines einfachen Perzeptrons für Sigmoid
model = Sequential()
model.add(Dense(input_dim=2, units=1))
model.add(Activation('sigmoid'))
model.summary()

model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.1))
 
#Trainingseingabe X und korrekte Antwortdaten T.
X = np.array( [[0,0], [0,1], [1,0], [1,1]] )
T = np.array( [[0], [1], [1], [1]] )
 
#Ausbildung
model.fit(X, T, epochs=30, batch_size=1)
 
#Tatsächliche Klassifizierung durch Umleiten des Trainingseingangs
Y = model.predict_classes(X, batch_size=1)

print("TEST")
print(Y == T)

--Np.random.seed (0) in np.random.seed (1) geändert

Da die generierten Zufallszahlen wie unten gezeigt auf unterschiedliche Werte festgelegt sind, ändert sich auch das Lernergebnis.

`python:np.random.seed()`


import numpy as np
 
#Initialisieren Sie eine Zufallszahl mit einem festen Wert
np.random.seed(0)
print(np.random.randn()) -> 1.764052345967664
#Initialisieren Sie eine Zufallszahl mit einem festen Wert
np.random.seed(1)
print(np.random.randn()) -> 1.6243453636632417

Die Anzahl der Epochen wurde auf 100 geändert

Es wurde bestätigt, dass eine Erhöhung der Anzahl der Epochen den Verlust verringerte.

Auf UND-Schaltung und XOR-Schaltung geändert

Es wurde bestätigt, dass die ODER-Schaltung und die UND-Schaltung linear getrennt werden können, aber das XOR kann nicht gelernt werden, da es nicht linear getrennt werden kann.

Ändern Sie die Chargengröße mit ODER-Schaltung auf 10

Es wurde bestätigt, dass der Verlust mit zunehmender Chargengröße zunahm.

Die Anzahl der Epochen wurde auf 300 geändert

Es wurde bestätigt, dass eine Erhöhung der Anzahl der Epochen den Verlust verringerte.

Klassifikation (Iris)

`classifiy_iris`


import matplotlib.pyplot as plt
from sklearn import datasets
iris = datasets.load_iris()
x = iris.data
d = iris.target

from sklearn.model_selection import train_test_split
x_train, x_test, d_train, d_test = train_test_split(x, d, test_size=0.2)

from keras.models import Sequential
from keras.layers import Dense, Activation
# from keras.optimizers import SGD

#Modelleinstellungen
model = Sequential()
model.add(Dense(12, input_dim=4))
model.add(Activation('relu'))
# model.add(Activation('sigmoid'))
model.add(Dense(3, input_dim=12))
model.add(Activation('softmax'))
model.summary()

model.compile(optimizer='sgd', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

history = model.fit(x_train, d_train, batch_size=5, epochs=20, verbose=1, validation_data=(x_test, d_test))
loss = model.evaluate(x_test, d_test, verbose=0)

#Accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.ylabel('accuracy', fontsize=14)
plt.xlabel('epoch', fontsize=14)
plt.legend(['train', 'test'], loc='lower right', fontsize=14)
plt.ylim(0, 1.0)
plt.show()

Die Aktivierungsfunktion der mittleren Schicht wurde auf Sigmoid geändert

→ Eine Abnahme der Genauigkeit wurde bestätigt.

SGD importieren und Optimierer in SGD ändern (lr = 0.1)

→ Es scheint, dass die Variation der Genauigkeit für jede Epoche zugenommen hat.

Klassifikation (mnist)

`classify_mnist`


#Importieren Sie die erforderlichen Bibliotheken
import sys, os
sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
import keras
import matplotlib.pyplot as plt
from data.mnist import load_mnist

(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)

#Verwenden Sie Adam zum Importieren und Optimieren der erforderlichen Bibliotheken
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import Adam

#Modellieren
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
model.summary()

#Chargengröße, Anzahl der Epochen
batch_size = 128
epochs = 20

model.compile(loss='categorical_crossentropy', 
              optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False), 
              metrics=['accuracy'])

history = model.fit(x_train, d_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, d_test))
loss = model.evaluate(x_test, d_test, verbose=0)
print('Test loss:', loss[0])
print('Test accuracy:', loss[1])

# Accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
# plt.ylim(0, 1.0)
plt.show()

Das one_hot_label von load_mnist wurde in False geändert oder die Fehlerfunktion in sparse_categorical_crossentropy geändert → Wenn Sie'categorical_crossentropy'als eine Fehlerfunktion verwenden, muss das Datenformat im Format one_hot_label vorliegen, und wenn Sie'parse_categorical_crossentropy 'verwenden, muss es in einem anderen Format als one_hot_label vorliegen.
Ändern Sie den Wert von Adams Argument → Wenn die Lernrate von 0,0001 auf 0,001 geändert wurde, war die Vorhersagegenauigkeit nahezu gleich, aber die Lerngeschwindigkeit verbesserte sich. Wenn jedoch die Lernrate von 0,001 auf 0,01 geändert wurde, nahm die Vorhersagegenauigkeit ab.

CNN-Klassifikation (mnist)

`classify_mnist_with_CNN`


#Importieren Sie die erforderlichen Bibliotheken
import sys, os
sys.path.append(os.pardir)  #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
import keras
import matplotlib.pyplot as plt
from data.mnist import load_mnist

(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)


#Verarbeitung zur Eingabe als Matrix
batch_size = 128
num_classes = 10
epochs = 20

img_rows, img_cols = 28, 28

x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)


#Verwenden Sie Adam zum Importieren und Optimieren der erforderlichen Bibliotheken
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import Adam

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.summary()

#Chargengröße, Anzahl der Epochen
batch_size = 128
epochs = 20

model.compile(loss='categorical_crossentropy', optimizer=Adam(), metrics=['accuracy'])
history = model.fit(x_train, d_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, d_test))

# Accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
# plt.ylim(0, 1.0)
plt.show()

→ CNN hat bestätigt, dass eine sehr hohe Vorhersagegenauigkeit von 99% oder mehr erzielt werden kann.

CIFAR-10

`classify_cifar10`


#CIFAR-Importieren Sie 10 Datensätze
from keras.datasets import cifar10
(x_train, d_train), (x_test, d_test) = cifar10.load_data()

#CIFAR-10 Normalisierung
from keras.utils import to_categorical
  
#Funktionsnormalisierung
x_train = x_train/255.
x_test = x_test/255.
 
#Klassenetikett 1-heiße Vektorisierung
d_train = to_categorical(d_train, 10)
d_test = to_categorical(d_test, 10)
 
#CNN bauen
import keras
from keras.models import Sequential
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Dense, Dropout, Activation, Flatten
import numpy as np
 
model = Sequential()
 
model.add(Conv2D(32, (3, 3), padding='same',input_shape=x_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
 
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
 
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))
 
#kompilieren
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
 
#Ausbildung
history = model.fit(x_train, d_train, epochs=20)
tf.executing_eagerly()

#Auswertung&Ausgabe des Bewertungsergebnisses
print(model.evaluate(x_test, d_test))

# Accuracy
plt.plot(history.history['accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.show()

#Modell speichern
# model.save('./CIFAR-10.h5')

RNN (Vorhersage der binären Addition)

`RNN (Vorhersage der binären Addition)`


# import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

#Ändern Sie die Protokollierungsstufe
tf.logging.set_verbosity(tf.logging.ERROR)

import numpy as np
import matplotlib.pyplot as plt

import keras
from keras.models import Sequential
from keras.layers.core import Dense, Dropout,Activation
from keras.layers.wrappers import TimeDistributed
from keras.optimizers import SGD
from keras.layers.recurrent import SimpleRNN, LSTM, GRU


#Daten vorbereiten
#Anzahl der Binärziffern
binary_dim = 8
#Maximalwert+ 1
largest_number = pow(2, binary_dim)

# largest_Bereiten Sie Binärzahlen bis zur Nummer vor
binary = np.unpackbits(np.array([range(largest_number)], dtype=np.uint8).T,axis=1)[:, ::-1]


# A,B-Initialisierung(a + b = d)
a_int = np.random.randint(largest_number/2, size=20000)
a_bin = binary[a_int] # binary encoding
b_int = np.random.randint(largest_number/2, size=20000)
b_bin = binary[b_int] # binary encoding

x_int = []
x_bin = []
for i in range(10000):
    x_int.append(np.array([a_int[i], b_int[i]]).T)
    x_bin.append(np.array([a_bin[i], b_bin[i]]).T)

x_int_test = []
x_bin_test = []
for i in range(10001, 20000):
    x_int_test.append(np.array([a_int[i], b_int[i]]).T)
    x_bin_test.append(np.array([a_bin[i], b_bin[i]]).T)

x_int = np.array(x_int)
x_bin = np.array(x_bin)
x_int_test = np.array(x_int_test)
x_bin_test = np.array(x_bin_test)


#Richtige Antwortdaten
d_int = a_int + b_int
d_bin = binary[d_int][0:10000]
d_bin_test = binary[d_int][10001:20000]

model = Sequential()

model.add(SimpleRNN(units=16,
               return_sequences=True,
               input_shape=[8, 2],
               go_backwards=False,
               activation='relu',
               # dropout=0.5,
               # recurrent_dropout=0.3,
               # unroll = True,
            ))
#Ausgabeschicht
model.add(Dense(1, activation='sigmoid', input_shape=(-1,2)))
model.summary()
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.1), metrics=['accuracy'])
# model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])

history = model.fit(x_bin, d_bin.reshape(-1, 8, 1), epochs=5, batch_size=2)

#Ausgabe des Testergebnisses
score = model.evaluate(x_bin_test, d_bin_test.reshape(-1,8,1), verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Epoch 1/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.0810 - accuracy: 0.9156 Epoch 2/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.0029 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 28s 3ms/step - loss: 9.7898e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 28s 3ms/step - loss: 4.8765e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 28s 3ms/step - loss: 3.3379e-04 - accuracy: 1.0000 Test loss: 0.0002865186012966387 Test accuracy: 1.0

Die Anzahl der Ausgangsknoten von RNN wurde auf 128 geändert Epoch 1/5 10000/10000 [==============================] - 29s 3ms/step - loss: 0.0741 - accuracy: 0.9194 Epoch 2/5 10000/10000 [==============================] - 29s 3ms/step - loss: 0.0020 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 29s 3ms/step - loss: 6.9808e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 28s 3ms/step - loss: 4.0773e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 28s 3ms/step - loss: 2.8269e-04 - accuracy: 1.0000 Test loss: 0.0002439875359702302 Test accuracy: 1.0 → Wenn die Anzahl der Ausgabeknoten von 16 auf 128 geändert wurde, verbesserte sich die Vorhersagegenauigkeit.
Die RNN-Ausgangsaktivierungsfunktion wurde auf Sigmoid geändert Epoch 1/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2498 - accuracy: 0.5131 Epoch 2/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2487 - accuracy: 0.5302 Epoch 3/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2469 - accuracy: 0.5481 Epoch 4/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2416 - accuracy: 0.6096 Epoch 5/5 10000/10000 [==============================] - 27s 3ms/step - loss: 0.2166 - accuracy: 0.7125 Test loss: 0.18766544096552618 Test accuracy: 0.7449744939804077 → Wenn die Ausgangsaktivierungsfunktion von ReLU auf Sigmoid geändert wurde, nahm die Vorhersagegenauigkeit ab.
Die RNN-Ausgangsaktivierungsfunktion wurde auf tanh geändert Epoch 1/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.1289 - accuracy: 0.8170 Epoch 2/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.0022 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 28s 3ms/step - loss: 7.1403e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 27s 3ms/step - loss: 4.1603e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 28s 3ms/step - loss: 2.8925e-04 - accuracy: 1.0000 Test loss: 0.00024679134038564263 Test accuracy: 1.0 → Durch Ändern der Ausgabeaktivierungsfunktion von ReLU auf Tanh wurde die Vorhersagegenauigkeit verbessert.
Die Optimierungsmethode wurde auf Adam geändert Epoch 1/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.0694 - accuracy: 0.9385 Epoch 2/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.0012 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 31s 3ms/step - loss: 5.4037e-05 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 31s 3ms/step - loss: 3.3823e-06 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 31s 3ms/step - loss: 2.4213e-07 - accuracy: 1.0000 Test loss: 5.572893907904208e-08 Test accuracy: 1.0 → Als die Optimierungsmethode von sgd auf adam geändert wurde, verbesserte sich die Vorhersagegenauigkeit.
Setzen Sie den RNN-Eingang Dropout auf 0,5 Epoch 1/5 10000/10000 [==============================] - 30s 3ms/step - loss: 0.2324 - accuracy: 0.5875 Epoch 2/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.2106 - accuracy: 0.6230 Epoch 3/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.2046 - accuracy: 0.6264 Epoch 4/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.2032 - accuracy: 0.6244 Epoch 5/5 10000/10000 [==============================] - 30s 3ms/step - loss: 0.1995 - accuracy: 0.6350 Test loss: 0.15461890560702712 Test accuracy: 0.8619986772537231 → Wenn der Eingabe-Dropout auf 0,5 eingestellt war, wurde das Lernen nicht fortgesetzt.
Setzen Sie den rekursiven Ausfall von RNN auf 0,3 Epoch 1/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.1459 - accuracy: 0.8306 Epoch 2/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.0947 - accuracy: 0.9058 Epoch 3/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.0895 - accuracy: 0.9099 Epoch 4/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.0881 - accuracy: 0.9112 Epoch 5/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.0871 - accuracy: 0.9120 Test loss: 0.09418297858566198 Test accuracy: 0.9016276597976685 → Wenn rekursives Dropout auf 0,3 eingestellt wurde, nahm die Vorhersagegenauigkeit ab.
Setzen Sie RNN Unroll auf True Epoch 1/5 10000/10000 [==============================] - 20s 2ms/step - loss: 0.0938 - accuracy: 0.8871 Epoch 2/5 10000/10000 [==============================] - 20s 2ms/step - loss: 0.0032 - accuracy: 0.9999 Epoch 3/5 10000/10000 [==============================] - 20s 2ms/step - loss: 9.4733e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 21s 2ms/step - loss: 5.3410e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 20s 2ms/step - loss: 3.6424e-04 - accuracy: 1.0000 Test loss: 0.0003125413816745379 Test accuracy: 1.0 → Wenn das Abrollen auf True gesetzt ist (Berechnung wird ohne Schleife durchgeführt), wird die Vorhersagegenauigkeit geringfügig verringert. Die Berechnungszeit ist schneller, da der Speicher konsolidiert wurde.

Abschnitt 2: Stärkung des Lernens

Was ist Bestärkungslernen?

Ein Bereich des maschinellen Lernens, der darauf abzielt, Agenten zu erstellen, die ihre Aktionen in der Umgebung auswählen können, um ihre Belohnungen langfristig zu maximieren. → Ein Mechanismus zur Verbesserung des Prinzips der Bestimmung von Maßnahmen auf der Grundlage der Vorteile (Belohnungen), die sich aus Maßnahmen ergeben.

Beim überwachten und unbeaufsichtigten Lernen besteht das Ziel darin, Vorhersagen aus den Daten zu treffen und die in den Daten enthaltenen Muster zu finden. Andererseits ist es beim verstärkten Lernen das Ziel, hervorragende Maßnahmen zu finden. Es ist möglich, das optimale Verhalten vorherzusagen und zu bestimmen, wenn Sie im Voraus über perfekte Kenntnisse der Umgebung verfügen. Bei intensivem Lernen können Sie jedoch Daten sammeln und das optimale Verhalten finden, während Sie auf der Grundlage unvollständigen Wissens handeln. Ich werde gehen.

Q lernen Eine Methode zum Fortschreiten des Lernens durch Aktualisieren der Aktionswertfunktion jedes Mal, wenn eine Aktion ausgeführt wird.
Funktionsnäherungsmethode Eine Methode zur Funktionsnäherung von Wertfunktionen und Richtlinienfunktionen.

Der Kompromiss zwischen Exploration und Nutzung

Wenn Sie immer nur die besten Aktionen basierend auf historischen Daten ausführen, können Sie keine anderen besten Aktionen finden. (Unzureichende Suche) $ \ Longleftrightarrow $ Wenn Sie immer nur unbekannte Aktionen ausführen, können Sie Ihre bisherigen Erfahrungen nicht nutzen (Zustand unzureichender Nutzung).

Bild des verstärkenden Lernens

Aktionswertfunktion

Es gibt zwei Arten von Funktionen, die Werte ausdrücken: die Statuswertfunktion (wenn Sie sich auf einen bestimmten Status konzentrieren) und die Aktionswertfunktion (wenn Sie sich auf den Wert konzentrieren, der Status und Wert kombiniert).

Richtlinienfunktion

Eine Richtlinienfunktion ist eine Funktion, die eine Wahrscheinlichkeit angibt, welche Art von Aktion in einem bestimmten Zustand in einer auf Richtlinien basierenden Lernmethode zur Verstärkung durchgeführt werden soll.

Richtliniengradientenmethode

\theta^{(t+1)} = \theta^{(t)}+\epsilon \nabla J(\theta)

[PYTHON] [Rabbit Challenge (E-Qualifikation)] Deep Learning (Tag 4)

Einführung

Liste der Themen

Abschnitt 1: Umsetzungsübung

Lineare Regression

Nichtlineare Regression

Klassifizierung 1 Schicht (mnist)

Klassifizierung 3 Schichten (Mnist)

Klassifikation CNN (mnist)

Lineare Regression

Einfaches Perceptron

Simple_perceptron

python:np.random.seed()

Klassifikation (Iris)

classifiy_iris

Klassifikation (mnist)

classify_mnist

CNN-Klassifikation (mnist)

classify_mnist_with_CNN

classify_cifar10

RNN (Vorhersage der binären Addition)

RNN (Vorhersage der binären Addition)

Abschnitt 2: Stärkung des Lernens

Was ist Bestärkungslernen?

Der Kompromiss zwischen Exploration und Nutzung

Bild des verstärkenden Lernens

Aktionswertfunktion

Richtlinienfunktion

Richtliniengradientenmethode

`Simple_perceptron`

`python:np.random.seed()`

`classifiy_iris`

`classify_mnist`

`classify_mnist_with_CNN`

`classify_cifar10`

`RNN (Vorhersage der binären Addition)`