――Ich würde gerne in Zukunft studieren, aber vorerst werde ich es kopieren.
main.py
#Lernmodell Teil der KI(neurales Netzwerk)Erschaffen
# images_placeholder:Platzhalter fuer Bild, keep_prob:Abbrecherquote Ort_Inhaber wird ein Argument
#Gibt die Wahrscheinlichkeit jedes Etiketts für das Eingabebild aus und gibt sie zurück
def inference(images_placeholder, keep_prob):
#Gewichtsstandardabweichung 0.Initialisieren Sie mit einer Normalverteilung von 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Vorspannung zur Standardabweichung 0.Initialisieren Sie mit einer Normalverteilung von 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Erstellen Sie eine Faltungsebene
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Erstellen Sie eine Pooling-Ebene
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
#28px Bilddateneingabe im Vektorformat*Kehren Sie zum 28px-Bild zurück(?)。
#Diesmal ist es ein Farbbild also 3(1 für Monochrom)
x_image = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
#Erstellen Sie die erste Ebene der Faltungsschicht
with tf.name_scope('conv1') as scope:
#Das Argument ist[width, height, input, filters]。
# 5px*Das Bild wird im Bereich von 5 Pixel gefiltert. Da dies ein Farbbild ist, ist die Eingabe 3?
#32 Funktionen erkennen
W_conv1 = weight_variable([5, 5, 3, 32])
#Ersetzen Sie den Bias-Wert
b_conv1 = bias_variable([32])
#Die Teile, die wahrscheinlich als Features nützlich sind, bleiben übrig, und die Teile, die wahrscheinlich nicht als Features verwendet werden, bleiben übrig
#Verstehen, dass es nicht als Feature als 0 behandelt wird(Relu-Funktion)
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
#Erstellung der Pooling-Schicht 1
# 2*Machen Sie 2 Frames und setzen Sie die Features im Frame auf 1*Es wird in 1 Minute schön komprimiert.
#Dieser Rahmen 2*Verstehen Sie diese Folie um 2, um Komprimierungsarbeit auf das gesamte Bild anzuwenden
#Fassen Sie die durch grobes Verständnis unterteilten Merkmale etwas besser zusammen(Kompresse)
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Erzeugung der zweiten Schicht der Faltungsschicht
with tf.name_scope('conv2') as scope:
#Das Filtern wird erneut mit der Ausgabe auf der ersten Ebene als Eingabe auf der zweiten Ebene durchgeführt.
#Erkennt 64 Funktionen. Warum ist Eingabe 32?(Ich möchte, dass du mir sagst)
W_conv2 = weight_variable([5, 5, 32, 64])
#Ersetzen Sie den Bias-Wert(Gleich wie die erste Schicht)
b_conv2 = bias_variable([64])
#Anordnung der erkannten Merkmale(Gleich wie die erste Schicht)
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Erstellung der Pooling-Schicht 2(Gleich wie Bohrschicht 1)
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Erstellung der vollständig verbundenen Schicht 1
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
#Konvertieren Sie die Bildanalyse in einen Vektor
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
#Wie beim ersten und zweiten aktiviert es die erkannten Funktionen.
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#Dropout-Einstellungen
#Nur für Trainingsdaten optimiert und nicht wirklich verwendbar
#Es scheint eine Rolle bei der Verhinderung von "Überlernen" zu spielen, das zur KI wird
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Erstellung der vollständig verbundenen Schicht 2(Ebene lesen)
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisierung durch Softmax-Funktion
#Konvertieren Sie die bisherige Ausgabe des neuronalen Netzwerks in die Wahrscheinlichkeit jedes Labels
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Wahrscheinlichkeit jedes Etiketts(Etwas wie?)Gib es zurück
return y_conv
#Berechnen Sie, wie viel "Fehler" zwischen dem Vorhersageergebnis und der richtigen Antwort lag
#logits ist das Berechnungsergebnis: float - [batch_size, NUM_CLASSES]
#label ist das richtige Antwortetikett: int32 - [batch_size, NUM_CLASSES]
def loss(logits, labels):
#Berechnung der gekreuzten Entropie
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Geben Sie an, dass in TensorBoard angezeigt werden soll
tf.summary.scalar("cross_entropy", cross_entropy)
#Wert der Fehlerrate(cross_entropy)Gib es zurück
return cross_entropy
#Error(loss)Trainieren Sie ein Lernmodell, das mit Hilfe der Fehler-Backpropagation basierend auf entwickelt wurde
#Ich bin mir nicht sicher, was hinter den Kulissen passiert, aber die Gewichte jeder Schicht des Lernmodells(w)Und so weiter
#Verstehen, dass es basierend auf dem Fehler optimiert und angepasst wird(?)
# (Die Erklärung des Buches "Übersteigt künstliche Intelligenz den Menschen?")
def training(loss, learning_rate):
#Wie diese Funktion macht das alles
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
#Berechnen Sie die korrekte Antwortrate des Vorhersageergebnisses, das das Lernmodell bei Inferenz angibt
def accuracy(logits, labels):
#Vergleichen Sie, ob das Vorhersageetikett und das richtige Antwortetikett gleich sind. Gibt True zurück, wenn sie identisch sind
#argmax ist der Index des Teils mit dem größten Wert im Array(=Die Nummer des Etiketts, die die richtigste Antwort zu sein scheint)Gib es zurück
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
#Boolescher Wert korrekt_Berechnen Sie die richtige Antwortrate, indem Sie die Vorhersage in float ändern
# false:0,true:In 1 konvertieren und berechnen
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#Auf TensorBoard anzeigen lassen
tf.summary.scalar("accuracy", accuracy)
return accuracy
»Du weißt es nicht, oder? Ich verstehe nur irgendwie n
Recommended Posts