Google I / O kembali hadir pada 18-20 Mei! Pesan tempat dan buat jadwal Anda Daftar sekarang

Migrasikan kode TensorFlow 1 Anda ke TensorFlow 2

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Panduan ini ditujukan untuk pengguna TensorFlow API level rendah. Jika Anda menggunakan API tingkat tinggi ( tf.keras ), mungkin ada sedikit atau tidak ada tindakan yang perlu Anda lakukan untuk membuat kode Anda sepenuhnya kompatibel dengan TensorFlow 2.x:

Masih mungkin untuk menjalankan kode 1.x, tanpa modifikasi ( kecuali untuk kontrib), di TensorFlow 2.x:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

Namun, hal ini tidak memungkinkan Anda memanfaatkan banyak penyempurnaan yang dilakukan di TensorFlow 2.x. Panduan ini akan membantu Anda mengupgrade kode Anda, membuatnya lebih sederhana, lebih berkinerja, dan lebih mudah dikelola.

Skrip konversi otomatis

Langkah pertama, sebelum mencoba menerapkan perubahan yang dijelaskan dalam panduan ini, adalah mencoba menjalankan skrip peningkatan .

Ini akan menjalankan pass awal saat mengupgrade kode Anda ke TensorFlow 2.x tetapi tidak dapat membuat kode Anda menjadi idiomatis ke v2. Kode Anda mungkin masih menggunakan titik akhir tf.compat.v1 untuk mengakses placeholder, sesi, koleksi, dan fungsionalitas gaya 1.x.

Perubahan perilaku tingkat atas

Jika kode Anda berfungsi di TensorFlow 2.x menggunakan tf.compat.v1.disable_v2_behavior , masih ada perubahan perilaku global yang mungkin perlu Anda atasi. Perubahan utamanya adalah:

  • Eksekusi bersemangat, v1.enable_eager_execution() : Kode apa pun yang secara implisit menggunakan tf.Graph akan gagal. Pastikan untuk membungkus kode ini with tf.Graph().as_default() .

  • Variabel sumber daya, v1.enable_resource_variables() : Beberapa kode mungkin bergantung pada perilaku non-deterministik yang diaktifkan oleh variabel referensi TensorFlow. Variabel sumber daya dikunci saat sedang ditulis, sehingga memberikan jaminan konsistensi yang lebih intuitif.

    • Ini dapat mengubah perilaku dalam kasus tepi.
    • Ini dapat membuat salinan tambahan dan dapat memiliki penggunaan memori yang lebih tinggi.
    • Ini bisa dinonaktifkan dengan meneruskan use_resource=False ke konstruktor tf.Variable .
  • Bentuk tensor, v1.enable_v2_tensorshape() : TensorFlow 2.x menyederhanakan perilaku bentuk tensor. Alih-alih nilai t.shape[0].value Anda dapat mengatakan t.shape[0] . Perubahan ini harus kecil, dan masuk akal untuk segera memperbaikinya. Lihat bagian TensorShape untuk mengetahui contohnya.

  • Alur kontrol, v1.enable_control_flow_v2() : Implementasi aliran kontrol TensorFlow 2.x telah disederhanakan, sehingga menghasilkan representasi grafik yang berbeda. Silakan laporkan bug untuk masalah apa pun.

Buat kode untuk TensorFlow 2.x

Panduan ini akan menjelaskan beberapa contoh tentang cara mengonversi kode TensorFlow 1.x ke TensorFlow 2.x. Perubahan ini akan memungkinkan kode Anda memanfaatkan pengoptimalan kinerja dan panggilan API yang disederhanakan.

Dalam setiap kasus, polanya adalah:

1. Ganti panggilan v1.Session.run

Setiap panggilan v1.Session.run harus diganti dengan fungsi Python.

  • The feed_dict dan v1.placeholder s menjadi argumen fungsi.
  • The fetches menjadi nilai kembali fungsi ini.
  • Selama konversi, eksekusi bersemangat memungkinkan debugging mudah dengan alat Python standar seperti pdb .

Setelah itu, tambahkan dekorator tf.function untuk membuatnya berjalan efisien dalam grafik. Lihat panduan Tanda Tangan untuk informasi lebih lanjut tentang cara kerjanya.

Perhatikan bahwa:

  • Tidak seperti v1.Session.run , sebuah tf.function memiliki tanda tangan kembalian tetap dan selalu mengembalikan semua keluaran. Jika ini menyebabkan masalah kinerja, buat dua fungsi terpisah.

  • Tidak diperlukan tf.control_dependencies atau operasi serupa: Sebuah tf.function berperilaku seolah-olah dijalankan dalam urutan tertulis. tf.Variable assignments dan tf.assert s, misalnya, dijalankan secara otomatis.

Bagian model konversi berisi contoh kerja dari proses konversi ini.

2. Gunakan objek Python untuk melacak variabel dan kerugian

Semua pelacakan variabel berbasis nama sangat tidak disarankan di TensorFlow 2.x. Gunakan objek Python untuk melacak variabel.

Gunakan tf.Variable bukan v1.get_variable .

Setiap v1.variable_scope harus diubah menjadi objek Python. Biasanya ini akan menjadi salah satu dari:

Jika Anda perlu daftar agregat dari variabel (seperti tf.Graph.get_collection(tf.GraphKeys.VARIABLES) ), menggunakan .variables dan .trainable_variables atribut dari Layer dan Model objek.

Kelas Layer dan Model mengimplementasikan beberapa properti lain yang menghilangkan kebutuhan untuk koleksi global. Properti .losses mereka bisa menjadi pengganti untuk menggunakan koleksi tf.GraphKeys.LOSSES .

