이 페이지는 Cloud Translation API를 통해 번역되었습니다.
Switch to English

모듈, 레이어 및 모델 소개

TensorFlow.org에서보기 Google Colab에서 실행 GitHub에서 소스보기 노트북 다운로드

머신 러닝 TensorFlow를 수행하려면 모델을 정의, 저장 및 복원해야 할 수 있습니다.

모델은 추상적으로 다음과 같습니다.

  • 텐서에서 무언가를 계산하는 함수 ( 정방향 패스 )
  • 훈련에 대한 응답으로 업데이트 할 수있는 일부 변수

이 가이드에서는 Keras의 표면 아래로 이동하여 TensorFlow 모델이 어떻게 정의되는지 확인합니다. TensorFlow가 변수와 모델을 수집하는 방법과 저장 및 복원 방법을 살펴 봅니다.

설정

import tensorflow as tf
from datetime import datetime

%load_ext tensorboard

TensorFlow에서 모델 및 레이어 정의

대부분의 모델은 레이어로 구성됩니다. 레이어는 재사용 할 수 있고 학습 가능한 변수를 가질 수있는 알려진 수학적 구조를 가진 함수입니다. TensorFlow에서 Keras 또는 Sonnet과 같은 계층 및 모델의 대부분의 고수준 구현은 동일한 기본 클래스 인 tf.Module 됩니다.

다음은 스칼라 텐서에서 작동하는 매우 간단한 tf.Module 의 예입니다.

class SimpleModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)
    self.a_variable = tf.Variable(5.0, name="train_me")
    self.non_trainable_variable = tf.Variable(5.0, trainable=False, name="do_not_train_me")
  def __call__(self, x):
    return self.a_variable * x + self.non_trainable_variable

simple_module = SimpleModule(name="simple")

simple_module(tf.constant(5.0))
<tf.Tensor: shape=(), dtype=float32, numpy=30.0>

모듈과 레이어는 확장하여 "객체"에 대한 딥 러닝 용어입니다. 내부 상태와 해당 상태를 사용하는 메서드가 있습니다.

파이썬 콜 __call__ 처럼 행동하는 것 외에는 __call__ 특별한 것이 없습니다. 원하는 기능으로 모델을 호출 할 수 있습니다.

미세 조정 중 레이어 및 변수 고정을 포함하여 어떤 이유로 든 변수의 학습 가능성을 설정 및 해제 할 수 있습니다.

tf.Module 을 서브 클래 싱하면이 객체의 속성에 할당 된 모든 tf.Variable 또는 tf.Module 인스턴스가 자동으로 수집됩니다. 이를 통해 변수를 저장 및로드 할 수 있으며 tf.Module 컬렉션을 만들 수도 있습니다.

# All trainable variables
print("trainable variables:", simple_module.trainable_variables)
# Every variable
print("all variables:", simple_module.variables)
trainable variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>,)
all variables: (<tf.Variable 'train_me:0' shape=() dtype=float32, numpy=5.0>, <tf.Variable 'do_not_train_me:0' shape=() dtype=float32, numpy=5.0>)

모듈로 구성된 2 계층 선형 계층 모델의 예입니다.

먼저 고밀도 (선형) 레이어 :

class Dense(tf.Module):
  def __init__(self, in_features, out_features, name=None):
    super().__init__(name=name)
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def __call__(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

그런 다음 두 개의 레이어 인스턴스를 만들고 적용하는 완전한 모델입니다.

class SequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model!
my_model = SequentialModule(name="the_model")

# Call it, with random results
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[0.        0.4145088]], shape=(1, 2), dtype=float32)

tf.Module 인스턴스는 할당 된 tf.Variable 또는 tf.Module 인스턴스를 tf.Variable 으로 자동으로 수집합니다. 이를 통해 단일 모델 인스턴스로 tf.Module 컬렉션을 관리하고 전체 모델을 저장 및로드 할 수 있습니다.

print("Submodules:", my_model.submodules)

