Poprawiam swoją odpowiedź, aby dodać więcej szczegółów dotyczących zapisywania i przywracania modeli.

W (i po) Wersja Tensorflow 0.11:

Zapisz model:

import tensorflow as tf

#Prepare to feed input, i.e. feed_dict and placeholders
w1 = tf.placeholder("float", name="w1")
w2 = tf.placeholder("float", name="w2")
b1= tf.Variable(2.0,name="bias")
feed_dict ={w1:4,w2:8}

#Define a test operation that we will restore
w3 = tf.add(w1,w2)
w4 = tf.multiply(w3,b1,name="op_to_restore")
sess = tf.Session()
sess.run(tf.global_variables_initializer())

#Create a saver object which will save all the variables
saver = tf.train.Saver()

#Run the operation by feeding input
print sess.run(w4,feed_dict)
#Prints 24 which is sum of (w1+w2)*b1 

#Now, save the graph
saver.save(sess, 'my_test_model',global_step=1000)

Przywróć model:

import tensorflow as tf

sess=tf.Session()    
#First let's load meta graph and restore weights
saver = tf.train.import_meta_graph('my_test_model-1000.meta')
saver.restore(sess,tf.train.latest_checkpoint('./'))


# Access saved Variables directly
print(sess.run('bias:0'))
# This will print 2, which is the value of bias that we saved


# Now, let's access and create placeholders variables and
# create feed-dict to feed new data

graph = tf.get_default_graph()
w1 = graph.get_tensor_by_name("w1:0")
w2 = graph.get_tensor_by_name("w2:0")
feed_dict ={w1:13.0,w2:17.0}

#Now, access the op that you want to run. 
op_to_restore = graph.get_tensor_by_name("op_to_restore:0")

print sess.run(op_to_restore,feed_dict)
#This will print 60 which is calculated 

To i Niektóre bardziej zaawansowane przypadki użycia zostały tutaj bardzo dobrze wyjaśnione.

Szybki kompletny samouczek do zapisywania i przywracania modeli Tensorflow

W (i po) TensorFlow w wersji 0.11. 0rc1, możesz zapisać i przywrócić swój model bezpośrednio przez wywołanie tf.train.export_meta_graph i tf.train.import_meta_graph zgodnie z https://www.tensorflow.org/programmers_guide/meta_graph .

Zapisz model

w1 = tf.Variable(tf.truncated_normal(shape=[10]), name='w1')
w2 = tf.Variable(tf.truncated_normal(shape=[20]), name='w2')
tf.add_to_collection('vars', w1)
tf.add_to_collection('vars', w2)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver.save(sess, 'my-model')
# `save` method will call `export_meta_graph` implicitly.
# you will get saved graph files:my-model.meta

Przywróć model

sess = tf.Session()
new_saver = tf.train.import_meta_graph('my-model.meta')
new_saver.restore(sess, tf.train.latest_checkpoint('./'))
all_vars = tf.get_collection('vars')
for v in all_vars:
    v_ = sess.run(v)
    print(v_)

Dla wersji TensorFlow

Zapisane punkty kontrolne zawierają wartości Variable S w modelu, a nie sam model / Wykres, co oznacza, że wykres powinien być taki sam po przywróceniu punktu kontrolnego.

Oto przykład regresji liniowej, gdzie istnieje pętla treningowa, która zapisuje zmienne punkty kontrolne i sekcja oceny, która przywróci zmienne zapisane w poprzednim biegu i obliczy prognozy. Oczywiście można również przywrócić zmienne i Kontynuuj trening, jeśli chcesz.

x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)

w = tf.Variable(tf.zeros([1, 1], dtype=tf.float32))
b = tf.Variable(tf.ones([1, 1], dtype=tf.float32))
y_hat = tf.add(b, tf.matmul(x, w))

...more setup for optimization and what not...

saver = tf.train.Saver()  # defaults to saving all variables - in this case w and b

with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    if FLAGS.train:
        for i in xrange(FLAGS.training_steps):
            ...training loop...
            if (i + 1) % FLAGS.checkpoint_steps == 0:
                saver.save(sess, FLAGS.checkpoint_dir + 'model.ckpt',
                           global_step=i+1)
    else:
        # Here's where you're restoring the variables w and b.
        # Note that the graph is exactly as it was when the variables were
        # saved in a prior training run.
        ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)
        else:
            ...no checkpoint found...

        # Now you can run the model to get predictions
        batch_x = ...load some data...
        predictions = sess.run(y_hat, feed_dict={x: batch_x})

Oto dokumenty dla Variables, które obejmują zapisywanie i przywracanie. A oto dokumenty dla Saver.

