Google I/O'da TensorFlow'a katılın, 11-12 Mayıs Şimdi kaydolun

Ön işleme katmanlarıyla çalışma

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

Keras ön işleme

Keras ön işleme katmanları API'si, geliştiricilerin Keras'a özgü girdi işleme boru hatları oluşturmasına olanak tanır. Bu girdi işleme boru hatları, Keras olmayan iş akışlarında bağımsız ön işleme kodu olarak kullanılabilir, doğrudan Keras modelleriyle birleştirilebilir ve Keras SavedModel'in bir parçası olarak dışa aktarılabilir.

Keras ön işleme katmanlarıyla, gerçekten uçtan uca modeller oluşturabilir ve dışa aktarabilirsiniz: ham görüntüleri veya ham yapılandırılmış verileri girdi olarak kabul eden modeller; özellik normalleştirmeyi veya özellik değeri indekslemeyi kendi başlarına işleyen modeller.

Mevcut ön işleme

Metin ön işleme

Sayısal özellikler ön işleme

Kategorik özellikler ön işleme

  • tf.keras.layers.CategoryEncoding : kategorik özellikler tamsayı döner çok sıcak, bir sıcak veya saymak yoğun gösterimleri içine.
  • tf.keras.layers.Hashing : gerçekleştirdiği da "karma hile" olarak bilinen kategorik özellik karma.
  • tf.keras.layers.StringLookup : döner dize kategorik bir tarafından okunabilen bir kodlanmış gösterimi değerleri Embedding tabakası ya da Dense bir tabaka.
  • tf.keras.layers.IntegerLookup : bir tarafından okunabilir bir kodlanmış gösterimine kategorik değerleri tam sayı dönüşler Embedding tabakası ya da Dense bir tabaka.

Görüntü ön işleme

Bu katmanlar, bir görüntü modelinin girdilerini standartlaştırmak içindir.

Görüntü verisi büyütme

Bu katmanlar, bir dizi görüntüye rastgele büyütme dönüşümleri uygular. Sadece eğitim sırasında aktiftirler.

adapt() metodu

Bazı ön işleme katmanları, eğitim verilerinin bir örneğine dayalı olarak hesaplanabilen dahili bir duruma sahiptir. Durum bilgisi olan ön işleme katmanlarının listesi:

  • TextVectorization : string jeton ve tamsayı indeksleri arasında bir eşleme tutan
  • StringLookup ve IntegerLookup : giriş değerleri ve tamsayı indeksleri arasında bir eşleme tutun.
  • Normalization : özelliklerinin ortalama ve standart sapma tutar.
  • Discretization : Değer kova sınırlar hakkında bilgi sahibidir.

En önemlisi, bu tabakalar olmayan eğitilebilen bulunmaktadır. Durumları eğitim sırasında belirlenmez; o eğitimden önce, ya precomputed sabit onları başlatarak, ya da onları verilere "adapte" tarafından ayarlanmalıdır.

Sen aracılığıyla, eğitim verileri maruz bırakarak bir ön işleme tabakasının durumunu ayarlamak adapt() yöntemiyle:

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers

data = np.array([[0.1, 0.2, 0.3], [0.8, 0.9, 1.0], [1.5, 1.6, 1.7],])
layer = layers.Normalization()
layer.adapt(data)
normalized_data = layer(data)

print("Features mean: %.2f" % (normalized_data.numpy().mean()))
print("Features std: %.2f" % (normalized_data.numpy().std()))
Features mean: -0.00
Features std: 1.00

adapt() metodu Numpy dizisini veya bir ya alır tf.data.Dataset nesnesi. Durumunda StringLookup ve TextVectorization , ayrıca dizeleri listesini geçirebilirsiniz:

data = [
    "ξεῖν᾽, ἦ τοι μὲν ὄνειροι ἀμήχανοι ἀκριτόμυθοι",
    "γίγνοντ᾽, οὐδέ τι πάντα τελείεται ἀνθρώποισι.",
    "δοιαὶ γάρ τε πύλαι ἀμενηνῶν εἰσὶν ὀνείρων:",
    "αἱ μὲν γὰρ κεράεσσι τετεύχαται, αἱ δ᾽ ἐλέφαντι:",
    "τῶν οἳ μέν κ᾽ ἔλθωσι διὰ πριστοῦ ἐλέφαντος,",
    "οἵ ῥ᾽ ἐλεφαίρονται, ἔπε᾽ ἀκράαντα φέροντες:",
    "οἱ δὲ διὰ ξεστῶν κεράων ἔλθωσι θύραζε,",
    "οἵ ῥ᾽ ἔτυμα κραίνουσι, βροτῶν ὅτε κέν τις ἴδηται.",
]
layer = layers.TextVectorization()
layer.adapt(data)
vectorized_text = layer(data)
print(vectorized_text)
tf.Tensor(
[[37 12 25  5  9 20 21  0  0]
 [51 34 27 33 29 18  0  0  0]
 [49 52 30 31 19 46 10  0  0]
 [ 7  5 50 43 28  7 47 17  0]
 [24 35 39 40  3  6 32 16  0]
 [ 4  2 15 14 22 23  0  0  0]
 [36 48  6 38 42  3 45  0  0]
 [ 4  2 13 41 53  8 44 26 11]], shape=(8, 9), dtype=int64)

Ek olarak, uyarlanabilir katmanlar her zaman yapıcı argümanları veya ağırlık ataması yoluyla doğrudan durum ayarlama seçeneği sunar. Amaçlanan durum değerleri katman inşaat zamanında bilinen veya dışında hesaplanır Eğer adapt() çağrısı, onlar katmanın iç hesaplama dayanmadan ayarlanabilir. İçin dış kelime dosyaları Örneğin, TextVectorization , StringLookup veya IntegerLookup katmanları zaten var, bu katmanın kurucu bağımsız yılında kelime dosyasına bir yola ileterek arama tabloları doğrudan yüklenebilir.

Burada bir örneğini bir örnek StringLookup önceden hesaplanabilir kelime ile katmanı:

vocab = ["a", "b", "c", "d"]
data = tf.constant([["a", "c", "d"], ["d", "z", "b"]])
layer = layers.StringLookup(vocabulary=vocab)
vectorized_data = layer(data)
print(vectorized_data)
tf.Tensor(
[[1 3 4]
 [4 0 2]], shape=(2, 3), dtype=int64)

Modelden önce veya modelin içindeki verileri ön işleme

Ön işleme katmanlarını kullanmanın iki yolu vardır:

1. Seçenek: Böyle modelin onlara parçası yapın:

inputs = keras.Input(shape=input_shape)
x = preprocessing_layer(inputs)
outputs = rest_of_the_model(x)
model = keras.Model(inputs, outputs)

Bu seçenekle, önişleme cihaz üzerinde, model yürütmenin geri kalanıyla eşzamanlı olarak gerçekleşecek, yani GPU hızlandırmasından faydalanacaktır. GPU üzerinde konum eğitim sen, bu en iyi seçenektir Normalization tabakasının ve tüm görüntü önişleme ve veri büyütme katmanları için.

2. Seçenek: uygulamak tf.data.Dataset bir veri kümesi elde edileceği şekilde, bu böyle Önişlenmiş verilerin verimleri toplu halde:

dataset = dataset.map(lambda x, y: (preprocessing_layer(x), y))

Bu seçenek ile önişlemeniz CPU üzerinde eşzamansız olarak gerçekleşecek ve modele girmeden önce arabelleğe alınacaktır. Eğer ararsanız ek olarak, dataset.prefetch(tf.data.AUTOTUNE) sizin veri kümesi üzerinde, ön işleme eğitimi ile paralel olarak verimli olur:

dataset = dataset.map(lambda x, y: (preprocessing_layer(x), y))
dataset = dataset.prefetch(tf.data.AUTOTUNE)
model.fit(dataset, ...)

Bu en iyi seçenektir TextVectorization ve tüm yapısal veri katmanları önişleme. Ayrıca CPU üzerinde eğitim alıyorsanız ve görüntü ön işleme katmanlarını kullanıyorsanız bu iyi bir seçenek olabilir.

TPU üzerinde çalışan, her zaman katmanları önişleme koymanız gerekir tf.data (hariç boru hattı Normalization ve Rescaling TPU üzerinde para cezası çalıştırın ve ilk katman bir görüntü modelidir gibi yaygın olarak kullanılmaktadır).