Submodules: (<__main__.Dense object at 0x7fbf9e6919b0>, <__main__.Dense object at 0x7fbfb1f266a0>)

for var in my_model.variables:
  print(var, "\n")
<tf.Variable 'b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 3) dtype=float32, numpy=
array([[ 1.8794332 ,  0.25367785, -1.5451777 ],
       [-0.7285093 ,  0.4250832 , -0.90914494],
       [-0.35409355, -1.463105  ,  0.27016956]], dtype=float32)> 

<tf.Variable 'b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)> 

<tf.Variable 'w:0' shape=(3, 2) dtype=float32, numpy=
array([[-0.20271134,  0.26009855],
       [ 0.49689794, -2.9020948 ],
       [-0.91616786, -0.7842423 ]], dtype=float32)> 


변수 생성 대기

여기서 레이어에 대한 입력 및 출력 크기를 모두 정의해야한다는 것을 알 수 있습니다. 이것은 w 변수가 알려진 모양을 가지므로 할당 될 수 있습니다.

특정 입력 모양으로 모듈이 처음 호출 될 때까지 변수 생성을 연기하면 입력 크기를 미리 지정할 필요가 없습니다.

class FlexibleDenseModule(tf.Module):
  # Note: No need for `in+features`
  def __init__(self, out_features, name=None):
    super().__init__(name=name)
    self.is_built = False
    self.out_features = out_features

  def __call__(self, x):
    # Create variables on first call.
    if not self.is_built:
      self.w = tf.Variable(
        tf.random.normal([x.shape[-1], self.out_features]), name='w')
      self.b = tf.Variable(tf.zeros([self.out_features]), name='b')
      self.is_built = True

    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)
# Used in a module
class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = FlexibleDenseModule(out_features=3)
    self.dense_2 = FlexibleDenseModule(out_features=2)

  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

my_model = MySequentialModule(name="the_model")
print("Model results:", my_model(tf.constant([[2.0, 2.0, 2.0]])))
Model results: tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)

이러한 유연성 때문에 TensorFlow 레이어는 종종 입력 및 출력 크기가 아닌 tf.keras.layers.Dense 와 같이 출력의 모양 만 지정하면됩니다.

무게 저장

tf.Module체크 포인트SavedModel 모두로 저장할 수 있습니다.

체크 포인트는 단지 가중치 (즉, 모듈 및 하위 모듈 내부의 변수 세트 값)입니다.

chkp_path = "my_checkpoint"
checkpoint = tf.train.Checkpoint(model=my_model)
checkpoint.write(chkp_path)
checkpoint.write(chkp_path)
'my_checkpoint'

체크 포인트는 데이터 자체와 메타 데이터 용 색인 파일이라는 두 가지 종류의 파일로 구성됩니다. 인덱스 파일은 실제로 저장된 항목과 체크 포인트 번호를 추적하는 반면 체크 포인트 데이터에는 변수 값과 해당 속성 조회 경로가 포함됩니다.

ls my_checkpoint*
my_checkpoint.data-00000-of-00001  my_checkpoint.index

체크 포인트 내부를 살펴보면 전체 변수 모음이 저장되고 변수가 포함 된 Python 객체별로 정렬되어 있는지 확인할 수 있습니다.

tf.train.list_variables(chkp_path)
[('_CHECKPOINTABLE_OBJECT_GRAPH', []),
 ('model/dense_1/b/.ATTRIBUTES/VARIABLE_VALUE', [3]),
 ('model/dense_1/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 3]),
 ('model/dense_2/b/.ATTRIBUTES/VARIABLE_VALUE', [2]),
 ('model/dense_2/w/.ATTRIBUTES/VARIABLE_VALUE', [3, 2])]

분산 (다중 머신) 훈련 중에 분할 할 수 있으므로 번호가 지정됩니다 (예 : '00000-of-00001'). 하지만이 경우에는 샤드가 하나만 있습니다.

모델을 다시로드하면 Python 객체의 값을 덮어 씁니다.

new_model = MySequentialModule()
new_checkpoint = tf.train.Checkpoint(model=new_model)
new_checkpoint.restore("my_checkpoint")

# Should be the same result as above
new_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[0., 0.]], dtype=float32)>

