Python/Tensorflow - J'ai formé le réseau de neurones convolutionnels, comment le tester?

Question

J'ai formé un réseau de neurones convolutionnel (CNN) avec les données suivantes que j'avais dans un fichier binaire (étiquette, nom de fichier, les données (pixels)):

[array([2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 
      0, 2, 1, 0, 2, 1, 0]), array(['10_c.jpg', '10_m.jpg', '10_n.jpg', '1_c.jpg', 
      '1_m.jpg', '1_n.jpg', '2_c.jpg', '2_m.jpg', 
      '2_n.jpg', '3_c.jpg', '3_m.jpg', '3_n.jpg', 
      '4_c.jpg', '4_m.jpg', '4_n.jpg', '5_c.jpg', 
      '5_m.jpg', '5_n.jpg', '6_c.jpg', '6_m.jpg', 
      '6_n.jpg', '7_c.jpg', '7_m.jpg', '7_n.jpg', 
      '8_c.jpg', '8_m.jpg', '8_n.jpg', '9_c.jpg', 
      '9_m.jpg', '9_n.jpg'], 
      dtype='<U15'), array([[255, 252, 255, ..., 255, 255, 255], 
      [136, 137, 138, ..., 114, 110, 111], 
      [200, 200, 199, ..., 179, 178, 177], 
      ..., 
      [146, 157, 165, ..., 202, 202, 201], 
      [228, 225, 222, ..., 219, 221, 223], 
      [128, 127, 127, ..., 133, 129, 127]])] 

Chaque lot contient toutes les images, et 30 epohs ont été exécutés:

EPOCH 0 
0 0.476923 
DONE WITH EPOCH 
EPOCH 1 
0 0.615385 
DONE WITH EPOCH 
EPOCH 2 
0 0.615385 
DONE WITH EPOCH 
EPOCH 3 
0 0.538462 
DONE WITH EPOCH 
EPOCH 4 
0 0.384615 
DONE WITH EPOCH 
... 
... 
EPOCH 28 
0 0.615385 
DONE WITH EPOCH 
EPOCH 29 
0 0.692308 
DONE WITH EPOCH 

Ma question est que je voudrais essayer de nouvelles images (test), et je voudrais savoir la classe retournée (0,1,2). Que dois-je faire dans ce cas? En d'autres termes, j'ai formé le CNN, mais comment le tester?

EDIT-1

Pour la évaluation précision le point, j'ai obtenu les résultats suivants lors du test 20 images:

EPOCH 0 
0 1.0 
DONE WITH EPOCH 
EPOCH 1 
0 1.0 
DONE WITH EPOCH 
EPOCH 2 
0 1.0 
DONE WITH EPOCH 
EPOCH 3 
0 1.0 
DONE WITH EPOCH 
EPOCH 4 
0 1.0 
DONE WITH EPOCH 
EPOCH 5 
0 1.0 
DONE WITH EPOCH 
EPOCH 6 
0 1.0 
DONE WITH EPOCH 
EPOCH 7 
0 1.0 
DONE WITH EPOCH 
EPOCH 8 
0 1.0 
DONE WITH EPOCH 
EPOCH 9 
0 1.0 
DONE WITH EPOCH 
EPOCH 10 
0 1.0 
DONE WITH EPOCH 
EPOCH 11 
0 1.0 
DONE WITH EPOCH 
EPOCH 12 
0 1.0 
DONE WITH EPOCH 
EPOCH 13 
0 1.0 
DONE WITH EPOCH 
EPOCH 14 
0 1.0 
DONE WITH EPOCH 
EPOCH 15 
0 1.0 
DONE WITH EPOCH 
EPOCH 16 
0 1.0 
DONE WITH EPOCH 
EPOCH 17 
0 1.0 
DONE WITH EPOCH 
EPOCH 18 
0 1.0 
DONE WITH EPOCH 
EPOCH 19 
0 1.0 
DONE WITH EPOCH 
EPOCH 20 
0 1.0 
DONE WITH EPOCH 
EPOCH 21 
0 1.0 
DONE WITH EPOCH 
EPOCH 22 
0 1.0 
DONE WITH EPOCH 
EPOCH 23 
0 1.0 
DONE WITH EPOCH 
EPOCH 24 
0 1.0 
DONE WITH EPOCH 
EPOCH 25 
0 1.0 
DONE WITH EPOCH 
EPOCH 26 
0 1.0 
DONE WITH EPOCH 
EPOCH 27 
0 1.0 
DONE WITH EPOCH 
EPOCH 28 
0 1.0 
DONE WITH EPOCH 
EPOCH 29 
0 1.0 
DONE WITH EPOCH 

Lors de l'application du Obtenir les étiquettes que le réseau a produit pour données de test point, j'ai obtenu ce qui suit:

EPOCH 0 
0 0.0 
DONE WITH EPOCH 
EPOCH 1 
0 0.0 
DONE WITH EPOCH 
EPOCH 2 
0 0.0 
DONE WITH EPOCH 
EPOCH 3 
0 0.0 
DONE WITH EPOCH 
EPOCH 4 
0 0.0 
DONE WITH EPOCH 
EPOCH 5 
0 0.0 
DONE WITH EPOCH 
EPOCH 6 
0 0.0 
DONE WITH EPOCH 
EPOCH 7 
0 0.0 
DONE WITH EPOCH 
EPOCH 8 
0 0.0 
DONE WITH EPOCH 
EPOCH 9 
0 0.0 
DONE WITH EPOCH 
EPOCH 10 
0 0.0 
DONE WITH EPOCH 
EPOCH 11 
0 0.0 
DONE WITH EPOCH 
EPOCH 12 
0 0.0 
DONE WITH EPOCH 
EPOCH 13 
0 0.0 
DONE WITH EPOCH 
EPOCH 14 
0 0.0 
DONE WITH EPOCH 
EPOCH 15 
0 0.0 
DONE WITH EPOCH 
EPOCH 16 
0 0.0 
DONE WITH EPOCH 
EPOCH 17 
0 0.0 
DONE WITH EPOCH 
EPOCH 18 
0 0.0 
DONE WITH EPOCH 
EPOCH 19 
0 0.0 
DONE WITH EPOCH 
EPOCH 20 
0 0.0 
DONE WITH EPOCH 
EPOCH 21 
0 0.0 
DONE WITH EPOCH 
EPOCH 22 
0 0.0 
DONE WITH EPOCH 
EPOCH 23 
0 0.0 
DONE WITH EPOCH 
EPOCH 24 
0 0.0 
DONE WITH EPOCH 
EPOCH 25 
0 0.0 
DONE WITH EPOCH 
EPOCH 26 
0 0.0 
DONE WITH EPOCH 
EPOCH 27 
0 0.0 
DONE WITH EPOCH 
EPOCH 28 
0 0.0 
DONE WITH EPOCH 
EPOCH 29 
0 0.0 
DONE WITH EPOCH 

Pourquoi est-ce que je reçois 0 ou 1? Avoir ces valeurs a-t-il un sens (c'est-à-dire aucune fraction)?

EDIT-2

Pour Obtenir les étiquettes que le réseau a produit des données d'essai, lors de l'impression sur la valeur de l'étiquette et la précision de chaque époque, je me suis les (étiquettes toujours 0 suivantes, bien que Je me attendais soit 0 ou 2 seulement, et la précision donnée comme 1):

EPOCH 0 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
EPOCH 1 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
EPOCH 2 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
EPOCH 3 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
EPOCH 4 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
EPOCH 5 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
..... 
..... 
EPOCH 28 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 
EPOCH 29 
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 1.0 
DONE WITH EPOCH 

Merci.

Answer 1

Discussion générale

En général, afin de tester le réseau de neurones, vous devez prendre de nouvelles données marquées que vous n'avez pas utilisé pour la formation, appliquer le réseau sur ces données (qui est, appliquer l'alimentation processus avancé), et évaluez l'exactitude du résultat (par rapport aux étiquettes que vous savez être vraies). Si vous n'avez pas de nouvelles données (si vous avez utilisé toutes vos données pour la formation) et que vous ne pouvez pas produire de nouvelles données, je vous suggère de prendre vos données d'entraînement, de les séparer en formation et test, et réexécutez votre procédure d'entraînement sur les données d'entraînement depuis le début. Il est important que les données de test soient des données inutilisées afin de pouvoir évaluer les performances de votre modèle.

évaluation précision

Maintenant, en supposant que vous parlez du réseau de this question, Vous pouvez faire quelque chose comme ça pour mesurer l'exactitude de vos données de test:

accuracy_test = sess.run(accuracy, feed_dict={x: test_data, y: test_onehot_vals}) 

où test_data et test_onehot_vals sont vos images de test (et les étiquettes correspondantes).

Rappelons que pour la formation que vous exécutez la commande suivante:

_, accuracy_val = sess.run([train_op, accuracy], feed_dict={x: batch_data, y: batch_onehot_vals}) 

Notez que je n'ai pas utilisé train_op dans l'évaluation des accuracy_test. Cela est dû au fait que lorsque vous testez votre performance, vous n'optimisez pas les poids ou quoi que ce soit de ce genre (ce que fait train_op). Vous venez d'appliquer le réseau que vous avez actuellement.

Obtenir les étiquettes que le réseau a produit des données d'essai

Enfin, si vous voulez que les étiquettes réelles de vos données de test, vous devez obtenir la valeur de tf.argmax(model_op, 1). Ainsi, vous pouvez le mettre dans une variable séparée, par exemple juste au-dessus de la ligne

correct_pred = tf.equal(tf.argmax(model_op, 1), tf.argmax(y,1)) 

Vous pouvez faire:

res_model=tf.argmax(model_op, 1) 
correct_pred = tf.equal(res_model, tf.argmax(y,1)) 

puis l'évaluer avec accuracy_test comme suit:

res, accuracy_test = sess.run([res_model,accuracy], feed_dict={x: test_data, y: test_onehot_vals}). 

Application du réseau sur des données non-étiquetées

Une fois le test du réseau terminé, et en supposant que vous êtes satisfait des résultats, vous pouvez poursuivre et appliquer le réseau aux données nouvelles et non étiquetées. Par exemple en faisant

res_new = sess.run(res_model, feed_dict={x: new_data}). Notez que pour produire res_model (ce qui signifie simplement appliquer le réseau sur l'entrée), vous n'avez besoin d'aucune étiquette, donc vous n'avez pas besoin de valeurs y dans votre feed_dict. res_new seront les nouvelles étiquettes.