Çıkarım zamanında model içinde ön işleme yapmanın faydaları

Seçenek 2'yi seçseniz bile, daha sonra ön işleme katmanlarını içeren yalnızca çıkarsama amaçlı uçtan uca bir modeli dışa aktarmak isteyebilirsiniz. Bunu yapmanın anahtarı yararı da modeli taşınabilir hale getirir ve onu azaltmaya yardımcı olmasıdır çarpık hizmet / eğitim .

Tüm veri ön işlemesi modelin bir parçası olduğunda, diğer kişiler, her bir özelliğin nasıl kodlanmasının ve normalleştirilmesinin beklendiğinin farkında olmadan modelinizi yükleyebilir ve kullanabilir. Çıkarım modeliniz ham görüntüleri veya ham yapılandırılmış verileri işleyebilecek ve model kullanıcılarının örneğin metin için kullanılan simgeleştirme şeması, kategorik özellikler için kullanılan indeksleme şeması, görüntü piksel değerleri olup olmadığı gibi ayrıntılardan haberdar olmalarını gerektirmeyecektir. normalize edilir [-1, +1] veya [0, 1] böyle TensorFlow.js gibi başka bir çalışma için model ihraç eğer, vb bu özellikle güçlüdür: Eğer preprocessing tekrar uygulamanız gerekmez JavaScript'te boru hattı.

Başlangıçta da ön işleme katmanları koyarsanız tf.data boru hattı, bir çıkarım modeli paketleri o ön işleme aktarabilirsiniz. Ön işleme katmanlarınızı ve eğitim modelinizi zincirleyen yeni bir modeli başlatmanız yeterlidir:

inputs = keras.Input(shape=input_shape)
x = preprocessing_layer(inputs)
outputs = training_model(x)
inference_model = keras.Model(inputs, outputs)

Hızlı yemek tarifleri

Görüntü verisi büyütme

Bu görüntü veri büyütme tabakalar eğitim sırasında (benzer şekilde, sadece aktif Not Dropout tabakası).

from tensorflow import keras
from tensorflow.keras import layers

# Create a data augmentation stage with horizontal flipping, rotations, zooms
data_augmentation = keras.Sequential(
    [
        layers.RandomFlip("horizontal"),
        layers.RandomRotation(0.1),
        layers.RandomZoom(0.1),
    ]
)

# Load some data
(x_train, y_train), _ = keras.datasets.cifar10.load_data()
input_shape = x_train.shape[1:]
classes = 10

# Create a tf.data pipeline of augmented images (and their labels)
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.batch(16).map(lambda x, y: (data_augmentation(x), y))


# Create a model and train it on the augmented image data
inputs = keras.Input(shape=input_shape)
x = layers.Rescaling(1.0 / 255)(inputs)  # Rescale inputs
outputs = keras.applications.ResNet50(  # Add the rest of the model
    weights=None, input_shape=input_shape, classes=classes
)(x)
model = keras.Model(inputs, outputs)
model.compile(optimizer="rmsprop", loss="sparse_categorical_crossentropy")
model.fit(train_dataset, steps_per_epoch=5)
Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170500096/170498071 [==============================] - 6s 0us/step
170508288/170498071 [==============================] - 6s 0us/step
5/5 [==============================] - 11s 44ms/step - loss: 8.8927
<keras.callbacks.History at 0x7f1c0c3f16d0>

Sen örnek eylem benzer bir kurulum görebilirsiniz sıfırdan görüntü sınıflandırma .

Sayısal özellikleri normalleştirme

# Load some data
(x_train, y_train), _ = keras.datasets.cifar10.load_data()
x_train = x_train.reshape((len(x_train), -1))
input_shape = x_train.shape[1:]
classes = 10

# Create a Normalization layer and set its internal state using the training data
normalizer = layers.Normalization()
normalizer.adapt(x_train)

# Create a model that include the normalization layer
inputs = keras.Input(shape=input_shape)
x = normalizer(inputs)
outputs = layers.Dense(classes, activation="softmax")(x)
model = keras.Model(inputs, outputs)

# Train the model
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
model.fit(x_train, y_train)
1563/1563 [==============================] - 3s 2ms/step - loss: 2.1304
<keras.callbacks.History at 0x7f1bc43f40d0>

