Tensorflow에서 모델을 학습 한 후 :

1. 훈련 된 모델을 어떻게 저장합니까?
2. 나중에이 저장된 모델을 어떻게 복원합니까?

문서

• 철저하고 유용한 튜토리얼-> https://www.tensorflow.org/guide/saved_model

• 모델을 저장하는 Keras 상세 안내서-> https://www.tensorflow.org/guide/keras/save_and_serialize

문서에서 :

저장

# Create some variables.
v1 = tf.get_variable("v1", shape=[3], initializer = tf.zeros_initializer)
v2 = tf.get_variable("v2", shape=[5], initializer = tf.zeros_initializer)

inc_v1 = v1.assign(v1+1)
dec_v2 = v2.assign(v2-1)

# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, initialize the variables, do some work, and save the
# variables to disk.
with tf.Session() as sess:
  sess.run(init_op)
  # Do some work with the model.
  inc_v1.op.run()
  dec_v2.op.run()
  # Save the variables to disk.
  save_path = saver.save(sess, "/tmp/model.ckpt")
  print("Model saved in path: %s" % save_path)

복원

tf.reset_default_graph()

# Create some variables.
v1 = tf.get_variable("v1", shape=[3])
v2 = tf.get_variable("v2", shape=[5])

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:
  # Restore variables from disk.
  saver.restore(sess, "/tmp/model.ckpt")
  print("Model restored.")
  # Check the values of the variables
  print("v1 : %s" % v1.eval())
  print("v2 : %s" % v2.eval())

텐서 플로우 2

이것은 여전히 ​​베타 버전이므로 지금은 조언하지 않습니다. 여전히 그 길을 가고 싶다면 tf.saved_model사용 안내서가 있습니다.

텐서 플로우 <2

simple_save

많은 좋은 대답, 완전성을 위해 2 센트를 추가합니다 : simple_save . tf.data.DatasetAPI 를 사용하는 독립형 코드 예제도 있습니다.

파이썬 3; 텐서 플로우 1.14

import tensorflow as tf
from tensorflow.saved_model import tag_constants

with tf.Graph().as_default():
    with tf.Session() as sess:
        ...

        # Saving
        inputs = {
            "batch_size_placeholder": batch_size_placeholder,
            "features_placeholder": features_placeholder,
            "labels_placeholder": labels_placeholder,
        }
        outputs = {"prediction": model_output}
        tf.saved_model.simple_save(
            sess, 'path/to/your/location/', inputs, outputs
        )

복원 :

graph = tf.Graph()
with restored_graph.as_default():
    with tf.Session() as sess:
        tf.saved_model.loader.load(
            sess,
            [tag_constants.SERVING],
            'path/to/your/location/',
        )
        batch_size_placeholder = graph.get_tensor_by_name('batch_size_placeholder:0')
        features_placeholder = graph.get_tensor_by_name('features_placeholder:0')
        labels_placeholder = graph.get_tensor_by_name('labels_placeholder:0')
        prediction = restored_graph.get_tensor_by_name('dense/BiasAdd:0')

        sess.run(prediction, feed_dict={
            batch_size_placeholder: some_value,
            features_placeholder: some_other_value,
            labels_placeholder: another_value
        })

독립형 예

원본 블로그 게시물

다음 코드는 데모를 위해 임의의 데이터를 생성합니다.

1. 플레이스 홀더를 작성하여 시작합니다. 런타임시 데이터를 보유합니다. 그들로부터 우리는를 Dataset만든 다음 그것의를 만듭니다 Iterator. input_tensor모델에 대한 입력으로 사용되는 이터레이터의 생성 된 텐서를 얻습니다 .
2. 모델 자체는 input_tensorGRU 기반 양방향 RNN과 고밀도 분류기 에서 빌드 됩니다. 왜 안돼?
3. 손실은로 softmax_cross_entropy_with_logits최적화되어 Adam있습니다. 에포크 2 개 (각 2 개 배치) 후에 "트레이닝 된"모델을로 저장합니다 tf.saved_model.simple_save. 코드를있는 그대로 실행하면 모델이 simple/현재 작업 디렉토리 에있는 폴더에 저장됩니다 .
4. 새 그래프에서로 저장된 모델을 복원합니다 tf.saved_model.loader.load. 우리는 자리와와 logits 잡아 graph.get_tensor_by_name와 Iterator와 초기화 작업을 graph.get_operation_by_name.
5. 마지막으로 데이터 세트의 두 배치에 대해 유추를 실행하고 저장된 모델과 복원 된 모델이 모두 동일한 값을 생성하는지 확인합니다. 그들이하다!