Lihat panduan Keras untuk lebih jelasnya.

3. Tingkatkan loop pelatihan Anda

Gunakan API tingkat tertinggi yang sesuai untuk kasus penggunaan Anda. Lebih suka tf.keras.Model.fit daripada membuat loop pelatihan Anda sendiri.

Fungsi tingkat tinggi ini mengelola banyak detail tingkat rendah yang mungkin mudah terlewatkan jika Anda menulis loop pelatihan Anda sendiri. Misalnya, mereka secara otomatis mengumpulkan kerugian regularisasi, dan menyetel argumen training=True saat memanggil model.

4. Tingkatkan pipeline input data Anda

Gunakan tf.data data tf.data untuk input data. Objek ini efisien, ekspresif, dan terintegrasi dengan baik dengan tensorflow.

Mereka dapat diteruskan langsung ke metode tf.keras.Model.fit .

model.fit(dataset, epochs=5)

Mereka dapat diiterasi langsung dengan Python standar:

for example_batch, label_batch in dataset:
    break

5. Migrasi dari simbol compat.v1

Modul tf.compat.v1 berisi TensorFlow 1.x API lengkap, dengan semantik aslinya.

Skrip upgrade TensorFlow 2.x akan mengonversi simbol menjadi setara v2 jika konversi semacam itu aman, yaitu jika dapat menentukan bahwa perilaku versi TensorFlow 2.x benar-benar setara (misalnya, akan mengganti nama v1.arg_max ke tf.argmax , karena fungsinya sama).

Setelah skrip pemutakhiran selesai dengan sepotong kode, kemungkinan besar ada banyak penyebutan compat.v1 . Layak untuk menelusuri kode dan mengonversinya secara manual ke v2 yang setara (harus disebutkan di log jika ada).

Mengonversi model

Variabel tingkat rendah & eksekusi operator

Contoh penggunaan API tingkat rendah meliputi:

Sebelum mengonversi

Berikut adalah tampilan pola dalam kode yang menggunakan TensorFlow 1.x.

import tensorflow as tf
import tensorflow.compat.v1 as v1

import tensorflow_datasets as tfds
g = v1.Graph()

with g.as_default():
  in_a = v1.placeholder(dtype=v1.float32, shape=(2))
  in_b = v1.placeholder(dtype=v1.float32, shape=(2))

  def forward(x):
    with v1.variable_scope("matmul", reuse=v1.AUTO_REUSE):
      W = v1.get_variable("W", initializer=v1.ones(shape=(2,2)),
                          regularizer=lambda x:tf.reduce_mean(x**2))
      b = v1.get_variable("b", initializer=v1.zeros(shape=(2)))
      return W * x + b

  out_a = forward(in_a)
  out_b = forward(in_b)
  reg_loss=v1.losses.get_regularization_loss(scope="matmul")

with v1.Session(graph=g) as sess:
  sess.run(v1.global_variables_initializer())
  outs = sess.run([out_a, out_b, reg_loss],
                feed_dict={in_a: [1, 0], in_b: [0, 1]})

print(outs[0])
print()
print(outs[1])
print()
print(outs[2])
[[1. 0.]
 [1. 0.]]

[[0. 1.]
 [0. 1.]]

1.0

Setelah mengonversi

Dalam kode yang dikonversi:

  • Variabelnya adalah objek Python lokal.
  • Fungsi forward masih mendefinisikan kalkulasi.
  • Panggilan Session.run diganti dengan panggilan untuk forward .
  • Dekorator tf.function opsional dapat ditambahkan untuk kinerja.
  • Regularisasi dihitung secara manual, tanpa mengacu pada koleksi global apa pun.
  • Tidak ada penggunaan sesi atau placeholder .
W = tf.Variable(tf.ones(shape=(2,2)), name="W")
b = tf.Variable(tf.zeros(shape=(2)), name="b")

@tf.function
def forward(x):
  return W * x + b

out_a = forward([1,0])
print(out_a)
tf.Tensor(
[[1. 0.]
 [1. 0.]], shape=(2, 2), dtype=float32)
out_b = forward([0,1])

regularizer = tf.keras.regularizers.l2(0.04)
reg_loss=regularizer(W)

Model berdasarkan tf.layers

Modul v1.layers digunakan untuk memuat fungsi lapisan yang mengandalkan v1.variable_scope untuk mendefinisikan dan menggunakan kembali variabel.

Sebelum mengonversi

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    x = v1.layers.conv2d(x, 32, 3, activation=v1.nn.relu,
          kernel_regularizer=lambda x:0.004*tf.reduce_mean(x**2))
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    x = v1.layers.dropout(x, 0.1, training=training)
    x = v1.layers.dense(x, 64, activation=v1.nn.relu)
    x = v1.layers.batch_normalization(x, training=training)
    x = v1.layers.dense(x, 10)
    return x
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