Istnieją dwie części modelu, definicja modelu, zapisana przez Supervisor jako graph.pbtxt w katalogu modelu oraz wartości liczbowe tensorów, zapisane w plikach punktów kontrolnych, takich jak model.ckpt-1003418.

Definicja modelu może być przywrócona za pomocą tf.import_graph_def, A wagi są przywracane za pomocą Saver.

Jednak Saver używa specjalnej listy przechowującej kolekcję zmiennych dołączonej do wykresu modelu, a ta kolekcja nie jest inicjalizowana za pomocą import_graph_def, więc nie można użyć dwóch razem w tej chwili (to na naszej mapie drogowej do naprawy). Na razie musisz użyć podejścia Ryana Sepasiego-ręcznie skonstruować Wykres o identycznych nazwach węzłów i użyć Saver, aby załadować do niego wagi.

(Alternatywnie można ją zhakować używając import_graph_def, tworząc zmienne ręcznie i używając tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) dla każdej zmiennej, a następnie używając Saver)

Moje środowisko: Python 3.6, TensorFlow 1.3.0

Choć rozwiązań było wiele, większość z nich opiera się na tf.train.Saver. Kiedy wczytujemy .ckpt zapisaną przez Saver, musimy albo przedefiniować sieć tensorflow, albo użyć jakiejś dziwnej i trudno zapamiętanej nazwy, np. 'placehold_0:0','dense/Adam/Weight:0'. Tutaj polecam użyć tf.saved_model, jeden najprostszy przykład podany poniżej, można dowiedzieć się więcej z służąc Model TensorFlow :

Zapisz model:

import tensorflow as tf

# define the tensorflow network and do some trains
x = tf.placeholder("float", name="x")
w = tf.Variable(2.0, name="w")
b = tf.Variable(0.0, name="bias")

h = tf.multiply(x, w)
y = tf.add(h, b, name="y")
sess = tf.Session()
sess.run(tf.global_variables_initializer())

# save the model
export_path =  './savedmodel'
builder = tf.saved_model.builder.SavedModelBuilder(export_path)

tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
tensor_info_y = tf.saved_model.utils.build_tensor_info(y)

prediction_signature = (
  tf.saved_model.signature_def_utils.build_signature_def(
      inputs={'x_input': tensor_info_x},
      outputs={'y_output': tensor_info_y},
      method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))

builder.add_meta_graph_and_variables(
  sess, [tf.saved_model.tag_constants.SERVING],
  signature_def_map={
      tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
          prediction_signature 
  },
  )
builder.save()

Load the model:

import tensorflow as tf
sess=tf.Session() 
signature_key = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
input_key = 'x_input'
output_key = 'y_output'

export_path =  './savedmodel'
meta_graph_def = tf.saved_model.loader.load(
           sess,
          [tf.saved_model.tag_constants.SERVING],
          export_path)
signature = meta_graph_def.signature_def

x_tensor_name = signature[signature_key].inputs[input_key].name
y_tensor_name = signature[signature_key].outputs[output_key].name

x = sess.graph.get_tensor_by_name(x_tensor_name)
y = sess.graph.get_tensor_by_name(y_tensor_name)

y_out = sess.run(y, {x: 3.0})

Możesz również skorzystać z tego łatwiejszego sposobu.

Krok 1: zainicjalizuj wszystkie zmienne

W1 = tf.Variable(tf.truncated_normal([6, 6, 1, K], stddev=0.1), name="W1")
B1 = tf.Variable(tf.constant(0.1, tf.float32, [K]), name="B1")

Similarly, W2, B2, W3, .....

Krok 2: Zapisz sesję wewnątrz modelu Saver i zapisz ją

model_saver = tf.train.Saver()

# Train the model and save it in the end
model_saver.save(session, "saved_models/CNN_New.ckpt")

Krok 3: Przywróć model

with tf.Session(graph=graph_cnn) as session:
    model_saver.restore(session, "saved_models/CNN_New.ckpt")
    print("Model restored.") 
    print('Initialized')

Krok 4: Sprawdź zmienną

W1 = session.run(W1)
print(W1)

Podczas uruchamiania w innej instancji Pythona, użyj

with tf.Session() as sess:
    # Restore latest checkpoint
    saver.restore(sess, tf.train.latest_checkpoint('saved_model/.'))

    # Initalize the variables
    sess.run(tf.global_variables_initializer())

    # Get default graph (supply your custom graph if you have one)
    graph = tf.get_default_graph()

    # It will give tensor object
    W1 = graph.get_tensor_by_name('W1:0')

    # To get the value (numpy array)
    W1_value = session.run(W1)

