کمک به حفاظت از دیواره بزرگ مرجانی با TensorFlow در Kaggle اضافه کردن چالش

کار با لایه های پیش پردازش

مشاهده در TensorFlow.org در Google Colab اجرا شود مشاهده منبع در GitHub دانلود دفترچه یادداشت

پیش پردازش Keras

API لایه‌های پیش‌پردازش Keras به توسعه‌دهندگان اجازه می‌دهد خطوط لوله پردازش ورودی بومی Keras را بسازند. این خطوط لوله پردازش ورودی را می‌توان به عنوان کد پیش‌پردازش مستقل در جریان‌های کاری غیر Keras استفاده کرد، مستقیماً با مدل‌های Keras ترکیب شد و به عنوان بخشی از Keras SavedModel صادر شد.

با لایه‌های پیش‌پردازش Keras، می‌توانید مدل‌هایی بسازید و صادر کنید که واقعاً سرتاسر هستند: مدل‌هایی که تصاویر خام یا داده‌های ساختاریافته خام را به عنوان ورودی می‌پذیرند. مدل هایی که به خودی خود نرمال سازی ویژگی یا نمایه سازی ارزش ویژگی را انجام می دهند.

پیش پردازش موجود

پیش پردازش متن

  • tf.keras.layers.TextVectorization : تبدیل رشته های خام را به نمایندگی های کد گذاری است که می تواند توسط یک خوانده Embedding لایه یا Dense لایه.

پیش پردازش ویژگی های عددی

پیش پردازش ویژگی های طبقه بندی شده

  • tf.keras.layers.CategoryEncoding : نوبت عدد صحیح ویژگی های طبقه را به یکی از داغ، چند گرم، و یا تعداد نمایندگی متراکم.
  • tf.keras.layers.Hashing : انجام هش کردن ویژگی قطعی، همچنین به عنوان "ترفند هش کردن" شناخته شده است.
  • tf.keras.layers.StringLookup : نوبت رشته قطعی ارزش نمایندگی کد گذاری است که می تواند توسط یک خوانده Embedding لایه یا Dense لایه.
  • tf.keras.layers.IntegerLookup : نوبت عدد صحیح مقادیر قطعی را به یک نمایندگی کد گذاری است که می تواند توسط یک خوانده Embedding لایه یا Dense لایه.

پیش پردازش تصویر

این لایه ها برای استانداردسازی ورودی های یک مدل تصویر هستند.

  • tf.keras.layers.Resizing : تغییر اندازه دسته ای از تصاویر به اندازه هدف.
  • tf.keras.layers.Rescaling : rescales و جبران ارزش از دسته ای از تصویر (به عنوان مثال رفتن از ورودی در [0, 255] وسیعی به ورودی در [0, 1] محدوده.
  • tf.keras.layers.CenterCrop : گرداند یک محصول مرکز یک دسته ای از تصاویر.

افزایش داده های تصویری

این لایه ها تبدیل های افزایش تصادفی را به دسته ای از تصاویر اعمال می کنند. آنها فقط در حین تمرین فعال هستند.

adapt() روش

برخی از لایه های پیش پردازش دارای یک حالت داخلی هستند که می توان آن را بر اساس نمونه ای از داده های آموزشی محاسبه کرد. لیست لایه های پیش پردازش حالت دار به شرح زیر است:

  • TextVectorization : دارای یک نگاشت بین نشانه رشته و شاخص عدد صحیح
  • StringLookup و IntegerLookup : برگزاری یک نگاشت بین مقادیر ورودی و شاخص عدد صحیح است.
  • Normalization : دارای انحراف از معیار و استاندارد از ویژگی های.
  • Discretization : اطلاعات در مورد مرزهای سطل ارزش نگه می دارد.

قطعا این لایه غیر تربیت شدنی هستند. وضعیت آنها در طول آموزش تعیین نمی شود. باید آن را قبل از آموزش، یا با مقدار دهی اولیه آنها را از یک ثابت از قبل محاسبه، و یا با "آداپتورهای آنان" آنها را در مجموعه داده.

شما دولت از یک لایه از پیش پردازش با افشای آن را به داده های آموزشی مجموعه، از طریق adapt() روش:

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() روش هم یک آرایه نامپای یا طول می کشد tf.data.Dataset شی. در مورد StringLookup و TextVectorization ، شما همچنین می توانید یک لیست از رشته عبور:

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)

