Python: Deep Learning Tuning

Hyperparameter

Für das neuronale Netzwerkmodell Es gibt einige sogenannte Hyperparameter, die bei der Konfiguration des Netzwerks angepasst werden müssen.

Es gibt viele Hyperparameter, und wenn sie nicht richtig eingestellt sind, werden sie nicht richtig trainiert. Daher ist es beim Erstellen eines neuen Modells erforderlich, die optimalen Hyperparameter zu entwerfen.

Schauen wir uns die Hyperparameter im eigentlichen Code an.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
#Hyperparameter: Aktivierungsfunktion
model.add(Activation("sigmoid"))
#Hyperparameter: Anzahl der ausgeblendeten Ebenen, Anzahl der Einheiten der ausgeblendeten Ebenen
model.add(Dense(128))
model.add(Activation("sigmoid"))
#Hyperparameter: Abbrecherquote (Rate)
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

#Hyperparameter: Lernrate (lr)
sgd = optimizers.SGD(lr=0.01)

#Hyperparameter: Optimierer
#Hyperparameter: Fehlerfunktion (Verlust)
model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

#Hyperparameter: Chargengröße_size)
#Hyperparameter: Epochen
model.fit(X_train, y_train, batch_size=32, epochs=10, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

Netzwerkstruktureinstellungen

Die Anzahl der ausgeblendeten Ebenen und die Anzahl der Einheiten zwischen der Eingabeebene und der Ausgabeebene können frei festgelegt werden. Durch Erhöhen der Anzahl wird es möglich, verschiedene Funktionen auszudrücken.

Wenn jedoch die Anzahl der verborgenen Schichten groß ist, erhöht sich die Schwierigkeit, das Gewicht anzupassen, und der Lernfortschritt verlangsamt sich. Wenn die Anzahl der Einheiten groß ist, wird das Überlernen (ein Zustand mit geringer Generalisierungsleistung) durchgeführt, indem Merkmale mit geringer Bedeutung extrahiert werden. Es wird einfacher sein aufzuwachen. Daher ist es notwendig, eine geeignete Zahl für das Lernen festzulegen, anstatt die Zahl nur blind zu erhöhen.

Betrachten Sie die Netzwerkstruktur basierend auf dem Präzedenzfall, z. B. anhand eines ähnlichen Implementierungsbeispiels.

Als Beispiel

Bestätigen Sie die Auswirkung der Struktur versteckter Ebenen auf das Modelltraining Lassen Sie uns das genaueste Modell aus den folgenden drei vorhersagen.

A: Eine vollständig verbundene verborgene Schicht mit 256 Einheiten und eine vollständig verbundene verborgene Schicht mit 128 Einheiten B: 1 vollständig verbundene verborgene Schicht mit 256 Einheiten, 3 vollständig verbundene verborgene Schichten mit 128 Einheiten C: 1 vollständig verbundene verborgene Schicht mit 256 Einheiten, 1 vollständig verbundene verborgene Schicht mit 1568 Einheiten

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))

def funcA():
    model.add(Dense(128))
    model.add(Activation("sigmoid"))

def funcB():
    model.add(Dense(128))
    model.add(Activation("sigmoid"))
    model.add(Dense(128))
    model.add(Activation("sigmoid"))
    model.add(Dense(128))
    model.add(Activation("sigmoid"))

def funcC():
    model.add(Dense(1568))
    model.add(Activation("sigmoid"))

#Wählen Sie eines der Modelle A, B und C und kommentieren Sie die beiden anderen aus.
#---------------------------
funcA()
funcB()
funcC()
#---------------------------

model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

sgd = optimizers.SGD(lr=0.1)

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, batch_size=32, epochs=3, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))




#Die richtige Antwort lautet funcA()ist.

Aussteigen

Dropout verhindert Übertraining von Trainingsdaten Dies ist eine der Methoden zur Verbesserung der Genauigkeit des Modells.

