probleme de sauvegarde et chargement de modele avec tensorflow

Version imprimable

bonjour !
je me tourne vers vous car j'ai un problème au niveau de la sauvegarde et du chargement de modèle de tensorflow.
mon code s'appuie sur l'exemple de mnist_softmax (https://github.com/tensorflow/tensor...ist_softmax.py)

pour sauvegarder le modèle crée et entraînée je me sert de la fonction ( tf.train.Saver() ) et pareil pour restaurer (restore)
mais le problème lors que je fais un batterie de test il recréée une sauvegarde lorsque qu'il trouve plus le fichier alors que normalement il devrait recharger le modèle!
Si vous avez une idée je prend!!
je vous donne mon code

petite precision: -chemin_donnée me permet de charger dans un de mes dossiers spécifique les packetages il vaut mieu mettre None
-je charge des images que je convertie en tableau et que je transmet a tensorflow via data

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#!usr/bin/python3.5
#-*-coding:UTF-8 -*

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import sys
import pickle

from tensorflow.examples.tutorials.mnist import input_data
from numpy import *

import tensorflow as tf
import matplotlib.pyplot as plt

FLAGS = None


def mlb(data, chemin_donnee = None):
	try:
		# creation des variables 
		x = tf.placeholder(tf.float32, [None, 784])
		W = tf.Variable(tf.zeros([784, 10]))
		b = tf.Variable(tf.zeros([10]))
		y = tf.matmul(x, W) + b
		y_ = tf.placeholder(tf.float32, [None, 10])

		cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
		train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

		#sauvegarder
		saver = tf.train.Saver()

		sess = tf.InteractiveSession()
		

		#je restaure les donnée.
		saver.restore(sess, "modeles/basique/model_basique.ckpt")
		print("Model restored.")
		#tf.global_variables_initializer().run()

	except:
		print("fichier non trouver!")

		if not chemin_donnee == None:
			# importation des données
			mnist = input_data.read_data_sets(chemin_donnee, one_hot=True)
		else:
			mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)

		# creation des variables 
		x = tf.placeholder(tf.float32, [None, 784])
		W = tf.Variable(tf.zeros([784, 10]))
		b = tf.Variable(tf.zeros([10]))
		y = tf.matmul(x, W) + b

		#initialisation des variables
		y_ = tf.placeholder(tf.float32, [None, 10])

		cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
		train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)



		sess = tf.InteractiveSession()
		tf.global_variables_initializer().run()

		#entrainement du modele
		for _ in range(1000):
			batch_xs, batch_ys = mnist.train.next_batch(100)
			sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

			# verification de l'entrainement du modele
		correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
		accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
		
		saver = tf.train.Saver()
		#sauvegarde modele
		save_path = saver.save(sess, "modeles/basique/model_basique.ckpt")
		print("Model saved in file: %s" % save_path)

	
	#test modele
	result2 = sess.run(tf.argmax(y,1), feed_dict={x: [data]})
	plt.matshow(tf.reshape(data,(28,28)).eval())
	plt.show()

	print ('resultat ', result2)