암호:

import os
import shutil
import numpy as np
import tensorflow as tf
from tensorflow.python.saved_model import tag_constants


def model(graph, input_tensor):
    """Create the model which consists of
    a bidirectional rnn (GRU(10)) followed by a dense classifier

    Args:
        graph (tf.Graph): Tensors' graph
        input_tensor (tf.Tensor): Tensor fed as input to the model

    Returns:
        tf.Tensor: the model's output layer Tensor
    """
    cell = tf.nn.rnn_cell.GRUCell(10)
    with graph.as_default():
        ((fw_outputs, bw_outputs), (fw_state, bw_state)) = tf.nn.bidirectional_dynamic_rnn(
            cell_fw=cell,
            cell_bw=cell,
            inputs=input_tensor,
            sequence_length=[10] * 32,
            dtype=tf.float32,
            swap_memory=True,
            scope=None)
        outputs = tf.concat((fw_outputs, bw_outputs), 2)
        mean = tf.reduce_mean(outputs, axis=1)
        dense = tf.layers.dense(mean, 5, activation=None)

        return dense


def get_opt_op(graph, logits, labels_tensor):
    """Create optimization operation from model's logits and labels

    Args:
        graph (tf.Graph): Tensors' graph
        logits (tf.Tensor): The model's output without activation
        labels_tensor (tf.Tensor): Target labels

    Returns:
        tf.Operation: the operation performing a stem of Adam optimizer
    """
    with graph.as_default():
        with tf.variable_scope('loss'):
            loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
                    logits=logits, labels=labels_tensor, name='xent'),
                    name="mean-xent"
                    )
        with tf.variable_scope('optimizer'):
            opt_op = tf.train.AdamOptimizer(1e-2).minimize(loss)
        return opt_op