Löschen Sie im Dropout zufällig Neuronen (überschreiben Sie sie mit 0). Wiederholen Sie das Lernen. Dadurch wird das neuronale Netzwerk zu einem spezifischen Neuron. Sie lernen allgemeinere Funktionen ohne Abhängigkeit.

Die Beschreibung des Aussetzers lautet wie folgt.

model.add(Dropout(rate=0.5))
#rate ist der Prozentsatz der zu löschenden Einheiten.

Sowohl die Ausfallpositionen als auch die Raten sind Hyperparameter.

Implementieren Sie einen Ausfall, um der richtigen Antwortrate für Trainingsdaten und Testdaten näher zu kommen.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))

# ---------------------------
#Hier ist der Code für den Ausfall
model.add(Dropout(rate=0.5))
# ---------------------------

model.add(Dense(10))
model.add(Activation("softmax"))

sgd = optimizers.SGD(lr=0.1)

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

history = model.fit(X_train, y_train, batch_size=32, epochs=5, verbose=1, validation_data=(X_test, y_test))

#acc, val_gem. Grundstück
plt.plot(history.history["acc"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_acc"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

Aktivierungsfunktion

Aktivierungsfunktion

Die Aktivierungsfunktion ist eine Funktion, die nach der vollständig verbundenen Schicht usw. angewendet wird.
Es ist gleichbedeutend mit dem Abfeuern eines Neurons.

In der vollständig verbundenen Schicht wird der Eingang linear transformiert und ausgegeben. Nichtlinearität kann mithilfe der Aktivierungsfunktion hinzugefügt werden.

Wenn die Aktivierungsfunktion nicht verwendet wird, kann sie nicht durch eine einzelne gerade Linie getrennt werden, wie in der folgenden Abbildung gezeigt (eine lineare Trennung ist nicht möglich). Die Daten können nicht klassifiziert werden.

image.png

Durch Nichtlinearität durch die Aktivierungsfunktion Selbst Modelle, die nicht linear voneinander getrennt werden können, können bei entsprechender Schulung immer klassifiziert werden.

Es gibt verschiedene Arten von Aktivierungsfunktionen, daher ist es wichtig, die entsprechende auszuwählen.

Sigmaid-Funktion

Die Sigmoidfunktion ist eine der Aktivierungsfunktionen Der Eingabewert wird auf einen Wert zwischen 0 und 1 gesetzt und ausgegeben. Die Formel lautet wie folgt.

image.png

Die Sigmoidfunktion ist grundsätzlich 1/2 bei X = 0 0 oder mehr und weniger als 1/2, wenn X <0 ist 1/2 oder mehr und weniger als 1, wenn x> 0 ist Es ist geworden.

Das blaue Diagramm ist die Sigmoidfunktion Der orangefarbene Graph ist die Ableitung der Sigmoidfunktion.

ReLU

Als Aktivierungsfunktion, die häufig verwendet wird

Es gibt ReLU (Rampenfunktion).

Diese Funktion nimmt 0, wenn der Eingabewert kleiner als 0 ist, und nimmt den Eingabewert als Ausgabewert, wenn er 0 oder mehr ist.

Die Definitionsformel von ReLU (Rectified Linear Unit) wird angezeigt.

image.png

ReLU (Rampenfunktion) ist grundsätzlich

0 wenn x <0 x => 0 und y = x Es wird sein.

Das blaue Diagramm repräsentiert ReLU und das orangefarbene Diagramm repräsentiert die Ableitung von ReLU.

Verlustfunktion

Verlustfunktion

Eine Funktion, die den Unterschied zwischen Ausgabedaten und Lehrerdaten während des Trainings auswertet

Es wird eine Verlustfunktion (Fehlerfunktion) genannt.

Es ist möglich, mit der richtigen Antwortrate als Index auszuwerten, aber das allein reicht für einzelne Ausgabedaten nicht aus. Ich kenne die detaillierten Ergebnisse wie richtige und falsche Antworten nicht. Mit anderen Worten wird die Verlustfunktion verwendet, um den Unterschied zwischen den einzelnen Ausgabedaten und den Lehrerdaten zu ermitteln.

Es gibt viele Arten von Verlustfunktionen Wird häufig für maschinelles Lernen verwendet

Beispiele sind Quadratfehler und Kreuzentropiefehler.

Wir werden später mehr über diese beiden sprechen.

Zusätzlich wird eine als Fehler-Backpropagation bezeichnete Technik verwendet, um die Berechnung des Differentials der Verlustfunktion effizient zu gestalten. Diese Technik aktualisiert die Gewichte jeder Schicht, um den Unterschied zwischen den Ausgabedaten und den Lehrerdaten zu minimieren.

Durchschnittlicher quadratischer Fehler

Der durchschnittliche quadratische Fehler liegt neben der Methode des minimalen Quadrats
Es ist eine Fehlerfunktion, die häufig in Bereichen wie Statistiken verwendet wird.

Beschreiben Sie mit der folgenden Formel.

image.png

yi ist das Vorhersageetikett und ti ist das richtige Antwortetikett. Da der mittlere quadratische Fehler bei der Bewertung kontinuierlicher Werte gut ist, wird er hauptsächlich als Fehlerfunktion von Regressionsmodellen verwendet.

Da 1 / N eine Konstante ist, die durch die Anzahl der Daten bestimmt wird, kann sie weggelassen werden und die Fehlerfunktion, die einfach die quadratischen Werte der Fehler summiert, kann verwendet werden.

Kreuzentropiefehler

Der Kreuzentropiefehler ist auf die Bewertung der Klassifizierung spezialisiert Es wird hauptsächlich als Fehlerfunktion des Klassifizierungsmodells verwendet. Die Formel lautet wie folgt.

image.png

Darüber hinaus wird im Allgemeinen häufig die folgende Formel verwendet.

image.png

Auf diese Weise sind alle Begriffe mit anderen Bezeichnungen als 1 0. Tatsächlich wird nur der Fehler des richtigen Antwortetiketts berechnet.

image.png

Angenommen, Sie haben eine Ausgabe wie oben. Die Berechnung dieses Kreuzentropiefehlers ist wie folgt.

image.png

Mit anderen Worten, je näher yi an 1 liegt, desto näher ist logyi an 0, sodass der Fehler kleiner wird. Wir können sehen, dass das Prinzip ist, dass wenn y sich 0 nähert, sich logyi -∞ nähert und der Fehler zunimmt.

Optimierungsfunktion

Basierend auf dem durch die Fehlerfunktion differenzierten Wert werden Richtung und Grad bestimmt und das Gewicht aktualisiert. Zu diesem Zeitpunkt, wie man die Lernrate, die Anzahl der Epochen, die Anzahl der vergangenen Gewichtsaktualisierungen usw. überprüft. Mit der Optimierungsfunktion wird ermittelt, ob sich das Gewicht in der Aktualisierung widerspiegelt.

image.png

Optimierungsfunktionen sind Hyperparameter, die vom Menschen angepasst werden müssen. Wie Sie sehen, gibt es verschiedene Arten von Optimierungsfunktionen, die korrekt ausgewählt werden müssen. Seien Sie vorsichtig, da dies das Lernen beeinträchtigen kann.

Lernrate

Die Lernrate bestimmt, um wie viel sich das Gewicht jeder Schicht gleichzeitig ändert. Hyperparameter.

Die folgende Abbildung zeigt das Minimierungsmodell und die Auswirkungen der Lernrate. Der obere rechte Punkt ist der Anfangswert.

image.png

1, Die Lernrate ist zu niedrig und das Update schreitet kaum voran. 2, Mit einer angemessenen Lernrate konvergieren die Werte in einer kleinen Anzahl von Malen. 3, es konvergiert, aber es ist eine Verschwendung beim Aktualisieren, weil der Wert groß ist. 4, Die Lernrate ist zu hoch und die Werte weichen voneinander ab. (Nach oben aktualisiert und der Wert wird immer größer)

Mit anderen Worten, um das Modell richtig zu trainieren, ist es notwendig, eine geeignete Trainingsrate für die Verlustfunktion festzulegen.

#Einstellung der Lernrate
global lr
    lr = #Parameter

Ich habe unten ein Beispiel gezeigt. Bitte passen Sie es an und überprüfen Sie es.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))