if __name__ == "__main__":
	import scipy.ndimage
	from PIL import Image
	version = 3

	if version == 3:
		
		#tableau_img = scipy.ndimage.imread("test/0v0.bmp", flatten=True)
		chiffre = Image.open("test/0v1.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")
		
		chiffre = Image.open("test/0v2.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/0v3.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/0v4.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/0v5.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")


		
		chiffre = Image.open("test/1v1.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/1v2.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/1v3.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/1v4.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

		chiffre = Image.open("test/1v5.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		mlb(data, chemin_donnee= "./MNIST_data")

je reste pour le moment sur du tensorflow tres basique!
en espérant que vous puissiez m'aider!

12/04/2017, 14h14
dev_ggy
Bonjour,

Je reste prudent, mais il me semble que dans ton code tu fais une sauvegarde sans entraîner ton modèle.

Pour cela il faut lancer la fonction run de tensorflow en ajoutant un code proche de ce que tu donnes en exemple sur Github :
Code:

1 2 # Train sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
Au plaisir de te lire.

PS :

Je pense comprendre la confusion que tu fais. La fonction tf.train.Saver() permet non pas de sauvegarder le réseau de neurones, mais les paramètres qui le constitue une fois qu'il est entraîné.

solution trouvé

bonsoir dev_ggy!

merci pour ta reponse mais en faite c'est mon try qui est trop grand et en faite je croyais qu'il charger pas correctement les données mais ça venais des variables sauvegarders en elle meme et donc j'ai remanier mon code!
j'ai changé de façon de travailler en partant du principe que comme les variables sont relativement simple et rapide a initialisé je préfère sauvegarder juste le modèle et recréer les variables avant le chargement. donc problème résolue
au cas ou voila le nouveau code pour ceux qui serais intéressé:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#!usr/bin/python3.5
#-*-coding:UTF-8 -*

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import sys
import pickle

from tensorflow.examples.tutorials.mnist import input_data
from numpy import *

import tensorflow as tf
import matplotlib.pyplot as plt

try:
	import package.utilitaire_debug as ud
except:
	import utilitaire_debug as ud

class machine_learning_basique:

	def __init__ (self, option = {"ch_mnist": "./MNIST_data"}):

		if not isinstance(option, dict):
			raise TypeError("erreur option = {} n'est pas de type dict ".format(type(option)))

		self.option = option
		self.session = None
		self.x = None
		self.y = None
		self.mnist = None

		self.init_machine_learning()


	def test_modele(self, data):
		"""
		methode de classe qui permet de tester le modele
		"""
		if not isinstance(data, ndarray):
			raise TypeError("erreur data = {} n'est pas de type numpy.ndarray ".format(type(data)))	

		ud.print_array_convert(data)
		result2 = self.session.run(tf.argmax(self.y,1), feed_dict={self.x: [data]})
		print ('resultat ', result2)


	def init_machine_learning(self):
		"""
		methode de class qui initialise la creation du modele et sont entrainement 
		"""
		self.mnist  = input_data.read_data_sets(self.option["ch_mnist"], one_hot=True)
		self.x = tf.placeholder(tf.float32, [None, 784], name="x")
		W = tf.Variable(tf.zeros([784, 10]), name="W")
		b = tf.Variable(tf.zeros([10]), name="b")
		self.y  = tf.matmul(self.x, W, name="y") + b
		y_ = tf.placeholder(tf.float32, [None, 10], name="y_")

		cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = y_, logits = self.y ), name="cross_entropy")
		train_step = tf.train.GradientDescentOptimizer(0.5,  name="train_step").minimize(cross_entropy)

		saver = tf.train.Saver()
		self.session = tf.Session()

		print("debut du chargement! ")

		try:
			saver.restore(self.session, "./modeles/basique/model_basique.ckpt")

		except:
			#creation d'un nouveau fichier
			print("le chargement a echouer ! \n creation d'un nouveau modele !")

			init_op = tf.global_variables_initializer()
			self.session.run(init_op)

			#entrainement du modele
			for _ in range(1000):
				batch_xs, batch_ys = self.mnist .train.next_batch(100)
				self.session.run(train_step, feed_dict={self.x: batch_xs, y_: batch_ys})

			# verification de l'entrainement du modele
			correct_prediction = tf.equal(tf.argmax(self.y , 1), tf.argmax(y_, 1))
			accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
			print(self.session.run(accuracy, feed_dict={self.x: self.mnist .test.images, y_: self.mnist .test.labels}))		

			#sauvegarde des données
			save_path = saver.save(self.session, "./modeles/basique/model_basique.ckpt")
			print("Model saved in file: %s" % save_path)

		print("chargement terminer")



if __name__ == "__main__":
	import scipy.ndimage
	from PIL import Image
	version = 2

	#creation et sauvegarde du modele

	if version == 2:

		a = machine_learning_basique()
		
		chiffre = Image.open("test/0v1.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		a.test_modele(data)


		
		chiffre = Image.open("test/0v2.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		a.test_modele(data)

		chiffre = Image.open("test/0v3.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		a.test_modele(data)

		chiffre = Image.open("test/0v4.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		a.test_modele(data)

		chiffre = Image.open("test/0v5.bmp").convert("L")
		data = (255 - array(chiffre.getdata()))/255
		a.test_modele(data)