if __name__ == '__main__':
    # Set random seed for reproducibility
    # and create synthetic data
    np.random.seed(0)
    features = np.random.randn(64, 10, 30)
    labels = np.eye(5)[np.random.randint(0, 5, (64,))]

    graph1 = tf.Graph()
    with graph1.as_default():
        # Random seed for reproducibility
        tf.set_random_seed(0)
        # Placeholders
        batch_size_ph = tf.placeholder(tf.int64, name='batch_size_ph')
        features_data_ph = tf.placeholder(tf.float32, [None, None, 30], 'features_data_ph')
        labels_data_ph = tf.placeholder(tf.int32, [None, 5], 'labels_data_ph')
        # Dataset
        dataset = tf.data.Dataset.from_tensor_slices((features_data_ph, labels_data_ph))
        dataset = dataset.batch(batch_size_ph)
        iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
        dataset_init_op = iterator.make_initializer(dataset, name='dataset_init')
        input_tensor, labels_tensor = iterator.get_next()

        # Model
        logits = model(graph1, input_tensor)
        # Optimization
        opt_op = get_opt_op(graph1, logits, labels_tensor)

        with tf.Session(graph=graph1) as sess:
            # Initialize variables
            tf.global_variables_initializer().run(session=sess)
            for epoch in range(3):
                batch = 0
                # Initialize dataset (could feed epochs in Dataset.repeat(epochs))
                sess.run(
                    dataset_init_op,
                    feed_dict={
                        features_data_ph: features,
                        labels_data_ph: labels,
                        batch_size_ph: 32
                    })
                values = []
                while True:
                    try:
                        if epoch < 2:
                            # Training
                            _, value = sess.run([opt_op, logits])
                            print('Epoch {}, batch {} | Sample value: {}'.format(epoch, batch, value[0]))
                            batch += 1
                        else:
                            # Final inference
                            values.append(sess.run(logits))
                            print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(epoch, batch, values[-1][0]))
                            batch += 1
                    except tf.errors.OutOfRangeError:
                        break
            # Save model state
            print('\nSaving...')
            cwd = os.getcwd()
            path = os.path.join(cwd, 'simple')
            shutil.rmtree(path, ignore_errors=True)
            inputs_dict = {
                "batch_size_ph": batch_size_ph,
                "features_data_ph": features_data_ph,
                "labels_data_ph": labels_data_ph
            }
            outputs_dict = {
                "logits": logits
            }
            tf.saved_model.simple_save(
                sess, path, inputs_dict, outputs_dict
            )
            print('Ok')
    # Restoring
    graph2 = tf.Graph()
    with graph2.as_default():
        with tf.Session(graph=graph2) as sess:
            # Restore saved values
            print('\nRestoring...')
            tf.saved_model.loader.load(
                sess,
                [tag_constants.SERVING],
                path
            )
            print('Ok')
            # Get restored placeholders
            labels_data_ph = graph2.get_tensor_by_name('labels_data_ph:0')
            features_data_ph = graph2.get_tensor_by_name('features_data_ph:0')
            batch_size_ph = graph2.get_tensor_by_name('batch_size_ph:0')
            # Get restored model output
            restored_logits = graph2.get_tensor_by_name('dense/BiasAdd:0')
            # Get dataset initializing operation
            dataset_init_op = graph2.get_operation_by_name('dataset_init')

            # Initialize restored dataset
            sess.run(
                dataset_init_op,
                feed_dict={
                    features_data_ph: features,
                    labels_data_ph: labels,
                    batch_size_ph: 32
                }

            )
            # Compute inference for both batches in dataset
            restored_values = []
            for i in range(2):
                restored_values.append(sess.run(restored_logits))
                print('Restored values: ', restored_values[i][0])

    # Check if original inference and restored inference are equal
    valid = all((v == rv).all() for v, rv in zip(values, restored_values))
    print('\nInferences match: ', valid)

인쇄됩니다 :

$ python3 save_and_restore.py

Epoch 0, batch 0 | Sample value: [-0.13851789 -0.3087595   0.12804556  0.20013677 -0.08229901]
Epoch 0, batch 1 | Sample value: [-0.00555491 -0.04339041 -0.05111827 -0.2480045  -0.00107776]
Epoch 1, batch 0 | Sample value: [-0.19321944 -0.2104792  -0.00602257  0.07465433  0.11674127]
Epoch 1, batch 1 | Sample value: [-0.05275984  0.05981954 -0.15913513 -0.3244143   0.10673307]
Epoch 2, batch 0 | Final inference | Sample value: [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Epoch 2, batch 1 | Final inference | Sample value: [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]

Saving...
INFO:tensorflow:Assets added to graph.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: b'/some/path/simple/saved_model.pb'
Ok

Restoring...
INFO:tensorflow:Restoring parameters from b'/some/path/simple/variables/variables'
Ok
Restored values:  [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Restored values:  [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]

Inferences match:  True

모델 저장 및 복원에 대한 세부 정보를 추가하기 위해 답변을 개선하고 있습니다.

IN (이후) Tensorflow 버전 0.11 :

모델을 저장하십시오.

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)

모델을 복원하십시오.

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 

이것과 몇 가지 고급 사용 사례가 여기에 잘 설명되어 있습니다.

Tensorflow 모델을 저장하고 복원하는 빠른 전체 자습서

TensorFlow 버전 0.11.0RC1에서 (이후), 당신은 저장하고 호출하여 직접 모델을 복원 tf.train.export_meta_graph하고 tf.train.import_meta_graph에 따라 https://www.tensorflow.org/programmers_guide/meta_graph .

모델 저장

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

모델 복원

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_)

TensorFlow 버전 <0.11.0RC1의 경우 :

저장된 검사 점에는 Variable모델 / 그래프 자체가 아니라 모델의 값이 포함되어 있으므로 검사 점을 복원 할 때 그래프가 동일해야합니다.

