TensorFlow 2'deki TF Hub'dan Kaydedilen Modeller

TensorFlow 2'nin SavedModel formatı, önceden eğitilmiş modelleri ve model parçalarını TensorFlow Hub'da paylaşmanın önerilen yoludur. Eski TF1 Hub formatının yerini alır ve yeni bir API seti ile birlikte gelir.

Bu sayfa, düşük seviyeli hub.load() API'si ve hub.KerasLayer sarmalayıcısı ile bir TensorFlow 2 programında TF2 SavedModels'in nasıl yeniden kullanılacağını açıklar. (Genellikle hub.KerasLayer , bir model_fn oluşturmak için diğer tf.keras.layers ile birleştirilir.) Bu API'ler ayrıca eski modelleri sınırlar dahilinde TF1 Hub biçiminde yükleyebilir, uyumluluk kılavuzuna bakın.

TensorFlow 1 kullanıcıları TF 1.15'e güncelleme yapabilir ve ardından aynı API'leri kullanabilir. TF1'in eski sürümleri çalışmıyor.

TF Hub'dan SavedModels'i Kullanma

Keras'ta SavedModel kullanma

Keras , TensorFlow'un Keras Layer nesneleri oluşturarak derin öğrenme modelleri oluşturmaya yönelik üst düzey API'sidir. tensorflow_hub kitaplığı, SavedModel'in URL'si (veya dosya sistemi yolu) ile başlatılan ve ardından önceden eğitilmiş ağırlıkları dahil SavedModel'den hesaplama sağlayan hub.KerasLayer sınıfını sağlar.

Önceden eğitilmiş bir metin gömme kullanımına bir örnek:

import tensorflow as tf
import tensorflow_hub as hub

hub_url = "https://tfhub.dev/google/nnlm-en-dim128/2"
embed = hub.KerasLayer(hub_url)
embeddings = embed(["A long sentence.", "single-word", "http://example.com"])
print(embeddings.shape, embeddings.dtype)

Bundan, her zamanki Keras yöntemiyle bir metin sınıflandırıcı oluşturulabilir:

model = tf.keras.Sequential([
    embed,
    tf.keras.layers.Dense(16, activation="relu"),
    tf.keras.layers.Dense(1, activation="sigmoid"),
])

Metin sınıflandırma ortak çalışması , böyle bir sınıflandırıcının nasıl eğitileceği ve değerlendirileceği konusunda eksiksiz bir örnektir.

Bir hub.KerasLayer'daki model ağırlıkları, varsayılan olarak hub.KerasLayer olarak ayarlanmıştır. Bunun nasıl değiştirileceğini öğrenmek için aşağıdaki ince ayar bölümüne bakın. Ağırlıklar, Keras'ta her zamanki gibi aynı katman nesnesinin tüm uygulamaları arasında paylaşılır.

Tahmin Edicide SavedModel Kullanma

Dağıtılmış eğitim için TensorFlow'un Tahminci API'sinin kullanıcıları, model_fn'lerini diğer hub.KerasLayer arasında model_fn cinsinden yazarak TF Hub'dan tf.keras.layers .

Sahne arkası: SavedModel indirme ve önbelleğe alma

TensorFlow Hub'dan (veya barındırma protokolünü uygulayan diğer HTTPS sunucularından) bir SavedModel kullanmak, zaten mevcut değilse, onu indirir ve yerel dosya sistemine açar. TFHUB_CACHE_DIR ortam değişkeni, indirilen ve sıkıştırılmamış SavedModel'leri önbelleğe almak için varsayılan geçici konumu geçersiz kılmak üzere ayarlanabilir. Ayrıntılar için, bkz. Önbelleğe Alma .

Düşük seviyeli TensorFlow'da SavedModel kullanma

hub.load(handle) işlevi bir SavedModel'i indirir ve sıkıştırır ( handle zaten bir dosya sistemi yolu değilse) ve ardından TensorFlow'un yerleşik işlevi tf.saved_model.load() ile yüklemenin sonucunu döndürür. Bu nedenle hub.load() , geçerli herhangi bir SavedModel'i işleyebilir (önceki hub.Module for TF1'den farklı olarak).

Gelişmiş konu: Yüklemeden sonra SavedModel'den ne beklenebilir?