Tek-sıcak kodlama yoluyla dize kategorik özelliklerini kodlama

# Define some toy data
data = tf.constant([["a"], ["b"], ["c"], ["b"], ["c"], ["a"]])

# Use StringLookup to build an index of the feature values and encode output.
lookup = layers.StringLookup(output_mode="one_hot")
lookup.adapt(data)

# Convert new test data (which includes unknown feature values)
test_data = tf.constant([["a"], ["b"], ["c"], ["d"], ["e"], [""]])
encoded_data = lookup(test_data)
print(encoded_data)
tf.Tensor(
[[0. 0. 0. 1.]
 [0. 0. 1. 0.]
 [0. 1. 0. 0.]
 [1. 0. 0. 0.]
 [1. 0. 0. 0.]
 [1. 0. 0. 0.]], shape=(6, 4), dtype=float32)

O, burada, endeks 0 dışı kelime değerleri için ayrılmıştır Not (sırasında görülen olmadığını değerleri adapt() ).

Görebilirsiniz StringLookup içinde eylem çizik gelen Yapılandırılmış veri sınıflandırma örneğin.

Tek-sıcak kodlama yoluyla tamsayı kategorik özelliklerini kodlama

# Define some toy data
data = tf.constant([[10], [20], [20], [10], [30], [0]])

# Use IntegerLookup to build an index of the feature values and encode output.
lookup = layers.IntegerLookup(output_mode="one_hot")
lookup.adapt(data)

# Convert new test data (which includes unknown feature values)
test_data = tf.constant([[10], [10], [20], [50], [60], [0]])
encoded_data = lookup(test_data)
print(encoded_data)
tf.Tensor(
[[0. 0. 1. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 1. 0. 0. 0.]
 [1. 0. 0. 0. 0.]
 [1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1.]], shape=(6, 5), dtype=float32)

Endeks 0 eksik değerler için ayrıldığına dikkat Not (Eğer değeri 0 olarak belirtmek zorunda olan) ve indeks 1-dışı kelime değerleri için ayrılmıştır (sırasında görülen olmadığını değerleri adapt() ). Sen kullanarak bu yapılandırabilir mask_token ve oov_token yapıcısı argümanları IntegerLookup .

Görebilirsiniz IntegerLookup örneği de eylem sıfırdan yapılandırılmış veri sınıflandırma .

Karma hilesini bir tamsayı kategorik özelliğine uygulama

Birçok farklı değer alabilen (10e3 veya daha yüksek mertebede) kategorik bir özelliğiniz varsa, her değerin verilerde yalnızca birkaç kez göründüğü, özellik değerlerini indekslemek ve one-hot kodlamak pratik ve etkisiz hale gelir. Bunun yerine, "karma hilesini" uygulamak iyi bir fikir olabilir: değerleri sabit boyutlu bir vektöre hash edin. Bu, özellik alanının boyutunu yönetilebilir tutar ve açık indeksleme ihtiyacını ortadan kaldırır.

# Sample data: 10,000 random integers with values between 0 and 100,000
data = np.random.randint(0, 100000, size=(10000, 1))

# Use the Hashing layer to hash the values to the range [0, 64]
hasher = layers.Hashing(num_bins=64, salt=1337)

# Use the CategoryEncoding layer to multi-hot encode the hashed values
encoder = layers.CategoryEncoding(num_tokens=64, output_mode="multi_hot")
encoded_data = encoder(hasher(data))
print(encoded_data.shape)
(10000, 64)

Metni bir dizi belirteç indeksi olarak kodlama

Bu da metin bir geçirilecek ön işlemeden nasıl olduğunu Embedding tabakasının.

# Define some text data to adapt the layer
adapt_data = tf.constant(
    [
        "The Brain is wider than the Sky",
        "For put them side by side",
        "The one the other will contain",
        "With ease and You beside",
    ]
)

# Create a TextVectorization layer
text_vectorizer = layers.TextVectorization(output_mode="int")
# Index the vocabulary via `adapt()`
text_vectorizer.adapt(adapt_data)

# Try out the layer
print(
    "Encoded text:\n", text_vectorizer(["The Brain is deeper than the sea"]).numpy(),
)