다음은 변수 체크 포인트를 저장하는 학습 루프와 이전 실행 및 계산 예측에 저장된 변수를 복원하는 평가 섹션이있는 선형 회귀 분석의 예입니다. 물론 원하는 경우 변수를 복원하고 교육을 계속할 수도 있습니다.

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})

다음은 저장 및 복원에 대한 문서 입니다 Variable. 그리고 여기 문서가 있습니다 가 있습니다 Saver.

내 환경 : Python 3.6, Tensorflow 1.3.0

많은 솔루션이 있었지만 대부분 기반으로 tf.train.Saver합니다. 우리가로드 할 때 .ckpt구원 Saver, 우리는 하나 예를 들어, tensorflow 네트워크를 재정의 또는 어떤 이상하고 어려운 기억하고 이름을 사용해야합니다 'placehold_0:0', 'dense/Adam/Weight:0'. tf.saved_model아래에 주어진 가장 간단한 예 인 을 사용하는 것이 좋습니다 .TensorFlow 모델 제공에서 더 많은 것을 배울 수 있습니다 .

모델을 저장하십시오.

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()

모델을로드하십시오.

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})

모델 에는 모델 디렉토리에서와 Supervisor같이 저장되는 모델 정의 graph.pbtxt와 텐서의 숫자 값과 같은 두 부분이 있습니다.model.ckpt-1003418 .

모델 정의는을 사용하여 복원 할 수 있으며 tf.import_graph_def가중치는Saver .

그러나 Saver모델 그래프에 첨부 된 변수의 특수 콜렉션 보유 목록을 사용하며,이 콜렉션은 import_graph_def를 사용하여 초기화되지 않으므로 현재 둘을 함께 사용할 수 없습니다 (로드맵에서 수정). 지금은 Ryan Sepassi의 접근 방식을 사용해야합니다. 노드 이름이 동일한 그래프를 수동으로 생성 Saver하고 가중치를로드하는 데 사용 합니다.

(또는를 사용하여 import_graph_def수동으로 변수를 생성 tf.add_to_collection(tf.GraphKeys.VARIABLES, variable)하고 각 변수에 대해 사용한 다음을 사용하여 해킹 할 수 있습니다 Saver)

이보다 쉬운 방법도 있습니다.

1 단계 : 모든 변수 초기화

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, .....

2 단계 : 세션을 모델 내부에 Saver저장하고 저장

model_saver = tf.train.Saver()

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

3 단계 : 모델 복원

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

4 단계 : 변수 확인

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

다른 파이썬 인스턴스에서 실행하는 동안

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)

대부분의 경우 a를 사용하여 디스크에서 저장 및 복원하는 tf.train.Saver것이 가장 좋습니다.

... # 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

그래프 구조 자체를 저장 / 복원 할 수도 있습니다 (자세한 내용은 MetaGraph 설명서 참조). 기본적으로 Saver그래프 구조는 .meta파일 로 저장 됩니다. 전화 import_meta_graph()를 걸어 복원 할 수 있습니다 . 그래프 구조 Saver를 복원하고 모델 상태를 복원하는 데 사용할 수있는를 반환합니다 .

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

그러나 훨씬 더 빠른 것이 필요한 경우가 있습니다. 예를 들어, 조기 중지를 구현하는 경우 (검증 세트에서 측정 한대로) 훈련 중에 모델이 개선 될 때마다 체크 포인트를 저장 한 다음 일정 시간 동안 진행되지 않으면 최상의 모델로 롤백하려고합니다. 모델이 향상 될 때마다 모델을 디스크에 저장하면 훈련 속도가 엄청나게 느려집니다. 트릭은 변수 상태를 memory 에 저장 한 다음 나중에 복원하는 것입니다.

... # 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)

간단한 설명 : 변수를 만들 때 XTensorFlow는 자동으로 할당 작업 X/Assign을 만들어 변수의 초기 값을 설정합니다. 자리 표시 자와 추가 할당 op (그래프를 복잡하게 만드는)를 만드는 대신 이러한 기존 할당 op를 사용합니다. 각 할당 op의 첫 번째 입력은 초기화해야하는 변수에 대한 참조이며 두 번째 입력 ( assign_op.inputs[1])은 초기 값입니다. 따라서 초기 값 대신 원하는 값을 설정하려면 a를 사용 feed_dict하고 초기 값을 바꿔야합니다. 예, TensorFlow를 사용하면 자리 표시 자뿐만 아니라 모든 op에 대한 값을 제공 할 수 있으므로 제대로 작동합니다.