علاوه بر این، لایه‌های سازگار همیشه گزینه‌ای را برای تنظیم مستقیم حالت از طریق آرگومان‌های سازنده یا تخصیص وزن در معرض دید قرار می‌دهند. اگر ارزش های دولت در نظر گرفته شده در زمان ساخت و ساز لایه شناخته شده است، و یا در خارج از محاسبه adapt() پاسخ، می توان آنها را بدون تکیه بر محاسبات داخلی لایه تنظیم شده است. برای مثال، اگر فایل های واژگان خارجی برای TextVectorization ، StringLookup یا IntegerLookup لایه حال حاضر وجود دارد، آن را می توان به طور مستقیم به جداول Lookup با گذراندن یک مسیر فایل لغات در آرگومان های لایه را لود می شود.

در اینجا یک مثال که در آن ما یک نمونه از یک است StringLookup لایه با واژگان پیش محاسبه:

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)

پیش پردازش داده ها قبل از مدل یا داخل مدل

دو روش برای استفاده از لایه های پیش پردازش وجود دارد:

انتخاب 1: آنها بخشی از مدل، مثل این:

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

با استفاده از این گزینه، پیش پردازش روی دستگاه، همزمان با بقیه اجرای مدل انجام می شود، به این معنی که از شتاب GPU بهره مند می شود. اگر شما آموزش هستید در GPU، این بهترین گزینه برای است Normalization لایه، و برای همه تصویر از پیش پردازش و لایه های تقویت داده است.

انتخاب 2: درخواست آن را به خود tf.data.Dataset ، بنابراین به عنوان به دست آوردن یک مجموعه داده است که بازده دسته از داده ها پیش پردازش، مثل این:

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

با استفاده از این گزینه، پیش پردازش شما در CPU به صورت ناهمزمان انجام می شود و قبل از ورود به مدل بافر می شود. علاوه بر این، اگر شما پاسخ dataset.prefetch(tf.data.AUTOTUNE) در مجموعه داده های خود، پیش پردازش خواهد کارآمد به صورت موازی با آموزش اتفاق می افتد:

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

این بهترین گزینه است TextVectorization ، و همه داده های ساخت یافته از پیش پردازش لایه. همچنین اگر روی CPU آموزش می بینید و از لایه های پیش پردازش تصویر استفاده می کنید، می تواند گزینه خوبی باشد.

هنگامی که در حال اجرا در TPU، شما همیشه باید از پیش پردازش لایه را در جای tf.data خط لوله (به استثنای Normalization و Rescaling ، که اجرای خوب در TPU و مورد استفاده هستند به عنوان اولین لایه مدل تصویر است).

مزایای انجام پیش پردازش در داخل مدل در زمان استنتاج

حتی اگر گزینه 2 را انتخاب کنید، ممکن است بعداً بخواهید یک مدل end-to-end فقط استنتاج صادر کنید که شامل لایه های پیش پردازش می شود. مزایای کلیدی برای انجام این کار این است که آن را می سازد مدل خود را قابل حمل و کمک می کند تا کاهش آموزش / خدمت چوله .

هنگامی که تمام پیش پردازش داده ها بخشی از مدل است، افراد دیگر می توانند مدل شما را بارگیری و استفاده کنند، بدون اینکه بدانند هر ویژگی چگونه انتظار می رود کدگذاری و عادی شود. مدل استنتاج شما می‌تواند تصاویر خام یا داده‌های ساختاریافته خام را پردازش کند، و نیازی نیست که کاربران مدل از جزئیات به عنوان مثال طرح توکن‌سازی مورد استفاده برای متن، طرح نمایه‌سازی مورد استفاده برای ویژگی‌های طبقه‌بندی، چه مقادیر پیکسل تصویر آگاه باشند. به نرمال [-1, +1] و یا به [0, 1] ، و غیره این امر به ویژه قدرتمند اگر شما در حال صادرات مدل خود را به زمان اجرا دیگر، مانند TensorFlow.js: شما نمی خواهد که به reimplement پردازش خود را خط لوله در جاوا اسکریپت

اگر شما در ابتدا لایه های از پیش پردازش خود را در خود tf.data خط لوله، شما می توانید یک مدل استنتاج که بسته های پیش پردازش صادرات. به سادگی یک مدل جدید که لایه های پیش پردازش و مدل آموزشی شما را به زنجیر می کشد، معرفی کنید:

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

دستور العمل های سریع

افزایش داده های تصویری