# Create a simple model
inputs = keras.Input(shape=(None,), dtype="int64")
x = layers.Embedding(input_dim=text_vectorizer.vocabulary_size(), output_dim=16)(inputs)
x = layers.GRU(8)(x)
outputs = layers.Dense(1)(x)
model = keras.Model(inputs, outputs)

# Create a labeled dataset (which includes unknown tokens)
train_dataset = tf.data.Dataset.from_tensor_slices(
    (["The Brain is deeper than the sea", "for if they are held Blue to Blue"], [1, 0])
)

# Preprocess the string inputs, turning them into int sequences
train_dataset = train_dataset.batch(2).map(lambda x, y: (text_vectorizer(x), y))
# Train the model on the int sequences
print("\nTraining model...")
model.compile(optimizer="rmsprop", loss="mse")
model.fit(train_dataset)

# For inference, you can export a model that accepts strings as input
inputs = keras.Input(shape=(1,), dtype="string")
x = text_vectorizer(inputs)
outputs = model(x)
end_to_end_model = keras.Model(inputs, outputs)

# Call the end-to-end model on test data (which includes unknown tokens)
print("\nCalling end-to-end model on test string...")
test_data = tf.constant(["The one the other will absorb"])
test_output = end_to_end_model(test_data)
print("Model output:", test_output)
Encoded text:
 [[ 2 19 14  1  9  2  1]]

Training model...
1/1 [==============================] - 3s 3s/step - loss: 0.4776

Calling end-to-end model on test string...
Model output: tf.Tensor([[0.04233753]], shape=(1, 1), dtype=float32)

Görebilirsiniz TextVectorization bir kombine eylem katmanı, Embedding örnek modundayken, sıfırdan metin sınıflandırma .

Böyle bir modeli eğitim sırasında, en iyi performans için, her zaman kullanması gerektiğini Not TextVectorization girdi boru hattının bir parçası olarak katmanını.

Metni çok sıcak kodlama ile yoğun bir ngram matrisi olarak kodlama

Bu da metin bir geçirilecek ön işlemeden nasıl olduğunu Dense katmanın.

# Define some text data to adapt the layer
adapt_data = tf.constant(
    [
        "The Brain is wider than the Sky",
        "For put them side by side",
        "The one the other will contain",
        "With ease and You beside",
    ]
)
# Instantiate TextVectorization with "multi_hot" output_mode
# and ngrams=2 (index all bigrams)
text_vectorizer = layers.TextVectorization(output_mode="multi_hot", ngrams=2)
# Index the bigrams via `adapt()`
text_vectorizer.adapt(adapt_data)

# Try out the layer
print(
    "Encoded text:\n", text_vectorizer(["The Brain is deeper than the sea"]).numpy(),
)

# Create a simple model
inputs = keras.Input(shape=(text_vectorizer.vocabulary_size(),))
outputs = layers.Dense(1)(inputs)
model = keras.Model(inputs, outputs)

# Create a labeled dataset (which includes unknown tokens)
train_dataset = tf.data.Dataset.from_tensor_slices(
    (["The Brain is deeper than the sea", "for if they are held Blue to Blue"], [1, 0])
)

# Preprocess the string inputs, turning them into int sequences
train_dataset = train_dataset.batch(2).map(lambda x, y: (text_vectorizer(x), y))
# Train the model on the int sequences
print("\nTraining model...")
model.compile(optimizer="rmsprop", loss="mse")
model.fit(train_dataset)

# For inference, you can export a model that accepts strings as input
inputs = keras.Input(shape=(1,), dtype="string")
x = text_vectorizer(inputs)
outputs = model(x)
end_to_end_model = keras.Model(inputs, outputs)