저장 기능

TensorFlow는 TensorFlow ServingTensorFlow Lite 에서 볼 수 있듯이 원래 Python 객체 없이도 모델을 실행할 수 있으며 TensorFlow Hub 에서 학습 된 모델을 다운로드 할 때도 가능합니다.

TensorFlow는 Python에 설명 된 계산을 수행하는 방법을 알아야하지만 원본 코드는 없습니다 . 이를 위해 이전 가이드 에서 설명한 그래프를 만들 수 있습니다.

이 그래프에는 함수를 구현하는 연산 또는 ops 가 포함됩니다.

이 코드가 그래프로 실행되어야 함을 나타 내기 위해 @tf.function 데코레이터를 추가하여 위 모델에서 그래프를 정의 할 수 있습니다.

class MySequentialModule(tf.Module):
  def __init__(self, name=None):
    super().__init__(name=name)

    self.dense_1 = Dense(in_features=3, out_features=3)
    self.dense_2 = Dense(in_features=3, out_features=2)

  @tf.function
  def __call__(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a model with a graph!
my_model = MySequentialModule(name="the_model")

당신이 만든 모듈은 이전과 똑같이 작동합니다. 함수에 전달 된 각 고유 서명은 별도의 그래프를 생성합니다. 자세한 내용 은 그래프 가이드 를 참조하세요.

print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0.        0.3236845]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0.        0.3236845]
  [0.        0.3236845]]], shape=(1, 2, 2), dtype=float32)

TensorBoard 요약 내에서 그래프를 추적하여 그래프를 시각화 할 수 있습니다.

# Set up logging.
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
logdir = "logs/func/%s" % stamp
writer = tf.summary.create_file_writer(logdir)

# Create a new model to get a fresh trace
# Otherwise the summary will not see the graph.
new_model = MySequentialModule()