W większości przypadków zapisywanie i przywracanie z dysku za pomocą tf.train.Saver jest najlepszą opcją:

... # build your model
saver = tf.train.Saver()

with tf.Session() as sess:
    ... # train the model
    saver.save(sess, "/tmp/my_great_model")

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_great_model")
    ... # use the model

Możesz również zapisać / przywrócić samą strukturę wykresu(szczegóły w dokumentacji MetaGraph ). Domyślnie Saver zapisuje strukturę wykresu do pliku .meta. Możesz zadzwonić import_meta_graph(), aby go przywrócić. Przywraca strukturę wykresu i zwraca Saver, którego można użyć do przywrócenia stanu modelu:

saver = tf.train.import_meta_graph("/tmp/my_great_model.meta")

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_great_model")
    ... # use the model

Są jednak przypadki, w których potrzebujesz czegoś znacznie szybciej. Na przykład, jeśli zaimplementujesz wczesne zatrzymanie, chcesz zapisywać punkty kontrolne za każdym razem, gdy model poprawia się podczas treningu( mierzone na zestawie walidacji), a następnie, jeśli nie ma postępów przez jakiś czas, chcesz wrócić do najlepszego modelu. Jeśli zapiszesz model na dysk za każdym razem, gdy się poprawi, ogromnie spowolni to trening. Sztuczka polega na zapisaniu Stanów zmiennych do pamięci , a następnie przywróceniu ich później:

... # build your model

# get a handle on the graph nodes we need to save/restore the model
graph = tf.get_default_graph()
gvars = graph.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
assign_ops = [graph.get_operation_by_name(v.op.name + "/Assign") for v in gvars]
init_values = [assign_op.inputs[1] for assign_op in assign_ops]

with tf.Session() as sess:
    ... # train the model

    # when needed, save the model state to memory
    gvars_state = sess.run(gvars)

    # when needed, restore the model state
    feed_dict = {init_value: val
                 for init_value, val in zip(init_values, gvars_state)}
    sess.run(assign_ops, feed_dict=feed_dict)

Szybkie wyjaśnienie: kiedy tworzysz zmienna X, TensorFlow automatycznie tworzy operację przypisania X/Assign, aby ustawić wartość początkową zmiennej. Zamiast tworzyć symbole zastępcze i dodatkowe operacje przydziału (które spowodowałyby bałagan na wykresie), po prostu używamy tych istniejących operacji przydziału. Pierwsze wejście każdego przypisania op jest odniesieniem do zmiennej, którą ma zainicjować, a drugie wejście (assign_op.inputs[1]) jest wartością początkową. Aby więc ustawić dowolną wartość (zamiast wartości początkowej), musimy użyć feed_dict i zastąp wartość początkową. Tak, TensorFlow pozwala podać wartość dla każdej operacji, a nie tylko dla elementów zastępczych, więc działa to dobrze.

Jak powiedział Yaroslav, można włamać przywracanie z graph_def i checkpoint importując Wykres, ręcznie tworząc zmienne, a następnie za pomocą wygaszacza.

Zaimplementowałem to na własny użytek, więc pomyślałem, że podzielę się tym kodem tutaj.

Link: https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(jest to oczywiście hack i nie ma gwarancji, że zapisane w ten sposób modele pozostaną czytelne w przyszłych wersjach TensorFlow.)

Jeśli jest to wewnętrznie zapisany model, po prostu określ restorer dla wszystkich zmiennych jako

restorer = tf.train.Saver(tf.all_variables())

I użyj go do przywrócenia zmiennych w bieżącej sesji:

restorer.restore(self._sess, model_file)

Dla modelu zewnętrznego należy określić mapowanie z nazw zmiennych its do nazw zmiennych. Nazwy zmiennych modelu można wyświetlić za pomocą polecenia

python /path/to/tensorflow/tensorflow/python/tools/inspect_checkpoint.py --file_name=/path/to/pretrained_model/model.ckpt

The inspect_checkpoint.py skrypt można znaleźć w './TensorFlow / python / tools' folder źródła Tensorflow.

Aby określić mapowanie, można użyć mojego Tensorflow-Worklab , który zawiera zestaw klas i skryptów do szkolenia i przekwalifikowywania różnych modeli. Zawiera przykład przekwalifikowania modeli ResNet, znajduje się tutaj

Oto moje proste rozwiązanie dla dwóch podstawowych przypadków różniących się tym, czy chcesz załadować Wykres z pliku, czy zbudować go podczas wykonywania.