توجه داشته باشید که لایه های تقویت داده های تصویر تنها فعال در طول آموزش (به طور مشابه به هستند Dropout لایه).

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>

شما می توانید تنظیمات مشابه در عمل در مثال بالا مشاهده طبقه بندی تصویر از ابتدا .

عادی سازی ویژگی های عددی

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

رمزگذاری ویژگی های دسته بندی رشته از طریق رمزگذاری یک طرفه

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

توجه داشته باشید که، در اینجا، شاخص 0 برای خارج از واژگان ارزش سایت متعلق به (ارزش هایی که در طول دیده نمی شد adapt() ).

شما می توانید ببینید StringLookup در عمل در طبقه بندی داده های ساخت یافته، از ابتدا به عنوان مثال.

رمزگذاری ویژگی های دسته بندی اعداد صحیح از طریق رمزگذاری یک طرفه

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

توجه داشته باشید که شاخص 0 برای از دست رفته ارزش محفوظ (که شما باید به عنوان ارزش 0 را مشخص) و شاخص 1 برای خارج از واژگان ارزش سایت متعلق به (ارزش هایی که در طول دیده نمی شد adapt() ). شما می توانید این را با استفاده از پیکربندی mask_token و oov_token آرگومان های سازنده از IntegerLookup .

شما می توانید ببینید IntegerLookup در عمل در مثال ساختار طبقه بندی داده ها، از ابتدا .

استفاده از ترفند هش کردن در یک ویژگی دسته بندی عدد صحیح

اگر یک ویژگی طبقه‌بندی دارید که می‌تواند مقادیر بسیار متفاوتی داشته باشد (در مرتبه 10e3 یا بالاتر)، که در آن هر مقدار فقط چند بار در داده‌ها ظاهر می‌شود، فهرست کردن و کدگذاری یک‌بار مقادیر ویژگی‌ها غیرعملی و بی‌اثر می‌شود. درعوض، استفاده از "ترفند هش کردن" می تواند ایده خوبی باشد: مقادیر را در یک بردار با اندازه ثابت هش کنید. این اندازه فضای ویژگی را قابل مدیریت نگه می دارد و نیاز به نمایه سازی صریح را از بین می برد.

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

رمزگذاری متن به عنوان دنباله ای از شاخص های نشانه

این است چگونه می توانید باید پیش پردازش متن به یک منتقل می شود Embedding لایه.

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

شما می توانید ببینید TextVectorization لایه در عمل، همراه با Embedding حالت، در مثال طبقه بندی متن از ابتدا .

توجه داشته باشید که در هنگام آموزش مانند مدل، برای بهترین عملکرد، شما همیشه باید استفاده TextVectorization لایه به عنوان بخشی از خط لوله ورودی.

کدگذاری متن به عنوان یک ماتریس متراکم از ngram ها با رمزگذاری چند داغ

این است چگونه می توانید باید پیش پردازش متن به یک منتقل می شود Dense لایه.

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

کدگذاری متن به عنوان یک ماتریس متراکم از ngram با وزن TF-IDF

این یک راه جایگزین پیش پردازش متن قبل از انتقال آن به یک است Dense لایه.

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

گوچاهای مهم

کار با لایه های جستجو با واژگان بسیار بزرگ

شما ممکن است خودتان با واژگان بسیار بزرگ در یک کار TextVectorization ، یک StringLookup لایه، یا یک IntegerLookup لایه. به طور معمول، واژگان بزرگتر از 500 مگابایت "بسیار بزرگ" در نظر گرفته می شود.

در چنین مواردی، برای بهترین عملکرد، شما باید با استفاده از اجتناب از adapt() . در عوض، واژگان خود را از قبل محاسبه کنید (می توانید از Apache Beam یا TF Transform برای این کار استفاده کنید) و آن را در یک فایل ذخیره کنید. سپس واژگان به لایه در زمان ساخت و ساز با عبور از filepath به عنوان بار vocabulary استدلال است.

با استفاده از لایه های جستوجو در یک غلاف TPU و یا با ParameterServerStrategy .

است یک موضوع باقیمانده که باعث عملکرد به تنزل در هنگام استفاده از وجود دارد TextVectorization ، StringLookup یا IntegerLookup لایه در حالی که آموزش در یک غلاف TPU یا بر روی چندین ماشین از طریق ParameterServerStrategy . قرار است این مشکل در TensorFlow 2.7 برطرف شود.