# Call the end-to-end model on test data (which includes unknown tokens)
print("\nCalling end-to-end model on test string...")
test_data = tf.constant(["The one the other will absorb"])
test_output = end_to_end_model(test_data)
print("Model output:", test_output)
WARNING:tensorflow:5 out of the last 1567 calls to <function PreprocessingLayer.make_adapt_function.<locals>.adapt_step at 0x7f1b9c5c5290> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
Encoded text:
 [[1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 0. 0. 0. 0. 0.

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

Training model...
1/1 [==============================] - 0s 231ms/step - loss: 1.0046

Calling end-to-end model on test string...
Model output: tf.Tensor([[-0.54753447]], shape=(1, 1), dtype=float32)

Metni TF-IDF ağırlıklı yoğun bir ngram matrisi olarak kodlama

Bu geçirmeden önce metni ön işlenmesi için alternatif bir yoldur Dense katmanın.

# Define some text data to adapt the layer
adapt_data = tf.constant(
    [
        "The Brain is wider than the Sky",
        "For put them side by side",
        "The one the other will contain",
        "With ease and You beside",
    ]
)
# Instantiate TextVectorization with "tf-idf" output_mode
# (multi-hot with TF-IDF weighting) and ngrams=2 (index all bigrams)
text_vectorizer = layers.TextVectorization(output_mode="tf-idf", ngrams=2)
# Index the bigrams and learn the TF-IDF weights via `adapt()`

with tf.device("CPU"):
    # A bug that prevents this from running on GPU for now.
    text_vectorizer.adapt(adapt_data)

# Try out the layer
print(
    "Encoded text:\n", text_vectorizer(["The Brain is deeper than the sea"]).numpy(),
)

# Create a simple model
inputs = keras.Input(shape=(text_vectorizer.vocabulary_size(),))
outputs = layers.Dense(1)(inputs)
model = keras.Model(inputs, outputs)

# Create a labeled dataset (which includes unknown tokens)
train_dataset = tf.data.Dataset.from_tensor_slices(
    (["The Brain is deeper than the sea", "for if they are held Blue to Blue"], [1, 0])
)

# Preprocess the string inputs, turning them into int sequences
train_dataset = train_dataset.batch(2).map(lambda x, y: (text_vectorizer(x), y))
# Train the model on the int sequences
print("\nTraining model...")
model.compile(optimizer="rmsprop", loss="mse")
model.fit(train_dataset)

# For inference, you can export a model that accepts strings as input
inputs = keras.Input(shape=(1,), dtype="string")
x = text_vectorizer(inputs)
outputs = model(x)
end_to_end_model = keras.Model(inputs, outputs)

# Call the end-to-end model on test data (which includes unknown tokens)
print("\nCalling end-to-end model on test string...")
test_data = tf.constant(["The one the other will absorb"])
test_output = end_to_end_model(test_data)
print("Model output:", test_output)
WARNING:tensorflow:6 out of the last 1568 calls to <function PreprocessingLayer.make_adapt_function.<locals>.adapt_step at 0x7f1b9f6eae60> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
Encoded text:
 [[5.461647  1.6945957 0.        0.        0.        0.        0.

  0.        0.        0.        0.        0.        0.        0.
  0.        0.        1.0986123 1.0986123 1.0986123 0.        0.
  0.        0.        0.        0.        0.        0.        0.
  1.0986123 0.        0.        0.        0.        0.        0.
  0.        1.0986123 1.0986123 0.        0.        0.       ]]

Training model...
1/1 [==============================] - 0s 239ms/step - loss: 4.4868

Calling end-to-end model on test string...
Model output: tf.Tensor([[0.25670475]], shape=(1, 1), dtype=float32)

Önemli bilgiler

Çok geniş kelime dağarcığına sahip arama katmanlarıyla çalışma

Sen kendine çok büyük bir kelime ile çalışan bulabilirsiniz TextVectorization , bir StringLookup katmanına veya bir IntegerLookup katmanına. Tipik olarak, 500 MB'den büyük bir kelime dağarcığı "çok büyük" olarak kabul edilir.

Böyle bir durumda, en iyi performans için, size kullanmaktan kaçınmalısınız adapt() . Bunun yerine, kelime dağarcığınızı önceden hesaplayın (bunun için Apache Beam veya TF Transform kullanabilirsiniz) ve bir dosyada saklayın. Sonra da dosya yolunu geçen inşaat sırasında tabaka halinde kelime yük vocabulary argüman.

Bir TPU pod veya arama katmanları kullanma ParameterServerStrategy .

Bir kullanırken dejenere performansı neden olağanüstü bir sorunu var TextVectorization , StringLookup veya IntegerLookup katman ise bir TPU pod veya yoluyla birden makinelerde eğitim ParameterServerStrategy . Bunun TensorFlow 2.7'de düzeltilmesi planlanıyor.