def funcA():
    global lr
    lr = 0.01

def funcB():
    global lr
    lr = 0.1

def funcC():
    global lr
    lr = 1.0

#Wählen Sie eine der drei Zeilen aus und kommentieren Sie die beiden anderen Zeilen aus, um die Änderungen zu vergleichen.
#---------------------------
#funcA()
funcB()
#funcC()
#---------------------------

sgd = optimizers.SGD(lr=lr)

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, batch_size=32, epochs=3, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

Mini-Batch-Lernen

Die Anzahl der Daten, die gleichzeitig in das Modell eingegeben werden sollen

Dies wird als Stapelgröße bezeichnet und ist auch einer der Hyperparameter.

Wenn Sie mehr als eine Daten gleichzeitig übergeben, berechnet das Modell den Verlust und den Verlustfunktionsgradienten für jede Daten. Das Gewicht wird nur einmal basierend auf dem Durchschnittswert des Gradienten jeder Daten aktualisiert.

Auf diese Weise wird durch Aktualisieren der Gewichte mit mehreren Daten der Einfluss von verzerrten Daten verringert. Sie können die Berechnungszeit auch verkürzen, indem Sie eine parallele Berechnung durchführen.

Andererseits wird es jedoch schwierig, große Gewichtsaktualisierungen durchzuführen, und es ist für einige Daten optimiert.