Yaroslav가 말했듯이 그래프를 가져오고 변수를 수동으로 만든 다음 Saver를 사용하여 graph_def 및 검사 점에서 복원을 해킹 할 수 있습니다.

나는 개인적인 용도로 이것을 구현했기 때문에 여기에서 코드를 공유 할 수는 있습니다.

링크 : https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(물론 이것은 해킹이므로이 방법으로 저장된 모델이 이후 버전의 TensorFlow에서 계속 읽을 수 있다고 보장 할 수 없습니다.)

내부 저장 모델 인 경우 모든 변수에 대해 복원자를 다음과 같이 지정하면됩니다.

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

현재 세션에서 변수를 복원하는 데 사용하십시오.

restorer.restore(self._sess, model_file)

외부 모델의 경우 변수 이름에서 변수 이름으로의 맵핑을 지정해야합니다. 명령을 사용하여 모델 변수 이름을 볼 수 있습니다

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

inspect_checkpoint.py 스크립트는 Tensorflow 소스의 './tensorflow/python/tools'폴더에 있습니다.

매핑을 지정하기 위해 Tensorflow-Worklab을 사용할 수 있습니다 . 여기에는 다양한 모델을 학습 및 재교육하는 클래스 및 스크립트 세트가 포함되어 있습니다. 여기에있는 ResNet 모델 재교육 예가 포함되어 있습니다 .

다음은 파일에서 그래프를로드 할 것인지 런타임 중에 빌드 할 것인지에 대한 두 가지 기본 사례에 대한 간단한 해결책입니다.

이 답변은 Tensorflow 0.12 이상 (1.0 포함)에 적용됩니다.

코드에서 그래프 재구성

절약

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')

로딩

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

파일에서 그래프도 불러 오기

이 기술을 사용할 때는 모든 레이어 / 변수에 고유 한 이름이 명시 적으로 설정되어 있는지 확인하십시오.그렇지 않으면 Tensorflow가 이름을 고유하게 만들어 파일에 저장된 이름과 다를 수 있습니다. 이전 기술에서는 문제가되지 않습니다. 이름은로드와 저장에서 같은 방식으로 "혼합"되기 때문입니다.

절약

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')

로딩

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

모델을 쉽게 관리하는 데 도움이되는 방법 과 방법을 제공하는 TensorFlow / skflow 에서 예제 를 확인할 수도 있습니다. 모델 백업 빈도를 제어 할 수있는 매개 변수도 있습니다.saverestore

tf.train.MonitoredTrainingSession 을 기본 세션으로 사용하는 경우 저장 / 복원을 위해 코드를 추가 할 필요가 없습니다. 검사 점 디렉토리 이름을 MonitoredTrainingSession의 생성자에게 전달하면 세션 후크를 사용하여 처리합니다.

여기에있는 모든 대답은 훌륭하지만 두 가지를 추가하고 싶습니다.

먼저 @ user7505159의 답변을 자세히 설명하려면 복원중인 파일 이름의 시작 부분에 "./"를 추가해야합니다.

예를 들어 파일 이름에 "./"가없는 그래프를 다음과 같이 저장할 수 있습니다.

# 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)

그러나 그래프를 복원하려면 file_name 앞에 "./"를 추가해야합니다.

# 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)

항상 "./"가 필요하지는 않지만 환경과 버전의 TensorFlow에 따라 문제가 발생할 수 있습니다.

또한 sess.run(tf.global_variables_initializer())세션을 복원하기 전에이 기능이 중요 할 수 있음 을 언급하고자합니다 .

저장된 세션을 복원하려고 할 때 초기화되지 않은 변수와 관련된 오류가 발생 sess.run(tf.global_variables_initializer())하면 saver.restore(sess, save_file)행 앞에 포함시켜야 합니다. 두통을 줄일 수 있습니다.