print(train_out)
print()
print(test_out)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:414: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  warnings.warn('`tf.layers.conv2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py:2273: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  warnings.warn('`layer.apply` is deprecated and '
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

tf.Tensor(
[[ 0.379358   -0.55901194  0.48704922  0.11619566  0.23902717  0.01691487
   0.07227738  0.14556988  0.2459927   0.2501198 ]], shape=(1, 10), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/pooling.py:310: UserWarning: `tf.layers.max_pooling2d` is deprecated and will be removed in a future version. Please use `tf.keras.layers.MaxPooling2D` instead.
  warnings.warn('`tf.layers.max_pooling2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:329: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  warnings.warn('`tf.layers.flatten` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:268: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  warnings.warn('`tf.layers.dropout` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:171: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  warnings.warn('`tf.layers.dense` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/normalization.py:308: UserWarning: `tf.layers.batch_normalization` is deprecated and will be removed in a future version. Please use `tf.keras.layers.BatchNormalization` instead. In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.BatchNormalization` documentation).
  '`tf.layers.batch_normalization` is deprecated and '

Setelah mengonversi

Kebanyakan argumen tetap sama. Tetapi perhatikan perbedaannya:

  • Argumen training diteruskan ke setiap lapisan oleh model saat dijalankan.
  • Argumen pertama ke fungsi model asli (input x ) hilang. Ini karena lapisan objek memisahkan bangunan model dari pemanggilan model.

Perhatikan juga bahwa:

  • Jika Anda menggunakan regulator atau penginisialisasi dari tf.contrib , argumen ini memiliki lebih banyak perubahan daripada yang lain.
  • Kode tidak lagi menulis ke koleksi, jadi fungsi seperti v1.losses.get_regularization_loss tidak akan lagi mengembalikan nilai-nilai ini, berpotensi merusak loop pelatihan Anda.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.04),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
train_out = model(train_data, training=True)
print(train_out)
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)
test_out = model(test_data, training=False)
print(test_out)
tf.Tensor(
[[-0.2145557  -0.22979769 -0.14968733  0.01208701 -0.07569927  0.3475932
   0.10718458  0.03482988 -0.04309493 -0.10469118]], shape=(1, 10), dtype=float32)
# Here are all the trainable variables
len(model.trainable_variables)
8
# Here is the regularization loss
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.08174552>]

Variabel campuran & v1.layers

Kode yang sudah ada sering kali mencampur variabel TensorFlow 1.x level lebih rendah dan operasi dengan v1.layers level lebih tinggi.

Sebelum mengonversi

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    W = v1.get_variable(
      "W", dtype=v1.float32,
      initializer=v1.ones(shape=x.shape),
      regularizer=lambda x:0.004*tf.reduce_mean(x**2),
      trainable=True)
    if training:
      x = x + W
    else:
      x = x + W * 0.5
    x = v1.layers.conv2d(x, 32, 3, activation=tf.nn.relu)
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    return x

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

Setelah mengonversi

Untuk mengubah kode ini, ikuti pola pemetaan lapisan ke lapisan seperti pada contoh sebelumnya.

Pola umumnya adalah:

  • Kumpulkan parameter lapisan di __init__ .
  • Buat variabel dalam build .
  • Jalankan kalkulasi dalam call , dan kembalikan hasilnya.

v1.variable_scope pada dasarnya adalah lapisannya sendiri. Jadi tulis ulang sebagai tf.keras.layers.Layer . Lihat Panduan Membuat Lapisan dan Model baru melalui panduan subclassing untuk detailnya.

# Create a custom layer for part of the model
class CustomLayer(tf.keras.layers.Layer):
  def __init__(self, *args, **kwargs):
    super(CustomLayer, self).__init__(*args, **kwargs)

  def build(self, input_shape):
    self.w = self.add_weight(
        shape=input_shape[1:],
        dtype=tf.float32,
        initializer=tf.keras.initializers.ones(),
        regularizer=tf.keras.regularizers.l2(0.02),
        trainable=True)

  # Call method will sometimes get used in graph mode,
  # training will get turned into a tensor
  @tf.function
  def call(self, inputs, training=None):
    if training:
      return inputs + self.w
    else:
      return inputs + self.w * 0.5
custom_layer = CustomLayer()
print(custom_layer([1]).numpy())
print(custom_layer([1], training=True).numpy())
[1.5]
[2.]
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

# Build the model including the custom layer
model = tf.keras.Sequential([
    CustomLayer(input_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
])

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

Beberapa hal yang perlu diperhatikan:

  • Model dan lapisan Keras Subclass harus dijalankan di grafik v1 (tanpa ketergantungan kontrol otomatis) dan dalam mode bersemangat:

  • Jangan lupa untuk menerima argumen training untuk call :

    • Terkadang itu adalah tf.Tensor
    • Terkadang itu adalah Python boolean
  • Buat variabel model dalam konstruktor atau Model.build menggunakan `self.add_weight:

    • Di Model.build Anda memiliki akses ke bentuk masukan, sehingga dapat membuat bobot dengan bentuk yang cocok
    • Menggunakan tf.keras.layers.Layer.add_weight memungkinkan Keras untuk melacak variabel dan kerugian regularisasi
  • Jangan simpan tf.Tensors di objek Anda:

    • Mereka mungkin dibuat baik dalam fungsi tf.function dalam konteks bersemangat, dan tensor ini berperilaku berbeda
    • Gunakan tf.Variable . tf.Variable s untuk status, mereka selalu dapat digunakan dari kedua konteks
    • tf.Tensors hanya untuk nilai menengah

Catatan tentang Slim dan contrib.layers

Sejumlah besar kode TensorFlow 1.x lama menggunakan pustaka Slim , yang dipaketkan dengan TensorFlow 1.x sebagai tf.contrib.layers . Sebagai modul contrib , modul ini tidak lagi tersedia di TensorFlow 2.x, bahkan di tf.compat.v1 . Mengonversi kode menggunakan Slim ke TensorFlow 2.x lebih melibatkan daripada mengonversi repositori yang menggunakan v1.layers . Sebenarnya, mungkin masuk akal untuk mengonversi kode Slim Anda ke v1.layers terlebih dahulu, kemudian mengonversi ke Keras.

  • Hapus arg_scopes , semua argumen harus eksplisit.
  • Jika Anda menggunakannya, pisahkan normalizer_fn dan activation_fn menjadi lapisannya masing-masing.
  • Lapisan konv yang dapat dipisahkan dipetakan ke satu atau beberapa lapisan Keras yang berbeda (lapisan dalam, tajam, dan dapat dipisahkan).
  • Slim dan v1.layers memiliki nama argumen dan nilai default yang berbeda.
  • Beberapa argumentasi memiliki skala yang berbeda.
  • Jika Anda menggunakan model pra-terlatih Slim, coba model yang telah dilatih Keras dari tf.keras.applications atau TensorFlow 2.x SavedModels TF Hub yang diekspor dari kode Slim asli.

Beberapa lapisan tf.contrib mungkin belum dipindahkan ke inti TensorFlow tetapi telah dipindahkan ke paket Addons TensorFlow .

Latihan

Ada banyak cara untuk memasukkan data ke model tf.keras . Mereka akan menerima generator Python dan array Numpy sebagai input.

Cara yang direkomendasikan untuk memasukkan data ke model adalah dengan menggunakan paket tf.data , yang berisi kumpulan kelas berperforma tinggi untuk memanipulasi data.

Jika Anda masih menggunakan tf.queue , ini sekarang hanya didukung sebagai struktur data, bukan sebagai pipeline input.

Menggunakan Set Data TensorFlow

Paket TensorFlow Dataset ( tfds ) berisi utilitas untuk memuattf.data.Dataset data yang telah ditentukan sebelumnya sebagai objektf.data.Dataset .

Untuk contoh ini, Anda dapat memuat set data tfds menggunakan tfds :

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
Downloading and preparing dataset mnist/3.0.1 (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /home/kbuilder/tensorflow_datasets/mnist/3.0.1...
WARNING:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead pass
`try_gcs=True` to `tfds.load` or set `data_dir=gs://tfds-data/datasets`.
Dataset mnist downloaded and prepared to /home/kbuilder/tensorflow_datasets/mnist/3.0.1. Subsequent calls will reuse this data.

Kemudian siapkan data untuk pelatihan:

  • Ubah skala setiap gambar.
  • Kocok urutan contoh.
  • Kumpulkan sejumlah gambar dan label.
BUFFER_SIZE = 10 # Use a much larger value for real code
BATCH_SIZE = 64
NUM_EPOCHS = 5


def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label

Agar contoh tetap singkat, pangkas kumpulan data agar hanya mengembalikan 5 kelompok:

train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)

STEPS_PER_EPOCH = 5

train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)
image_batch, label_batch = next(iter(train_data))

Gunakan loop pelatihan Keras

Jika Anda tidak perlu kontrol tingkat rendah dari proses pelatihan Anda, menggunakan Keras built-in fit , evaluate , dan predict metode dianjurkan. Metode ini menyediakan antarmuka yang seragam untuk melatih model terlepas dari implementasinya (berurutan, fungsional, atau sub-kelas).

Keuntungan dari metode ini meliputi:

  • Mereka menerima array Numpy, generator Python dan, tf.data.Datasets .
  • Mereka menerapkan regularisasi, dan kerugian aktivasi secara otomatis.
  • Mereka mendukung tf.distribute untuk pelatihan multi-perangkat .
  • Mereka mendukung callable sewenang-wenang sebagai kerugian dan metrik.
  • Mereka mendukung callback seperti tf.keras.callbacks.TensorBoard , dan callback kustom.
  • Mereka berperforma baik, secara otomatis menggunakan grafik TensorFlow.

Berikut adalah contoh melatih model menggunakan Dataset . (Untuk detail tentang cara kerjanya, lihat bagian tutorial .)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)

print("Loss {}, Accuracy {}".format(loss, acc))
Epoch 1/5
5/5 [==============================] - 1s 9ms/step - loss: 2.0191 - accuracy: 0.3608
Epoch 2/5
5/5 [==============================] - 0s 9ms/step - loss: 0.4736 - accuracy: 0.9059
Epoch 3/5
5/5 [==============================] - 0s 8ms/step - loss: 0.2973 - accuracy: 0.9626
Epoch 4/5
5/5 [==============================] - 0s 9ms/step - loss: 0.2108 - accuracy: 0.9911
Epoch 5/5
5/5 [==============================] - 0s 8ms/step - loss: 0.1791 - accuracy: 0.9874
5/5 [==============================] - 0s 6ms/step - loss: 1.5504 - accuracy: 0.7500
Loss 1.5504140853881836, Accuracy 0.75

Tulis lingkaran Anda sendiri

Jika langkah pelatihan model Keras berhasil untuk Anda, tetapi Anda memerlukan lebih banyak kontrol di luar langkah itu, pertimbangkan untuk menggunakan metode tf.keras.Model.train_on_batch , di loop iterasi data Anda sendiri.

Ingat: Banyak hal yang dapat diimplementasikan sebagai tf.keras.callbacks.Callback .

Metode ini memiliki banyak keuntungan dari metode yang disebutkan di bagian sebelumnya, tetapi memberikan kontrol pengguna untuk loop luar.

Anda juga dapat menggunakan tf.keras.Model.test_on_batch atau tf.keras.Model.evaluate untuk memeriksa kinerja selama pelatihan.

Untuk melanjutkan melatih model di atas:

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

for epoch in range(NUM_EPOCHS):
  # Reset the metric accumulators
  model.reset_metrics()

  for image_batch, label_batch in train_data:
    result = model.train_on_batch(image_batch, label_batch)
    metrics_names = model.metrics_names
    print("train: ",
          "{}: {:.3f}".format(metrics_names[0], result[0]),
          "{}: {:.3f}".format(metrics_names[1], result[1]))
  for image_batch, label_batch in test_data:
    result = model.test_on_batch(image_batch, label_batch,
                                 # Return accumulated metrics
                                 reset_metrics=False)
  metrics_names = model.metrics_names
  print("\neval: ",
        "{}: {:.3f}".format(metrics_names[0], result[0]),
        "{}: {:.3f}".format(metrics_names[1], result[1]))
train:  loss: 0.138 accuracy: 1.000
train:  loss: 0.161 accuracy: 1.000
train:  loss: 0.159 accuracy: 0.969
train:  loss: 0.241 accuracy: 0.953
train:  loss: 0.172 accuracy: 0.969

eval:  loss: 1.550 accuracy: 0.800
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.094 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000
train:  loss: 0.119 accuracy: 0.984
train:  loss: 0.099 accuracy: 1.000

eval:  loss: 1.558 accuracy: 0.841
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.061 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000

eval:  loss: 1.536 accuracy: 0.841
train:  loss: 0.059 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.058 accuracy: 1.000
train:  loss: 0.054 accuracy: 1.000
train:  loss: 0.055 accuracy: 1.000

eval:  loss: 1.497 accuracy: 0.863
train:  loss: 0.053 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.045 accuracy: 1.000

eval:  loss: 1.463 accuracy: 0.878

Sesuaikan langkah pelatihan

Jika Anda membutuhkan lebih banyak fleksibilitas dan kontrol, Anda dapat memilikinya dengan menerapkan loop pelatihan Anda sendiri. Ada tiga langkah:

  1. Iterasi melalui generator Python atautf.data.Dataset untuk mendapatkantf.data.Dataset contoh.
  2. Gunakantf.GradientTape untuk mengumpulkan gradien.
  3. Gunakan salah satu tf.keras.optimizers untuk menerapkan pembaruan bobot ke variabel model.

Ingat:

  • Selalu sertakan argumen training tentang metode call lapisan dan model subclass.
  • Pastikan untuk memanggil model dengan argumen training disetel dengan benar.
  • Bergantung pada penggunaan, variabel model mungkin tidak ada sampai model dijalankan pada sekumpulan data.
  • Anda perlu menangani hal-hal seperti kerugian regularisasi secara manual untuk model tersebut.

Perhatikan penyederhanaan relatif terhadap v1:

  • Tidak perlu menjalankan penginisialisasi variabel. Variabel diinisialisasi saat pembuatan.
  • Tidak perlu menambahkan dependensi kontrol manual. Bahkan dalam operasi tf.function bertindak seperti dalam mode bersemangat.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

for epoch in range(NUM_EPOCHS):
  for inputs, labels in train_data:
    train_step(inputs, labels)
  print("Finished epoch", epoch)
Finished epoch 0
Finished epoch 1
Finished epoch 2
Finished epoch 3
Finished epoch 4

Metrik dan kerugian gaya baru

Di TensorFlow 2.x, metrik dan kerugian adalah objek. Ini bekerja dengan penuh semangat dan dalam tf.function s.

Objek kerugian dapat dipanggil, dan mengharapkan (y_true, y_pred) sebagai argumen:

cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
4.01815

Objek metrik memiliki metode berikut:

  • Metric.update_state() : tambahkan pengamatan baru.
  • Metric.result() : dapatkan hasil saat ini dari metrik, berdasarkan nilai yang diamati.
  • Metric.reset_states() : hapus semua observasi.

Objek itu sendiri bisa dipanggil. Memanggil memperbarui status dengan pengamatan baru, seperti update_state , dan mengembalikan hasil baru dari metrik.

Anda tidak perlu menginisialisasi variabel metrik secara manual, dan karena TensorFlow 2.x memiliki dependensi kontrol otomatis, Anda juga tidak perlu mengkhawatirkannya.

Kode di bawah ini menggunakan metrik untuk melacak kerugian rata-rata yang diamati dalam loop pelatihan kustom.

# Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  # Update the metrics
  loss_metric.update_state(total_loss)
  accuracy_metric.update_state(labels, predictions)


for epoch in range(NUM_EPOCHS):
  # Reset the metrics
  loss_metric.reset_states()
  accuracy_metric.reset_states()

  for inputs, labels in train_data:
    train_step(inputs, labels)
  # Get the metric results
  mean_loss=loss_metric.result()
  mean_accuracy = accuracy_metric.result()

  print('Epoch: ', epoch)
  print('  loss:     {:.3f}'.format(mean_loss))
  print('  accuracy: {:.3f}'.format(mean_accuracy))
Epoch:  0
  loss:     0.139
  accuracy: 0.997
Epoch:  1
  loss:     0.116
  accuracy: 1.000
Epoch:  2
  loss:     0.105
  accuracy: 0.997
Epoch:  3
  loss:     0.089
  accuracy: 1.000
Epoch:  4
  loss:     0.078
  accuracy: 1.000

Nama metrik Keras

Di TensorFlow 2.x, model Keras lebih konsisten dalam menangani nama metrik.

Sekarang ketika Anda melewati string dalam daftar metrik, string tepat digunakan sebagai metrik ini name . Nama-nama ini terlihat di objek histori yang dikembalikan oleh model.fit , dan di log yang diteruskan ke keras.callbacks . disetel ke string yang Anda berikan di daftar metrik.

model.compile(
    optimizer = tf.keras.optimizers.Adam(0.001),
    loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)
5/5 [==============================] - 1s 8ms/step - loss: 0.0901 - acc: 0.9923 - accuracy: 0.9923 - my_accuracy: 0.9923
history.history.keys()
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

Ini berbeda dari versi sebelumnya di mana melewatkan metrics=["accuracy"] akan menghasilkan dict_keys(['loss', 'acc'])

Pengoptimal keras

Pengoptimal di v1.train , seperti v1.train.AdamOptimizer dan v1.train.GradientDescentOptimizer , memiliki padanan di tf.keras.optimizers .

Ubah v1.train menjadi keras.optimizers

Berikut hal-hal yang perlu diperhatikan saat mengubah pengoptimal Anda:

Default baru untuk beberapa tf.keras.optimizers

Tidak ada perubahan untuk optimizers.SGD , optimizers.Adam , atau optimizers.RMSprop .

Kecepatan pembelajaran default berikut telah berubah:

TensorBoard

TensorFlow 2.x menyertakan perubahan signifikan pada tf.summary API yang digunakan untuk menulis data ringkasan untuk visualisasi di TensorBoard. Untuk pengenalan umum tentang tf.summary baru, tersedia beberapa tutorial yang menggunakan TensorFlow 2.x API. Ini termasuk panduan migrasi TensorBoard TensorFlow 2.x.

Menyimpan dan memuat

Kompatibilitas pos pemeriksaan

TensorFlow 2.x menggunakan pos pemeriksaan berbasis objek .

Pos pemeriksaan berbasis nama gaya lama masih dapat dimuat, jika Anda berhati-hati. Proses konversi kode dapat mengakibatkan perubahan nama variabel, tetapi ada beberapa solusi.

Pendekatan paling sederhana untuk menyejajarkan nama model baru dengan nama di pos pemeriksaan:

  • Variabel masih semuanya memiliki argumen name yang dapat Anda atur.
  • Model Keras juga menggunakan argumen name yang mereka setel sebagai awalan untuk variabel mereka.
  • Fungsi v1.name_scope dapat digunakan untuk mengatur awalan nama variabel. Ini sangat berbeda dari tf.variable_scope . Ini hanya mempengaruhi nama, dan tidak melacak variabel dan digunakan kembali.

Jika itu tidak berhasil untuk kasus penggunaan Anda, coba fungsi v1.train.init_from_checkpoint . Dibutuhkan argumen assignment_map , yang menentukan pemetaan dari nama lama ke nama baru.

Repositori TensorFlow Estimator menyertakan fitur konversi untuk mengupgrade checkpoint untuk estimator yang dibuat sebelumnya dari TensorFlow 1.x ke 2.0. Ini dapat berfungsi sebagai contoh cara membuat alat untuk kasus penggunaan serupa.

Kompatibilitas model yang disimpan

Tidak ada masalah kompatibilitas yang signifikan untuk model yang disimpan.

  • TensorFlow 1.x save_models berfungsi di TensorFlow 2.x.
  • TensorFlow 2.x save_models berfungsi di TensorFlow 1.x jika semua operasi didukung.

Sebuah Graph.pb atau Graph.pbtxt

Tidak ada cara mudah untuk mengupgrade file Graph.pb mentah ke TensorFlow 2.x. Taruhan terbaik Anda adalah meningkatkan kode yang menghasilkan file.

Tapi, jika Anda memiliki "grafik beku" (a tf.Graph mana variabel telah berubah menjadi konstanta), maka adalah mungkin untuk mengubahnya ke concrete_function menggunakan v1.wrap_function :

def wrap_frozen_graph(graph_def, inputs, outputs):
  def _imports_graph_def():
    tf.compat.v1.import_graph_def(graph_def, name="")
  wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, [])
  import_graph = wrapped_import.graph
  return wrapped_import.prune(
      tf.nest.map_structure(import_graph.as_graph_element, inputs),
      tf.nest.map_structure(import_graph.as_graph_element, outputs))

Misalnya, berikut adalah grafik yang dibekukan untuk Inception v1, dari 2016:

path = tf.keras.utils.get_file(
    'inception_v1_2016_08_28_frozen.pb',
    'http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz',
    untar=True)
Downloading data from http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz
24698880/24695710 [==============================] - 1s 0us/step

Muat tf.GraphDef :

graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(path,'rb').read())