Es besteht auch die Möglichkeit, dass Sie nicht aus dem Zustand herauskommen, in dem keine Optimierung für die gesamten Daten durchgeführt wird (lokale Lösung).

Um dies zu vermeiden, wenn viele unregelmäßige Daten vorliegen Erhöhen Sie die Chargengröße, verringern Sie die Chargengröße, wenn sie klein ist usw. Passen Sie die Chargengröße an.

Online lernen(Probabilistische Gradientenabstiegsmethode):Lernmethode zum Festlegen der Stapelgröße auf 1
Batch-Lernen(Die steilste Abstiegsmethode):Lernmethode zum Einstellen der Gesamtzahl der Daten
Mini-Batch-Lernen:Lernmethode, um eine kleine Zahl in die Mitte zu setzen
Wird genannt.
#Anpassung der Chargengröße
global batch_size
    batch_size = #Parameter

Hier ist ein Beispielcode.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

sgd = optimizers.SGD(lr=0.1)

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

def funcA():
    global batch_size
    batch_size = 16

def funcB():
    global batch_size
    batch_size = 32

def funcC():
    global batch_size
    batch_size = 64

#Wählen Sie eine der drei Zeilen aus, kommentieren Sie die beiden anderen Zeilen aus und stapeln Sie sie_Bitte vergleichen Sie die Größe.
#---------------------------
#funcA()
#funcB()
funcC()
#---------------------------

model.fit(X_train, y_train, batch_size=batch_size, epochs=3, verbose=1)

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

Iteratives Lernen

Im Allgemeinen beinhaltet Deep Running iteratives Lernen und wiederholt das Lernen mit denselben Trainingsdaten. Die Anzahl der Trainings wird als Epochennummer bezeichnet, die auch ein Hyperparameter ist.

Das Festlegen einer großen Anzahl von Epochen bedeutet nicht, dass sich die Genauigkeit des Modells weiter verbessert.

Wenn Sie keine angemessene Anzahl von Epochen festlegen, wird die Genauigkeit in der Mitte nicht erhöht. Nicht nur das, sondern auch der Versuch, die Verlustfunktion durch wiederholtes Lernen zu minimieren Dies kann zu Überlernen führen.

Daher ist es auch wichtig, eine angemessene Anzahl von Epochen festzulegen und das Lernen rechtzeitig zu beenden.