6255 호에 설명 된대로 :

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

대신에

saver.restore('my_model_final.ckpt')

새로운 Tensorflow 버전에 따르면 tf.train.Checkpoint모델을 저장하고 복원하는 가장 좋은 방법은 다음과 같습니다.

Checkpoint.save및 Checkpoint.restore읽고 쓰기 기록하고 variable.name 기반 체크 포인트를 판독 tf.train.Saver 달리, 체크 포인트 오브젝트 기반. 객체 기반 검사 점은 명명 된 모서리를 가진 Python 객체 (Layers, Optimizer, Variables 등) 간의 종속성 그래프를 저장하며이 그래프는 검사 점을 복원 할 때 변수를 일치시키는 데 사용됩니다. Python 프로그램의 변경 사항에 대해보다 강력 할 수 있으며, 열심히 실행할 때 변수를 만들 때 복원시 지원할 수 있습니다. 선호 tf.train.Checkpoint이상 tf.train.Saver새로운 코드 .

예를 들면 다음과 같습니다.

import tensorflow as tf
import os

tf.enable_eager_execution()

checkpoint_directory = "/tmp/training_checkpoints"
checkpoint_prefix = os.path.join(checkpoint_directory, "ckpt")

checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
status = checkpoint.restore(tf.train.latest_checkpoint(checkpoint_directory))
for _ in range(num_training_steps):
  optimizer.minimize( ... )  # Variables will be restored on creation.
status.assert_consumed()  # Optional sanity checks.
checkpoint.save(file_prefix=checkpoint_prefix)

자세한 내용과 예는 여기에 있습니다.

들어 tensorflow 2.0 , 그것은이다 단순하게

# Save the model
model.save('path_to_my_model.h5')

복원하려면

new_model = tensorflow.keras.models.load_model('path_to_my_model.h5')

tf.keras로 모델 저장 TF2.0

TF1.x를 사용하여 모델을 저장하면 큰 답변을 볼 수 있습니다. tensorflow.keras모델을 저장하는 방법이 많기 때문에 모델을 저장하는 데 더 많은 포인터를 제공하고 싶습니다 .

여기에서는 현재 디렉토리 아래의 폴더에 tensorflow.keras모델을 저장하는 예를 제공합니다 model_path. 이것은 가장 최근의 tensorflow (TF2.0)에서 잘 작동합니다. 가까운 시일 내에 변경 사항이 있으면이 설명을 업데이트하겠습니다.

전체 모델 저장 및로드

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist

#import data
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# create a model
def create_model():
  model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation=tf.nn.relu),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
    ])
# compile the model
  model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
  return model

# Create a basic model instance
model=create_model()

model.fit(x_train, y_train, epochs=1)
loss, acc = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))

# Save entire model to a HDF5 file
model.save('./model_path/my_model.h5')

# Recreate the exact same model, including weights and optimizer.
new_model = keras.models.load_model('./model_path/my_model.h5')
loss, acc = new_model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

모델 무게 저장 및 불러 오기

모델 가중치 만 저장 한 다음 가중치를로드하여 모델을 복원하려는 경우

model.fit(x_train, y_train, epochs=5)
loss, acc = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))

# Save the weights
model.save_weights('./checkpoints/my_checkpoint')

# Restore the weights
model = create_model()
model.load_weights('./checkpoints/my_checkpoint')

loss,acc = model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

keras 검사 점 콜백을 사용하여 저장 및 복원

# include the epoch in the file name. (uses `str.format`)
checkpoint_path = "training_2/cp-{epoch:04d}.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)

cp_callback = tf.keras.callbacks.ModelCheckpoint(
    checkpoint_path, verbose=1, save_weights_only=True,
    # Save weights, every 5-epochs.
    period=5)

model = create_model()
model.save_weights(checkpoint_path.format(epoch=0))
model.fit(train_images, train_labels,
          epochs = 50, callbacks = [cp_callback],
          validation_data = (test_images,test_labels),
          verbose=0)

latest = tf.train.latest_checkpoint(checkpoint_dir)