Bungkus menjadi sebuah concrete_function :

inception_func = wrap_frozen_graph(
    graph_def, inputs='input:0',
    outputs='InceptionV1/InceptionV1/Mixed_3b/Branch_1/Conv2d_0a_1x1/Relu:0')

Berikan tensor sebagai masukan:

input_img = tf.ones([1,224,224,3], dtype=tf.float32)
inception_func(input_img).shape
TensorShape([1, 28, 28, 96])

Estimator

Pelatihan dengan Estimator

Estimator didukung di TensorFlow 2.x.

Saat menggunakan estimator, Anda dapat menggunakan input_fn , tf.estimator.TrainSpec , dan tf.estimator.EvalSpec dari TensorFlow 1.x.

Berikut adalah contoh menggunakan input_fn dengan spesifikasi train dan evaluasi.

Membuat spesifikasi input_fn dan train / eval

# Define the estimator's input_fn
def input_fn():
  datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
  mnist_train, mnist_test = datasets['train'], datasets['test']

  BUFFER_SIZE = 10000
  BATCH_SIZE = 64

  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255

    return image, label[..., tf.newaxis]

  train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
  return train_data.repeat()

# Define train and eval specs
train_spec = tf.estimator.TrainSpec(input_fn=input_fn,
                                    max_steps=STEPS_PER_EPOCH * NUM_EPOCHS)