#Anzahl der Epochen
global epochs
    epochs = #Parameter

Hier ist ein Beispielcode.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:1500]
X_test = X_test.reshape(X_test.shape[0], 784)[:6000]
y_train = to_categorical(y_train)[:1500]
y_test = to_categorical(y_test)[:6000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
#Ich werde Dropout diesmal nicht verwenden.
#model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

sgd = optimizers.SGD(lr=0.1)

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

def funcA():
    global epochs
    epochs = 5

def funcB():
    global epochs
    epochs = 10

def funcC():
    global epochs
    epochs = 60

#Wählen Sie eine der drei Zeilen aus und kommentieren Sie die beiden anderen Zeilen aus, um die Anzahl der Epochen zu bestimmen.
#---------------------------
#funcA()
funcB()
#funcC()
#---------------------------

history = model.fit(X_train, y_train, batch_size=32, epochs=epochs, verbose=1, validation_data=(X_test, y_test))

#acc, val_gem. Grundstück
plt.plot(history.history["acc"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_acc"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

score = model.evaluate(X_test, y_test, verbose=0)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

Recommended Posts

Python: Deep Learning Tuning
Python Deep Learning
Deep Learning × Python
Python: Deep Learning-Praxis
Deep Running 2 Tuning von Deep Learning
Python lernen
Tiefes Lernen
(Python) Deep Learning Library Chainer-Grundlagen Grundlagen
[Python] Lernnotiz 1
Python-Lernnotizen
Python-Lernausgabe
Deep Learning Memorandum
Python-Lernseite
Python-Lerntag 4
Python-Lernen (Ergänzung)
Python-Lernnotizen
Python: Geschlechtsidentifikation (Entwicklung von Deep Learning) Teil 1
Python: Geschlechtsidentifikation (Entwicklung von Deep Learning) Teil 2
Python-Klasse (Python-Lernnotiz ⑦)
Erstes tiefes Lernen ~ Kampf ~
Python lernen mit ChemTHEATER 03
"Objektorientiert" mit Python gelernt
Python-Modul (Python-Lernnotiz ④)
Erweitertes Lernen 1 Python-Installation
Python lernen mit ChemTHEATER 05-1
Python: Unüberwachtes Lernen: Grundlagen
Deep Learning / Aktivierungsfunktionen
Deep Learning von Grund auf neu
Deep Learning 1 Übung des Deep Learning
Deep Learning / Cross Entropy
Erstes tiefes Lernen ~ Vorbereitung ~
Erstes tiefes Lernen ~ Lösung ~
[Hinweis] Python beim Starten von maschinellem Lernen / Deep Learning [Links]
Videorahmeninterpolation durch tiefes Lernen Teil 1 [Python]
Private Python-Lernprozedur
Python lernen mit ChemTHEATER 02
Ich habe versucht, tief zu lernen
Python: Tiefes Lernen in der Verarbeitung natürlicher Sprache: Grundlagen
Python vs Ruby "Deep Learning von Grund auf neu" Zusammenfassung
Deep Learning Großtechnologie
Python + Unity Enhanced Learning (Lernen)
Python: Überwachtes Lernen (Rückkehr)
Python: Überwachtes Lernen (Klassifizierung)
Erstes tiefes Lernen in C # - Einführung in Python implementieren-
Deep Learning / Softmax-Funktion
Tiefes Lernen mit Python Kapitel 2 (Material für runde Vorlesung)
Deep Python hat von DEAP gelernt
Deep Learning von Grund auf 1-3 Kapitel
Versuchen Sie es mit TensorFlow
O'Reilly python3 Primer Lernnotiz
Deep Learning Gaiden ~ GPU-Programmierung ~
Lernablauf für Python-Anfänger
Python: Überwachtes Lernen: Hyperparameter Teil 1
Python-Lernplan für KI-Lernen
Deep Learning Bilderkennung 1 Theorie
Verbessertes Lernen ab Python
Flache Python-Kopie und tiefe Kopie
Deep Learning / LSTM Scratch Code