«J'aimerais étudier à l'avenir, mais pour le moment, je vais le copier.
main.py
#Modèle d'apprentissage faisant partie de l'IA(réseau neuronal)Créer
# images_placeholder:Espace réservé pour l'image, keep_prob:lieu de taux d'abandon_titulaire devient un argument
#Sort et renvoie la probabilité de chaque étiquette pour l'image d'entrée
def inference(images_placeholder, keep_prob):
#Écart type de poids 0.Initialiser avec une distribution normale de 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Biais par rapport à l'écart type 0.Initialiser avec une distribution normale de 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Créer une couche de convolution
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Créer une couche de regroupement
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
#Entrée de données d'image 28px au format vectoriel*Revenir à l'image 28px(?)。
#Cette fois c'est une image couleur donc 3(1 pour monochrome)
x_image = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
#Créer la première couche de la couche de convolution
with tf.name_scope('conv1') as scope:
#L'argument est[width, height, input, filters]。
# 5px*L'image est filtrée dans une plage de 5 pixels. Puisqu'il s'agit d'une image couleur, l'entrée est 3?
#Détecter 32 fonctionnalités
W_conv1 = weight_variable([5, 5, 3, 32])
#Remplacez la valeur du biais
b_conv1 = bias_variable([32])
#Les pièces susceptibles d'être utiles en tant que fonctions sont laissées, et les pièces qui sont peu susceptibles d'être utilisées comme fonctions sont
#Comprendre qu'il n'est pas traité comme une fonctionnalité comme 0(Fonction Relu)
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
#Création de la couche de pooling 1
# 2*Créez 2 cadres et définissez les caractéristiques du cadre sur 1*Il est bien compressé en 1 minute.
#Ce cadre 2*Comprendre cette diapositive par 2 pour appliquer le travail de compression à l'image entière
#Résumez grossièrement les fonctionnalités subdivisées par une compréhension approximative d'une manière légèrement meilleure(Compresse)
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Création de la deuxième couche de la couche de convolution
with tf.name_scope('conv2') as scope:
#Le filtrage est à nouveau effectué avec la sortie sur la première couche comme entrée sur la seconde couche.
#Détecte 64 fonctionnalités. Pourquoi l'entrée 32?(je veux que tu me dises)
W_conv2 = weight_variable([5, 5, 32, 64])
#Remplacez la valeur du biais(Identique à la première couche)
b_conv2 = bias_variable([64])
#Disposition des fonctionnalités détectées(Identique à la première couche)
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Création de la couche de pooling 2(Identique à la couche ennuyeuse 1)
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Création de la couche 1 entièrement connectée
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
#Convertir l'analyse d'image en vecteur
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
#Comme le premier et le second, il active les fonctionnalités détectées.
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#paramètres d'abandon
#Optimisé uniquement pour les données d'entraînement et pas vraiment utilisable
#Il semble jouer un rôle dans la prévention du «surapprentissage» qui devient l'IA
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Création de la couche 2 entièrement connectée(Lire la couche)
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisation par fonction softmax
#Convertir la sortie du réseau neuronal jusqu'à présent en probabilité de chaque étiquette
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Probabilité de chaque étiquette(Quelque chose comme?)rends le
return y_conv
#Calculez le taux d '"erreur" entre le résultat de la prédiction et la bonne réponse
#logits est le résultat du calcul: float - [batch_size, NUM_CLASSES]
#étiquettes est l'étiquette de réponse correcte: int32 - [batch_size, NUM_CLASSES]
def loss(logits, labels):
#Calcul de l'entropie croisée
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Spécifiez pour afficher dans TensorBoard
tf.summary.scalar("cross_entropy", cross_entropy)
#Valeur du taux d'erreur(cross_entropy)rends le
return cross_entropy
#Erreur(loss)Former un modèle d'apprentissage conçu à l'aide d'une rétropropagation d'erreur basée sur
#Je ne suis pas sûr de ce qui se passe dans les coulisses, mais les poids de chaque couche du modèle d'apprentissage(w)Etc
#Comprendre qu'il est optimisé et ajusté en fonction de l'erreur(?)
# (L'explication du livre "L'intelligence artificielle dépasse-t-elle les humains?")
def training(loss, learning_rate):
#Comme cette fonction fait tout ça
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
#Calculer le taux de réponse correct du résultat de prédiction donné par le modèle d'apprentissage à l'inférence
def accuracy(logits, labels):
#Comparez si l'étiquette de prédiction et l'étiquette de réponse correcte sont égales. Renvoie Vrai s'ils sont identiques
#argmax est l'indice de la partie avec la plus grande valeur dans le tableau(=Le numéro de l'étiquette qui semble être la réponse la plus correcte)rends le
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
#booléen correct_Calculez le taux de réponse correct en changeant la prédiction en flottant
# false:0,true:Convertir en 1 et calculer
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#Configurer pour afficher sur TensorBoard
tf.summary.scalar("accuracy", accuracy)
return accuracy
«Tu ne sais pas, non? Je ne comprends qu'en quelque sorte n