eval_spec = tf.estimator.EvalSpec(input_fn=input_fn,
                                  steps=STEPS_PER_EPOCH)

Menggunakan definisi model Keras

Ada beberapa perbedaan dalam cara membuat estimator Anda di TensorFlow 2.x.

Sebaiknya tentukan model Anda menggunakan Keras, lalu gunakan utilitas tf.keras.estimator.model_to_estimator untuk mengubah model Anda menjadi penaksir. Kode di bawah ini menunjukkan bagaimana menggunakan utilitas ini saat membuat dan melatih estimator.

def make_model():
  return tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
  ])
model = make_model()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(
  keras_model = model
)

tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
INFO:tensorflow:Using the Keras model provided.
INFO:tensorflow:Using the Keras model provided.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/backend.py:434: UserWarning: `tf.keras.backend.set_learning_phase` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.
  warnings.warn('`tf.keras.backend.set_learning_phase` is deprecated and '
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-started 8 variables.
INFO:tensorflow:Warm-started 8 variables.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training.py:2325: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  warnings.warn('`Model.state_updates` will be removed in a future version. '
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.37597787.
INFO:tensorflow:Loss for final step: 0.37597787.
({'accuracy': 0.6, 'loss': 1.6160676, 'global_step': 25}, [])

Menggunakan model_fn kustom

Jika Anda memiliki estimator kustom model_fn yang perlu Anda pertahankan, Anda dapat mengonversi model_fn Anda untuk menggunakan model Keras.

Namun, untuk alasan kompatibilitas, model_fn khusus akan tetap berjalan dalam mode grafik gaya 1.x. Ini berarti tidak ada eksekusi yang bersemangat dan tidak ada ketergantungan kontrol otomatis.

Model_fn kustom dengan sedikit perubahan

Agar model_fn kustom Anda berfungsi di TensorFlow 2.x, jika Anda lebih suka perubahan minimal pada kode yang ada, simbol tf.compat.v1 seperti optimizers dan metrics dapat digunakan.

Menggunakan model Keras di model_fn kustom mirip dengan menggunakannya di loop pelatihan kustom:

  • Setel fase training tepat, berdasarkan argumen mode .
  • Teruskan secara eksplisit trainable_variables model ke pengoptimal.

Namun ada perbedaan penting, terkait dengan pengulangan khusus :

  • Alih-alih menggunakan Model.losses , ekstrak kerugian menggunakan Model.get_losses_for .
  • Ekstrak pembaruan model menggunakan Model.get_updates_for .

Kode berikut membuat estimator dari model_fn kustom, yang menggambarkan semua masalah ini.

def my_model_fn(features, labels, mode):
  model = make_model()

  optimizer = tf.compat.v1.train.AdamOptimizer()
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  predictions = model(features, training=training)

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_fn(labels, predictions) + tf.math.add_n(reg_losses)

  accuracy = tf.compat.v1.metrics.accuracy(labels=labels,
                                           predictions=tf.math.argmax(predictions, axis=1),
                                           name='acc_op')

  update_ops = model.get_updates_for(None) + model.get_updates_for(features)
  minimize_op = optimizer.minimize(
      total_loss,
      var_list=model.trainable_variables,
      global_step=tf.compat.v1.train.get_or_create_global_step())
  train_op = tf.group(minimize_op, update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op, eval_metric_ops={'accuracy': accuracy})

# Create the Estimator & Train
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.35726172.
INFO:tensorflow:Loss for final step: 0.35726172.
({'accuracy': 0.59375, 'loss': 1.6248872, 'global_step': 25}, [])

model_fn kustom dengan simbol TensorFlow 2.x.

Jika ingin menghapus semua simbol TensorFlow 1.x dan mengupgrade model_fn kustom Anda ke TensorFlow 2.x, Anda perlu mengupdate pengoptimal dan metrik ke tf.keras.optimizers dan tf.keras.metrics .

Di model_fn khusus, selain perubahan di atas, lebih banyak peningkatan perlu dilakukan:

Untuk contoh my_model_fn , kode yang dimigrasi dengan simbol TensorFlow 2.x ditampilkan sebagai:

def my_model_fn(features, labels, mode):
  model = make_model()

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  loss_obj = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
  predictions = model(features, training=training)

  # Get both the unconditional losses (the None part)
  # and the input-conditional losses (the features part).
  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_obj(labels, predictions) + tf.math.add_n(reg_losses)

  # Upgrade to tf.keras.metrics.
  accuracy_obj = tf.keras.metrics.Accuracy(name='acc_obj')
  accuracy = accuracy_obj.update_state(
      y_true=labels, y_pred=tf.math.argmax(predictions, axis=1))

  train_op = None
  if training:
    # Upgrade to tf.keras.optimizers.
    optimizer = tf.keras.optimizers.Adam()
    # Manually assign tf.compat.v1.global_step variable to optimizer.iterations
    # to make tf.compat.v1.train.global_step increased correctly.
    # This assignment is a must for any `tf.train.SessionRunHook` specified in
    # estimator, as SessionRunHooks rely on global step.
    optimizer.iterations = tf.compat.v1.train.get_or_create_global_step()
    # Get both the unconditional updates (the None part)
    # and the input-conditional updates (the features part).
    update_ops = model.get_updates_for(None) + model.get_updates_for(features)
    # Compute the minimize_op.
    minimize_op = optimizer.get_updates(
        total_loss,
        model.trainable_variables)[0]
    train_op = tf.group(minimize_op, *update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op,
    eval_metric_ops={'Accuracy': accuracy_obj})

# Create the Estimator and train.
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.47094986.
INFO:tensorflow:Loss for final step: 0.47094986.
({'Accuracy': 0.59375, 'loss': 1.7570661, 'global_step': 25}, [])

Estimator Premade

Estimator Premade dalam keluarga tf.estimator.DNN* , tf.estimator.Linear* dan tf.estimator.DNNLinearCombined* masih didukung di TensorFlow 2.x API. Namun, beberapa argumen telah berubah:

  1. input_layer_partitioner : Dihapus di v2.
  2. loss_reduction : Diperbarui ke tf.keras.losses.Reduction bukan tf.compat.v1.losses.Reduction . Nilai defaultnya juga diubah menjadi tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE dari tf.compat.v1.losses.Reduction.SUM .
  3. optimizer , dnn_optimizer dan linear_optimizer : argumen ini telah diperbarui menjadi tf.keras.optimizers alih-alih tf.compat.v1.train.Optimizer .

Untuk memindahkan perubahan di atas:

  1. Tidak diperlukan migrasi untuk input_layer_partitioner karena Distribution Strategy akan menanganinya secara otomatis di TensorFlow 2.x.
  2. Untuk loss_reduction , periksa tf.keras.losses.Reduction untuk opsi yang didukung.
  3. Untuk argumen optimizer :
    • Jika Anda tidak: 1) meneruskan argumen optimizer , dnn_optimizer , atau linear_optimizer , atau 2) menentukan argumen optimizer sebagai string dalam kode Anda, maka Anda tidak perlu mengubah apa pun karena tf.keras.optimizers digunakan secara default .
    • Jika tidak, Anda perlu memperbarui dari tf.compat.v1.train.Optimizer ke yang sesuai tf.keras.optimizers .