SavedModel'in içeriğine bağlı olarak, obj = hub.load(...) 'un sonucu çeşitli şekillerde çağrılabilir (TensorFlow'un SavedModel Kılavuzunda çok daha ayrıntılı olarak açıklandığı gibi:

  • SavedModel'in (varsa) hizmet veren imzaları, somut işlevlerin bir sözlüğü olarak temsil edilir ve ilgili giriş ve çıkış tarafından anahtarlanan tensör sözlükleriyle tensors_out = obj.signatures["serving_default"](**tensors_in) gibi çağrılabilir. adlar ve imzanın şekli ve türü kısıtlamalarına tabidir.

  • Kaydedilen nesnenin (varsa) @tf.function -decorated yöntemleri, kaydetmeden önce tf.function öğesinin izlendiği tüm Tensor ve Tensor olmayan argüman kombinasyonları tarafından çağrılabilen tf.function nesneleri olarak geri yüklenir. Özellikle, uygun izlemelere sahip bir obj obj.__call__ yöntemi varsa, obj'nin kendisi bir Python işlevi gibi çağrılabilir. Basit bir örnek, output_tensor = obj(input_tensor, training=False) gibi görünebilir.

Bu, SavedModels'in uygulayabileceği arabirimlerde muazzam bir özgürlük sağlar. obj için Yeniden Kullanılabilir SavedModels arabirimi , hub.KerasLayer gibi bağdaştırıcılar da dahil olmak üzere istemci kodunun SavedModel'in nasıl kullanılacağını bilmesi için kurallar oluşturur.

Bazı SavedModel'ler, özellikle daha büyük modellerde yeniden kullanılması amaçlanmayan tüm modeller bu kuralı takip etmeyebilir ve yalnızca hizmet imzaları sağlar.

SavedModel'deki eğitilebilir değişkenler, eğitilebilir olarak yeniden yüklenir ve tf.GradientTape bunları varsayılan olarak izleyecektir. Bazı uyarılar için aşağıdaki ince ayar bölümüne bakın ve yeni başlayanlar için bundan kaçınmayı düşünün. İnce ayar yapmak isteseniz bile, obj.trainable_variables orijinal olarak eğitilebilir değişkenlerin yalnızca bir alt kümesini yeniden eğitmeyi tavsiye edip etmediğini görmek isteyebilirsiniz.

TF Hub için Kayıtlı Modeller Oluşturma

genel bakış

SavedModel, eğitimli modeller veya model parçaları için TensorFlow'un standart serileştirme formatıdır. Modelin eğitilmiş ağırlıklarını, hesaplamasını gerçekleştirmek için tam TensorFlow işlemleriyle birlikte saklar. Onu oluşturan koddan bağımsız olarak kullanılabilir. Özellikle, Keras gibi farklı üst düzey model oluşturma API'lerinde yeniden kullanılabilir, çünkü TensorFlow işlemleri ortak temel dilleridir.

Keras'tan kaydetme

TensorFlow 2 ile başlayarak, tf.keras.Model.save() ve tf.keras.models.save_model() varsayılan olarak SavedModel formatına (HDF5 değil) geçer. Ortaya çıktıkça hub.load() , hub.KerasLayer ve diğer üst düzey API'ler için benzer bağdaştırıcılarla kullanılabilen SavedModels.

Tam bir Keras Modelini paylaşmak için bunu include_optimizer=False ile kaydedin.

Keras Modelinin bir parçasını paylaşmak için, parçayı kendi içinde bir Model yapın ve ardından kaydedin. Kodu baştan böyle düzenleyebilirsiniz ....

piece_to_share = tf.keras.Model(...)
full_model = tf.keras.Sequential([piece_to_share, ...])
full_model.fit(...)
piece_to_share.save(...)

...veya olaydan sonra paylaşılacak parçayı kesin (tam modelinizin katmanlaması ile aynı hizadaysa):

full_model = tf.keras.Model(...)
sharing_input = full_model.get_layer(...).get_output_at(0)
sharing_output = full_model.get_layer(...).get_output_at(0)
piece_to_share = tf.keras.Model(sharing_input, sharing_output)
piece_to_share.save(..., include_optimizer=False)

GitHub'daki TensorFlow Modelleri , BERT için eski yaklaşımı kullanır (bkz. nlp/tools/export_tfhub_lib.py , dışa aktarma için pretrainer core_model ikinci yaklaşım (bkz. Legacy/image_classification/tfhub_export.py ).

Düşük seviyeli TensorFlow'dan kaydetme

Bu, TensorFlow'un SavedModel Kılavuzuna iyi bir aşinalık gerektirir.

Yalnızca bir sunum imzasından fazlasını sağlamak istiyorsanız, Yeniden Kullanılabilir SavedModel arabirimini uygulamalısınız. Kavramsal olarak, bu gibi görünüyor

class MyMulModel(tf.train.Checkpoint):
  def __init__(self, v_init):
    super().__init__()
    self.v = tf.Variable(v_init)
    self.variables = [self.v]
    self.trainable_variables = [self.v]
    self.regularization_losses = [
        tf.function(input_signature=[])(lambda: 0.001 * self.v**2),
    ]

  @tf.function(input_signature=[tf.TensorSpec(shape=None, dtype=tf.float32)])
  def __call__(self, inputs):
    return tf.multiply(inputs, self.v)

tf.saved_model.save(MyMulModel(2.0), "/tmp/my_mul")

layer = hub.KerasLayer("/tmp/my_mul")
print(layer([10., 20.]))  # [20., 40.]
layer.trainable = True
print(layer.trainable_weights)  # [2.]
print(layer.losses)  # 0.004

İnce ayar

İçe aktarılan bir SavedModel'in önceden eğitilmiş değişkenlerini, etrafındaki modelinkilerle birlikte eğitmek, SavedModel'de ince ayar yapmak olarak adlandırılır. Bu, daha iyi kalite ile sonuçlanabilir, ancak genellikle eğitimi daha zorlu hale getirir (daha fazla zaman alabilir, optimize ediciye ve hiperparametrelerine daha fazla bağlı olabilir, fazla uyum riskini artırır ve özellikle CNN'ler için veri kümesi büyütmesi gerektirebilir). SavedModel tüketicilerine, yalnızca iyi bir eğitim rejimi oluşturduktan sonra ve yalnızca SavedModel yayıncısı önerdiği takdirde ince ayar yapmalarını öneriyoruz.

İnce ayar, eğitilen "sürekli" model parametrelerini değiştirir. Metin girişini simgeleştirme ve belirteçleri bir gömme matrisinde karşılık gelen girişlerine eşleme gibi sabit kodlanmış dönüşümleri değiştirmez.

SavedModel tüketicileri için

Bir hub.KerasLayer oluşturma gibi

layer = hub.KerasLayer(..., trainable=True)

katman tarafından yüklenen SavedModel'in ince ayarını sağlar. SavedModel'de bildirilen eğitilebilir ağırlıkları ve ağırlık düzenleyicilerini Keras modeline ekler ve SavedModel'in hesaplamasını eğitim modunda çalıştırır (bırakmayı düşünün vb.).

Görüntü sınıflandırma ortak çalışması , isteğe bağlı ince ayarlı uçtan uca bir örnek içerir.

İnce ayar sonucunu yeniden dışa aktarma

İleri düzey kullanıcılar, ince ayar sonuçlarını, orijinal olarak yüklenenin yerine kullanılabilecek bir SavedModel'e geri kaydetmek isteyebilir. Bu gibi bir kodla yapılabilir

loaded_obj = hub.load("https://tfhub.dev/...")
hub_layer = hub.KerasLayer(loaded_obj, trainable=True, ...)

model = keras.Sequential([..., hub_layer, ...])
model.compile(...)
model.fit(...)

export_module_dir = os.path.join(os.getcwd(), "finetuned_model_export")
tf.saved_model.save(loaded_obj, export_module_dir)

SavedModel yaratıcıları için

TensorFlow Hub'da paylaşmak için bir SavedModel oluştururken, tüketicilerinin buna nasıl ince ayar yapması gerektiğini önceden düşünün ve belgelerde rehberlik sağlayın.

Bir Keras Modelinden kaydetme, ince ayar çalışmasının tüm mekaniklerini yapmalıdır (ağırlık düzenleme kayıplarından tasarruf etmek, eğitilebilir değişkenleri bildirmek, hem training=True hem de training training=False , vb. için __call__ izleme).

Gradyan akışıyla iyi oynayan bir model arayüzü seçin, örneğin softmax olasılıkları veya en iyi tahminler yerine çıktı logitleri.

Model, hiperparametreler içeren bırakma, toplu normalleştirme veya benzer eğitim teknikleri kullanıyorsa, bunları, beklenen birçok hedef sorun ve toplu iş boyutunda anlamlı olan değerlere ayarlayın. (Bu yazı itibariyle, Keras'tan tasarruf, tüketicilerin bunları ayarlamasına izin vermeyi kolaylaştırmıyor.)

Tek tek katmanlardaki ağırlık düzenleyiciler kaydedilir (düzenleme güç katsayılarıyla birlikte), ancak optimize edicinin içindeki ağırlık düzenlemesi ( tf.keras.optimizers.Ftrl.l1_regularization_strength=...) kaybolur. SavedModel'inizin tüketicilerini buna göre bilgilendirin.