new_model = create_model()
new_model.load_weights(latest)
loss, acc = new_model.evaluate(test_images, test_labels)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

맞춤 측정 항목으로 모델 저장

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Custom Loss1 (for example) 
@tf.function() 
def customLoss1(yTrue,yPred):
  return tf.reduce_mean(yTrue-yPred) 

# Custom Loss2 (for example) 
@tf.function() 
def customLoss2(yTrue, yPred):
  return tf.reduce_mean(tf.square(tf.subtract(yTrue,yPred))) 

def create_model():
  model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation=tf.nn.relu),  
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
    ])
  model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy', customLoss1, customLoss2])
  return model

# Create a basic model instance
model=create_model()

# Fit and evaluate model 
model.fit(x_train, y_train, epochs=1)
loss, acc,loss1, loss2 = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))

model.save("./model.h5")

new_model=tf.keras.models.load_model("./model.h5",custom_objects={'customLoss1':customLoss1,'customLoss2':customLoss2})

맞춤형 조작으로 keras 모델 저장

다음 사례 ( tf.tile)와 같이 사용자 지정 작업이있는 경우 함수를 만들고 Lambda 레이어로 래핑해야합니다. 그렇지 않으면 모델을 저장할 수 없습니다.

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Input, Lambda
from tensorflow.keras import Model

def my_fun(a):
  out = tf.tile(a, (1, tf.shape(a)[0]))
  return out

a = Input(shape=(10,))
#out = tf.tile(a, (1, tf.shape(a)[0]))
out = Lambda(lambda x : my_fun(x))(a)
model = Model(a, out)

x = np.zeros((50,10), dtype=np.float32)
print(model(x).numpy())

model.save('my_model.h5')

#load the model
new_model=tf.keras.models.load_model("my_model.h5")

tf.keras 모델을 저장하는 여러 가지 방법 중 일부를 다루었다고 생각합니다. 그러나 다른 많은 방법이 있습니다. 사용 사례가 위에서 다루지 않은 경우 아래에 의견을 보내주십시오. 감사!

tf.train.Saver를 사용하여 모델을 저장하고, 모델 크기를 줄이려면 var_list를 지정해야합니다. val_list는 tf.trainable_variables 또는 tf.global_variables 일 수 있습니다.

다음을 사용 하여 네트워크에 변수를 저장할 수 있습니다

saver = tf.train.Saver() 
saver.save(sess, 'path of save/fileName.ckpt')

나중에 또는 다른 스크립트에서 재사용 할 수 있도록 네트워크 를 복원 하려면 다음을 사용하십시오.

saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('path of save/')
sess.run(....) 

중요한 점 :

1. sess 첫 번째 실행과 이후 실행 사이에 동일해야합니다 (일관된 구조).
2. saver.restore 개별 파일 경로가 아닌 저장된 파일의 폴더 경로가 필요합니다.

모델을 저장하려는 모든 곳에서

self.saver = tf.train.Saver()
with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            ...
            self.saver.save(sess, filename)

tf.Variable나중에 이름을 사용하여 복원 할 수 있으므로 모든 이름이 있는지 확인하십시오 . 그리고 당신이 예측하고 싶은 곳,

saver = tf.train.import_meta_graph(filename)
name = 'name given when you saved the file' 
with tf.Session() as sess:
      saver.restore(sess, name)
      print(sess.run('W1:0')) #example to retrieve by variable name

보호기가 해당 세션 내에서 실행되는지 확인하십시오. 를 사용 tf.train.latest_checkpoint('./')하면 최신 확인 지점 만 사용됩니다.

나는 버전에 있습니다 :

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

간단한 방법은

저장:

model.save("model.h5")

복원:

model = tf.keras.models.load_model("model.h5")

텐서 플로우 2.0

매우 간단합니다.

import tensorflow as tf

저장

model.save("model_name")

복원

model = tf.keras.models.load_model('model_name')

@Vishnuvardhan Janapati의 답변에 따라 TensorFlow 2.0.0 에서 사용자 정의 레이어 / 메트릭 / 손실로 모델을 저장하고 다시로드하는 또 다른 방법이 있습니다.