Konverter pos pemeriksaan

Migrasi ke keras.optimizers akan merusak checkpoint yang disimpan menggunakan TensorFlow 1.x, karena tf.keras.optimizers menghasilkan sekumpulan variabel berbeda untuk disimpan di checkpoint. Untuk membuat checkpoint lama dapat digunakan kembali setelah migrasi Anda ke TensorFlow 2.x, coba alat konverter checkpoint .

 curl -O https://raw.githubusercontent.com/tensorflow/estimator/master/tensorflow_estimator/python/estimator/tools/checkpoint_converter.py
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 15165  100 15165    0     0  40656      0 --:--:-- --:--:-- --:--:-- 40656

Alat tersebut memiliki bantuan bawaan:

 python checkpoint_converter.py -h
2021-01-06 02:31:26.297951: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0
usage: checkpoint_converter.py [-h]
                               {dnn,linear,combined} source_checkpoint
                               source_graph target_checkpoint

positional arguments:
  {dnn,linear,combined}
                        The type of estimator to be converted. So far, the
                        checkpoint converter only supports Canned Estimator.
                        So the allowed types include linear, dnn and combined.
  source_checkpoint     Path to source checkpoint file to be read in.
  source_graph          Path to source graph file to be read in.
  target_checkpoint     Path to checkpoint file to be written out.