Ta odpowiedź dotyczy Tensorflow 0.12+ (w tym 1.0).

Przebudowa wykresu w kodzie

Zapisywanie

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.save(sess, 'my-model')

Ładowanie

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.restore(sess, tf.train.latest_checkpoint('./'))
    # now you can use the graph, continue training or whatever

Wczytywanie również wykresu z pliku

Podczas korzystania z tej techniki upewnij się, że wszystkie warstwy/zmienne mają jawnie ustawione unikalne nazwy. W Przeciwnym Razie Tensorflow będzie niech nazwy będą unikalne, a tym samym będą się różnić od nazw przechowywanych w pliku. Nie stanowi to problemu w poprzedniej technice, ponieważ nazwy są "zniekształcone" w ten sam sposób zarówno podczas ładowania, jak i zapisywania.

Zapisywanie

graph = ... # build the graph

for op in [ ... ]:  # operators you want to use after restoring the model
    tf.add_to_collection('ops_to_restore', op)

saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.save(sess, 'my-model')

Ładowanie

with ... as sess:  # your session object
    saver = tf.train.import_meta_graph('my-model.meta')
    saver.restore(sess, tf.train.latest_checkpoint('./'))
    ops = tf.get_collection('ops_to_restore')  # here are your operators in the same order in which you saved them to the collection

Możesz również sprawdzić przykłady w TensorFlow/skflow, który oferuje metody save i restore, które pomogą Ci łatwo zarządzać Twoimi modelami. Ma parametry, które można również kontrolować, jak często chcesz tworzyć kopie zapasowe modelu.

Jeśli używasz tf.pociąg.MonitoredTrainingSession jako domyślna sesja, nie musisz dodawać dodatkowego kodu, aby zapisać / przywrócić rzeczy. Wystarczy podać nazwę katalogu checkpoint do konstruktora MonitoredTrainingSession, aby obsłużyć je za pomocą hooków sesji.

Jak opisano w numerze 6255:

use '**./**model_name.ckpt'
saver.restore(sess,'./my_model_final.ckpt')

Zamiast

saver.restore('my_model_final.ckpt')

Wszystkie odpowiedzi tutaj są świetne, ale chcę dodać dwie rzeczy.

Po pierwsze, aby rozwinąć @user7505159 odpowiedź,"./ "może być ważne, aby dodać na początku nazwy pliku, który przywracasz.

Na przykład, można zapisać wykres bez "./ "w nazwie pliku tak:

# Some graph defined up here with specific names

saver = tf.train.Saver()
save_file = 'model.ckpt'

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    saver.save(sess, save_file)

Ale w celu przywrócenia wykresu, może być konieczne dodanie "./ "do nazwa_pliku:

# Same graph defined up here

saver = tf.train.Saver()
save_file = './' + 'model.ckpt' # String addition used for emphasis

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    saver.restore(sess, save_file)

Należy również wspomnieć, że sess.run(tf.global_variables_initializer()) może być ważne przed przywróceniem sesji.

Jeśli podczas próby przywrócenia zapisanej sesji pojawia się błąd dotyczący niezainicjalizowanych zmiennych, upewnij się, że dodałeś sess.run(tf.global_variables_initializer()) przed linią saver.restore(sess, save_file). Oszczędzi ci to Bólu Głowy.

Eager mode jest również nierozwiązanym pytaniem save/restore, na które nikt nie odpowiedział nawet w dokumentacji, chociaż dokumenty z pewnością twierdzą, że na nie odpowiedzą. Oto nie działający kod, który napisałem, który próbuje użyć klasy Saver wewnątrz tensorflow.contrib.chętny jak tfe. Mój kod na pewno zapisany na dysku... coś zostało zapisane. Problem polega na przywróceniu. Dodałem nawet jawny kod, aby najpierw ręcznie odtworzyć wszystko, a następnie załadować wyuczone parametry:

optimizer = tf.train.AdamOptimizer() #ga
global_step = tf.train.get_or_create_global_step()  # what is a global_step?
model = tf.keras.Sequential([
  tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)),  # input shape required
  tf.keras.layers.Dense(10, activation=tf.nn.relu, kernel_initializer='glorot_uniform'),
  tf.keras.layers.Dense(3)
])
#s = tfe.Saver([optimizer, model, global_step])
s = tfe.Saver([model])
s.restore(file_prefix="/tmp/iris-1")

Przywraca coś wtedy rzuca ValueError:

INFO:tensorflow:Restoring parameters from /tmp/iris-1

---------------------------------------------------------------------------
ValueError...
--> names, slices, dtypes = zip(*restore_specs)