import tensorflow as tf
from tensorflow.keras.layers import Layer
from tensorflow.keras.utils.generic_utils import get_custom_objects

# custom loss (for example)  
def custom_loss(y_true,y_pred):
  return tf.reduce_mean(y_true - y_pred)
get_custom_objects().update({'custom_loss': custom_loss}) 

# custom loss (for example) 
class CustomLayer(Layer):
  def __init__(self, ...):
      ...
  # define custom layer and all necessary custom operations inside custom layer

get_custom_objects().update({'CustomLayer': CustomLayer})  

이러한 방법으로, 당신은 코드를 실행하고, 일단 귀하의 모델을 저장 tf.keras.models.save_model하거나 model.save또는 ModelCheckpoint단순하게, 당신은, 정확한 사용자 정의 개체의 필요없이 모델을 다시로드 할 수 있습니다 콜백

new_model = tf.keras.models.load_model("./model.h5"})

tensorflow 2.0의 새 버전에서는 모델 저장 /로드 프로세스가 훨씬 쉽습니다. Keras API의 구현으로 인해 TensorFlow의 고급 API입니다.

모델을 저장하려면 다음을 참조하십시오. 설명서는 https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/save_model

tf.keras.models.save_model(model_name, filepath, save_format)

모델을로드하려면

https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/load_model

model = tf.keras.models.load_model(filepath)

여기에 사용하는 간단한 예입니다 Tensorflow 2.0 SavedModel의 형식 (권장 형식 인 워드 프로세서에 따라 ) 너무 많은 공상에 가지 않고 Keras 기능 API를 사용하여 간단한 MNIST 데이터 세트 분류기는 :

# Imports
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Flatten
from tensorflow.keras.models import Model
import matplotlib.pyplot as plt

# Load data
mnist = tf.keras.datasets.mnist # 28 x 28
(x_train,y_train), (x_test, y_test) = mnist.load_data()

# Normalize pixels [0,255] -> [0,1]
x_train = tf.keras.utils.normalize(x_train,axis=1)
x_test = tf.keras.utils.normalize(x_test,axis=1)

# Create model
input = Input(shape=(28,28), dtype='float64', name='graph_input')
x = Flatten()(input)
x = Dense(128, activation='relu')(x)
x = Dense(128, activation='relu')(x)
output = Dense(10, activation='softmax', name='graph_output', dtype='float64')(x)
model = Model(inputs=input, outputs=output)

model.compile(optimizer='adam',
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

# Train
model.fit(x_train, y_train, epochs=3)

# Save model in SavedModel format (Tensorflow 2.0)
export_path = 'model'
tf.saved_model.save(model, export_path)

# ... possibly another python program 

# Reload model
loaded_model = tf.keras.models.load_model(export_path) 

# Get image sample for testing
index = 0
img = x_test[index] # I normalized the image on a previous step

# Predict using the signature definition (Tensorflow 2.0)
predict = loaded_model.signatures["serving_default"]
prediction = predict(tf.constant(img))

# Show results
print(np.argmax(prediction['graph_output']))  # prints the class number
plt.imshow(x_test[index], cmap=plt.cm.binary)  # prints the image

무엇입니까 serving_default?

선택한 태그 의 서명 정의 이름입니다 (이 경우 기본 serve태그가 선택됨). 또한, 여기에 사용하는 모델의 태그의 및 서명을 찾는 방법을 설명합니다 saved_model_cli.

면책

이것은 당신이 그것을 시작하고 실행하려는 경우에 단지 기본적인 예이지만, 결코 완전한 대답은 아닙니다-아마 나중에 업데이트 할 수 있습니다. 방금 간단한 예제를 사용하고 싶었습니다.SavedModel TF 2.0에서 왜냐하면이 단순한 곳조차도 보지 못했기 때문입니다.

@ Tom 의 대답은 SavedModel 예제이지만 불행히도 몇 가지 주요 변경 사항이 있기 때문에 Tensorflow 2.0에서는 작동하지 않습니다.

@ Vishnuvardhan Janapati 의 답변에 TF 2.0이 있지만 SavedModel 형식은 아닙니다.