optional arguments:
  -h, --help            show this help message and exit

TensorShape

Kelas ini disederhanakan untuk menampung int s, bukan objek tf.compat.v1.Dimension . Jadi tidak perlu memanggil .value untuk mendapatkan int .

Objek tf.compat.v1.Dimension individual masih dapat diakses dari tf.TensorShape.dims .

Berikut ini adalah demonstrasi perbedaan antara TensorFlow 1.x dan TensorFlow 2.x.

# Create a shape and choose an index
i = 0
shape = tf.TensorShape([16, None, 256])
shape
TensorShape([16, None, 256])

Jika Anda memiliki ini di TensorFlow 1.x:

value = shape[i].value

Kemudian lakukan ini di TensorFlow 2.x:

value = shape[i]
value
16

Jika Anda memiliki ini di TensorFlow 1.x:

for dim in shape:
    value = dim.value
    print(value)

Kemudian lakukan ini di TensorFlow 2.x:

for value in shape:
  print(value)
16
None
256

Jika Anda memiliki ini di TensorFlow 1.x (atau menggunakan metode dimensi lain):

dim = shape[i]
dim.assert_is_compatible_with(other_dim)

Kemudian lakukan ini di TensorFlow 2.x:

other_dim = 16
Dimension = tf.compat.v1.Dimension