# Bracket the function call with
# tf.summary.trace_on() and tf.summary.trace_export().
tf.summary.trace_on(graph=True, profiler=True)
# Call only one tf.function when tracing.
z = print(new_model(tf.constant([[2.0, 2.0, 2.0]])))
with writer.as_default():
  tf.summary.trace_export(
      name="my_func_trace",
      step=0,
      profiler_outdir=logdir)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/summary_ops_v2.py:1203: start (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.start` instead.
tf.Tensor([[0. 0.]], shape=(1, 2), dtype=float32)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/summary_ops_v2.py:1259: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/summary_ops_v2.py:1259: save (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
`tf.python.eager.profiler` has deprecated, use `tf.profiler` instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/eager/profiler.py:151: maybe_create_event_file (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
`tf.python.eager.profiler` has deprecated, use `tf.profiler` instead.

텐서 보드를 시작하여 결과 추적을 확인합니다.

%tensorboard --logdir logs/func

텐서 보드의 그래프 스크린 샷

SavedModel 생성

완전히 훈련 된 모델을 공유하는 권장 방법은 SavedModel 을 사용하는 SavedModel 입니다. SavedModel 에는 함수 모음과 가중치 모음이 모두 포함되어 있습니다.

방금 만든 모델을 저장할 수 있습니다.

tf.saved_model.save(my_model, "the_saved_model")
INFO:tensorflow:Assets written to: the_saved_model/assets

# Inspect the in the directory
ls -l the_saved_model
total 24
drwxr-sr-x 2 kbuilder kokoro  4096 Sep 10 01:35 assets
-rw-rw-r-- 1 kbuilder kokoro 12617 Sep 10 01:35 saved_model.pb
drwxr-sr-x 2 kbuilder kokoro  4096 Sep 10 01:35 variables

# The variables/ directory contains a checkpoint of the variables
ls -l the_saved_model/variables
total 8
-rw-rw-r-- 1 kbuilder kokoro 408 Sep 10 01:35 variables.data-00000-of-00001
-rw-rw-r-- 1 kbuilder kokoro 356 Sep 10 01:35 variables.index

saved_model.pb 파일은 기능적 tf.Graph 설명하는 프로토콜 버퍼 입니다.

모델과 레이어는 실제로 생성 한 클래스의 인스턴스를 만들지 않고도이 표현에서로드 할 수 있습니다. 이는 대규모 또는 엣지 장치에서 제공하는 것과 같이 Python 인터프리터가 없거나 원하는 상황이나 원래 Python 코드를 사용할 수 없거나 사용할 수없는 상황에서 바람직합니다.

모델을 새 개체로로드 할 수 있습니다.

new_model = tf.saved_model.load("the_saved_model")

저장된 모델을로드하여 생성 된 new_model 은 클래스 지식이없는 내부 TensorFlow 사용자 객체입니다. SequentialModule 유형이 아닙니다.

isinstance(new_model, SequentialModule)
False

이 새 모델은 이미 정의 된 입력 서명에서 작동합니다. 이와 같이 복원 된 모델에는 더 많은 서명을 추가 할 수 없습니다.

print(my_model([[2.0, 2.0, 2.0]]))
print(my_model([[[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]]))
tf.Tensor([[0.        0.3236845]], shape=(1, 2), dtype=float32)
tf.Tensor(
[[[0.        0.3236845]
  [0.        0.3236845]]], shape=(1, 2, 2), dtype=float32)

따라서, 사용 SavedModel , 당신은 TensorFlow 무게와 사용하여 그래프를 저장할 수 있습니다 tf.Module 한 다음 다시로드합니다.

Keras 모델 및 레이어

이 시점까지 Keras에 대한 언급이 없습니다. tf.Module 위에 고유 한 고수준 API를 빌드 할 수 있으며 사람들은 tf.Module 있습니다.

이 섹션에서는 tf.Moduletf.Module 사용하는 방법을 살펴 봅니다. Keras 모델에 대한 완전한 사용자 가이드는 Keras 가이드 에서 찾을 수 있습니다.

Keras 레이어

tf.keras.layers.Layer 는 모든 Keras 레이어의 기본 클래스이며 tf.Module 에서 상속합니다.

부모를 교체 한 다음 __call__ 을 다음을 call 하도록 변경하여 모듈을 Keras 레이어로 변환 할 수 있습니다.

class MyDense(tf.keras.layers.Layer):
  # Adding **kwargs to support base Keras layer arguemnts
  def __init__(self, in_features, out_features, **kwargs):
    super().__init__(**kwargs)

    # This will soon move to the build step; see below
    self.w = tf.Variable(
      tf.random.normal([in_features, out_features]), name='w')
    self.b = tf.Variable(tf.zeros([out_features]), name='b')
  def call(self, x):
    y = tf.matmul(x, self.w) + self.b
    return tf.nn.relu(y)

simple_layer = MyDense(name="simple", in_features=3, out_features=3)

Keras 레이어에는 다음 섹션에서 설명하는 몇 가지 부기를 수행 한 다음 call() 을 호출하는 고유 한 __call__ 이 있습니다. 기능에 변화가 없어야합니다.

simple_layer([[2.0, 2.0, 2.0]])
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[1.8125846, 0.       , 0.       ]], dtype=float32)>

build 단계

앞서 언급했듯이 입력 형태가 확실해질 때까지 변수를 생성하기 위해 기다리는 것이 많은 경우 편리합니다.

Keras 계층에는 계층을 정의하는 방법에 더 많은 유연성을 제공하는 추가 수명주기 단계가 있습니다. 이것은 build() 함수에서 정의됩니다.

build 는 정확히 한 번만 호출되며 입력 모양으로 호출됩니다. 일반적으로 변수 (가중치)를 만드는 데 사용됩니다.

위의 MyDense 레이어를 입력 크기에 맞게 다시 작성할 수 있습니다.

class FlexibleDense(tf.keras.layers.Layer):
  # Note the added `**kwargs`, as Keras supports many arguments
  def __init__(self, out_features, **kwargs):
    super().__init__(**kwargs)
    self.out_features = out_features

  def build(self, input_shape):  # Create the state of the layer (weights)
    self.w = tf.Variable(
      tf.random.normal([input_shape[-1], self.out_features]), name='w')
    self.b = tf.Variable(tf.zeros([self.out_features]), name='b')

  def call(self, inputs):  # Defines the computation from inputs to outputs
    return tf.matmul(inputs, self.w) + self.b

# Create the instance of the layer
flexible_dense = FlexibleDense(out_features=3)

이 시점에서 모델이 빌드되지 않았으므로 변수가 없습니다.

flexible_dense.variables
[]

함수를 호출하면 적절한 크기의 변수가 할당됩니다.

# Call it, with predictably random results
print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0], [3.0, 3.0, 3.0]])))
Model results: tf.Tensor(
[[  1.9751439   -0.52345586  -6.757321  ]
 [  2.962716    -0.78518367 -10.135981  ]], shape=(2, 3), dtype=float32)

flexible_dense.variables
[<tf.Variable 'flexible_dense/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[-1.3283044 ,  0.4407923 , -1.0344194 ],
        [ 0.2887298 ,  0.7995425 , -3.0122824 ],
        [ 2.0271466 , -1.5020627 ,  0.66804147]], dtype=float32)>,
 <tf.Variable 'flexible_dense/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

build 는 한 번만 호출되기 때문에 입력 모양이 레이어의 변수와 호환되지 않으면 입력이 거부됩니다.

try:
  print("Model results:", flexible_dense(tf.constant([[2.0, 2.0, 2.0, 2.0]])))
except tf.errors.InvalidArgumentError as e:
  print("Failed:", e)
Failed: Matrix size-incompatible: In[0]: [1,4], In[1]: [3,3] [Op:MatMul]

Keras 레이어에는 다음과 같은 더 많은 추가 기능이 있습니다.

  • 선택적 손실
  • 메트릭 지원
  • 학습 및 추론 사용을 구별하기위한 선택적 training 인수에 대한 기본 training 지원
  • Python에서 모델 복제를 허용하도록 구성을 정확하게 저장할 수있는 get_configfrom_config 메서드

커스텀 레이어에 대한 전체 가이드 에서 이에 대해 읽어보세요.

Keras 모델

모델을 중첩 된 Keras 레이어로 정의 할 수 있습니다.

그러나 tf.keras.Modeltf.keras.Model 이라는 완전한 기능을 갖춘 모델 클래스도 제공합니다. tf.keras.layers.Layer 에서 상속하므로 tf.keras.layers.Layer 모델은 tf.keras.layers.Layer 레이어이며 동일한 방식으로 사용, 중첩 및 저장할 수 있습니다. Keras 모델에는 여러 기계에서 쉽게 학습, 평가,로드, 저장 및 학습 할 수있는 추가 기능이 있습니다.

거의 동일한 코드로 위에서 SequentialModule 을 정의 할 수 있으며, 다시 __call__call() 로 변환하고 부모를 변경할 수 있습니다.

class MySequentialModel(tf.keras.Model):
  def __init__(self, name=None, **kwargs):
    super().__init__(**kwargs)

    self.dense_1 = FlexibleDense(out_features=3)
    self.dense_2 = FlexibleDense(out_features=2)
  def call(self, x):
    x = self.dense_1(x)
    return self.dense_2(x)

# You have made a Keras model!
my_sequential_model = MySequentialModel(name="the_model")

# Call it on a tensor, with random results
print("Model results:", my_sequential_model(tf.constant([[2.0, 2.0, 2.0]])))

Model results: tf.Tensor([[-3.680038   1.2085412]], shape=(1, 2), dtype=float32)

추적 변수 및 하위 모듈을 포함하여 동일한 기능을 모두 사용할 수 있습니다.

my_sequential_model.variables
[<tf.Variable 'my_sequential_model/flexible_dense_1/w:0' shape=(3, 3) dtype=float32, numpy=
 array([[ 0.5388254 , -2.268109  , -0.34042016],
        [-1.1464697 ,  0.04621376,  0.6316701 ],
        [ 0.22427997,  1.975861  , -1.3573155 ]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_1/b:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/w:0' shape=(3, 2) dtype=float32, numpy=
 array([[-0.5662819 ,  1.154388  ],
        [ 2.1547215 , -0.71875423],
        [ 1.4323472 , -0.81606954]], dtype=float32)>,
 <tf.Variable 'my_sequential_model/flexible_dense_2/b:0' shape=(2,) dtype=float32, numpy=array([0., 0.], dtype=float32)>]
my_sequential_model.submodules
(<__main__.FlexibleDense at 0x7fbffc7c2cf8>,
 <__main__.FlexibleDense at 0x7fbffc7c2f98>)

tf.keras.Model 재정의하는 것은 TensorFlow 모델을 빌드하는 매우 tf.keras.Model 적인 접근 방식입니다. 다른 프레임 워크에서 모델을 마이그레이션하는 경우 매우 간단 할 수 있습니다.

기존 레이어 및 입력의 간단한 조합 인 모델을 구성하는 경우 모델 재구성 및 아키텍처와 관련된 추가 기능과 함께 제공되는 기능적 API 를 사용하여 시간과 공간을 절약 할 수 있습니다.

다음은 기능 API가있는 동일한 모델입니다.

inputs = tf.keras.Input(shape=[3,])

x = FlexibleDense(3)(inputs)
x = FlexibleDense(2)(x)

my_functional_model = tf.keras.Model(inputs=inputs, outputs=x)

my_functional_model.summary()
Model: "functional_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 3)]               0         
_________________________________________________________________
flexible_dense_3 (FlexibleDe (None, 3)                 12        
_________________________________________________________________
flexible_dense_4 (FlexibleDe (None, 2)                 8         
=================================================================
Total params: 20
Trainable params: 20
Non-trainable params: 0
_________________________________________________________________

my_functional_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[-0.70818764, -4.2403307 ]], dtype=float32)>

여기서 가장 큰 차이점은 입력 모양이 기능 구성 프로세스의 일부로 미리 지정된다는 것입니다. 이 경우 input_shape 인수를 완전히 지정할 필요는 없습니다. 일부 차원은 None 남겨 둘 수 있습니다.

Keras 모델 저장

Keras 모델은 체크 포인트 할 수 있으며 tf.Module 과 동일하게 tf.Module .

Keras 모델은 모듈 tf.saved_models.save() 로 저장할 수도 있습니다. 그러나 Keras 모델에는 편리한 방법과 기타 기능이 있습니다.

my_sequential_model.save("exname_of_file")
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: exname_of_file/assets

마찬가지로 쉽게 다시로드 할 수 있습니다.

reconstructed_model = tf.keras.models.load_model("exname_of_file")
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.

SavedModels 는 또한 메트릭, 손실 및 최적화 프로그램 상태를 저장합니다.

이 재구성 된 모델을 사용할 수 있으며 동일한 데이터에 대해 호출 될 때 동일한 결과를 생성합니다.

reconstructed_model(tf.constant([[2.0, 2.0, 2.0]]))
<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[-3.680038 ,  1.2085412]], dtype=float32)>

기능 지원을위한 사용자 정의 계층에 대한 구성 방법을 제공하는 것을 포함하여 Keras 모델의 저장 및 직렬화에 대해 더 많이 알아야합니다. 저장 및 직렬화 가이드를 확인하세요.

무엇 향후 계획

Keras에 대한 자세한 내용을 알고 싶다면 여기 에서 기존 Keras 가이드를 따르십시오.

tf.module 기반으로 구축 된 고수준 API의 또 다른 예는 DeepMind의 Sonnet이며, 해당 사이트에서 다룹니다.