if shape.rank is None:
  dim = Dimension(None)
else:
  dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
True
shape = tf.TensorShape(None)

if shape:
  dim = shape.dims[i]
  dim.is_compatible_with(other_dim) # or any other dimension method

Nilai boolean dari sebuah tf.TensorShape adalah True jika rangkingnya diketahui, False sebaliknya.

print(bool(tf.TensorShape([])))      # Scalar
print(bool(tf.TensorShape([0])))     # 0-length vector
print(bool(tf.TensorShape([1])))     # 1-length vector
print(bool(tf.TensorShape([None])))  # Unknown-length vector
print(bool(tf.TensorShape([1, 10, 100])))       # 3D tensor
print(bool(tf.TensorShape([None, None, None]))) # 3D tensor with no known dimensions
print()
print(bool(tf.TensorShape(None)))  # A tensor with unknown rank.
True
True
True
True
True
True

False

Perubahan lainnya

  • Hapus tf.colocate_with : Algoritme penempatan perangkat TensorFlow telah meningkat secara signifikan. Ini seharusnya tidak lagi diperlukan. Jika menghapusnya menyebabkan penurunan kinerja, harap laporkan bug .

  • Ganti penggunaan v1.ConfigProto dengan fungsi yang setara dari tf.config .

Kesimpulan

Proses keseluruhannya adalah:

  1. Jalankan skrip peningkatan.
  2. Hapus simbol kontribusi.
  3. Alihkan model Anda ke gaya berorientasi objek (Keras).
  4. Gunakan tf.keras pelatihan dan evaluasi tf.keras atau tf.estimator jika Anda bisa.
  5. Jika tidak, gunakan loop khusus, tetapi pastikan untuk menghindari sesi & koleksi.

Perlu sedikit usaha untuk mengonversi kode menjadi TensorFlow 2.x idiomatik, tetapi setiap perubahan menghasilkan:

  • Lebih sedikit baris kode.
  • Peningkatan kejelasan dan kesederhanaan.
  • Debugging lebih mudah.