इस पेज का अनुवाद Cloud Translation API से किया गया है.

प्रीप्रोसेसिंग परतों के साथ काम करना

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

केरस प्रीप्रोसेसिंग

केरस प्रीप्रोसेसिंग लेयर्स एपीआई डेवलपर्स को केरस-देशी इनपुट प्रोसेसिंग पाइपलाइन बनाने की अनुमति देता है। इन इनपुट प्रोसेसिंग पाइपलाइनों का उपयोग गैर-केरस वर्कफ़्लोज़ में स्वतंत्र प्रीप्रोसेसिंग कोड के रूप में किया जा सकता है, जो सीधे केरस मॉडल के साथ संयुक्त होता है, और केरस सेव्डमॉडल के हिस्से के रूप में निर्यात किया जाता है।

केरस प्रीप्रोसेसिंग परतों के साथ, आप ऐसे मॉडल बना और निर्यात कर सकते हैं जो वास्तव में एंड-टू-एंड हैं: ऐसे मॉडल जो कच्ची छवियों या कच्चे संरचित डेटा को इनपुट के रूप में स्वीकार करते हैं; ऐसे मॉडल जो फीचर नॉर्मलाइजेशन या फीचर वैल्यू इंडेक्सिंग को अपने दम पर हैंडल करते हैं।

उपलब्ध प्रीप्रोसेसिंग

टेक्स्ट प्रीप्रोसेसिंग

tf.keras.layers.TextVectorization : एक एन्कोड प्रतिनिधित्व है कि एक द्वारा पढ़ा जा सकता में कच्चे तार बदल जाता है Embedding परत या Dense परत।

संख्यात्मक विशेषताएं प्रीप्रोसेसिंग

tf.keras.layers.Normalization : प्रदर्शन की सुविधा के लिहाज से इनपुट सुविधाओं के सामान्य।
tf.keras.layers.Discretization : स्पष्ट सुविधाओं पूर्णांक में निरंतर संख्यात्मक सुविधाओं बदल जाता है।

स्पष्ट विशेषताएं प्रीप्रोसेसिंग

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 : मूल्य बाल्टी सीमाओं के बारे में जानकारी रखती है।

महत्वपूर्ण बात, इन परतों गैर trainable रहे हैं। उनका राज्य प्रशिक्षण के दौरान निर्धारित नहीं है; यह निर्धारित किया जाना चाहिए प्रशिक्षण से पहले, या तो उन्हें एक precomputed निरंतर से आरंभ, अथवा डेटा पर "अनुकूल" उन्हें।

आप प्रशिक्षण डेटा के संपर्क में लाने से एक preprocessing परत की स्थिति निर्धारित करते हैं, के माध्यम से 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() विधि या तो एक Numpy सरणी या एक लेता है 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 परतों पहले से ही मौजूद है, उन सीधे देखने तालिका में परत के निर्माता तर्क में शब्दावली फाइल करने के लिए एक रास्ता पारित करके लोड किया जा सकता।

यहाँ एक उदाहरण है, जहां हम एक दृष्टांत है StringLookup precomputed शब्दावली के साथ परत:

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 परत, और सभी छवि preprocessing और डेटा वृद्धि परतों के लिए।

विकल्प 2: अपने पर लागू tf.data.Dataset एक डाटासेट प्राप्त करने के लिए इतनी के रूप में, कि preprocessed डेटा, इस तरह की पैदावार बैचों:

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

इस विकल्प के साथ, आपका प्रीप्रोसेसिंग सीपीयू पर अतुल्यकालिक रूप से होगा, और मॉडल में जाने से पहले बफ़र किया जाएगा। इसके अलावा, यदि आप कॉल 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 , और सभी संरचित डेटा परतों preprocessing। यह एक अच्छा विकल्प भी हो सकता है यदि आप सीपीयू पर प्रशिक्षण ले रहे हैं और आप छवि प्रीप्रोसेसिंग परतों का उपयोग करते हैं।

जब TPU पर चल रहा है, तो आप हमेशा में परतों preprocessing रखूं tf.data पाइपलाइन (के अपवाद के साथ Normalization और Rescaling , जो TPU पर ठीक चलाने के लिए और आम तौर पर पहली परत एक छवि मॉडल है उपयोग किया जाता है)।

अनुमान के समय मॉडल के अंदर प्रीप्रोसेसिंग करने के लाभ

यहां तक कि अगर आप विकल्प 2 के साथ जाते हैं, तो आप बाद में एक अनुमान-केवल एंड-टू-एंड मॉडल निर्यात करना चाह सकते हैं जिसमें प्रीप्रोसेसिंग परतें शामिल होंगी। ऐसा करने के लिए महत्वपूर्ण लाभ यह है कि यह अपने मॉडल पोर्टेबल बनाता है और इसे कम करने में मदद करता है तिरछा सेवारत / प्रशिक्षण ।

जब सभी डेटा प्रीप्रोसेसिंग मॉडल का हिस्सा होता है, तो अन्य लोग इस बात से अवगत हुए बिना आपके मॉडल को लोड और उपयोग कर सकते हैं कि प्रत्येक सुविधा के एन्कोडेड और सामान्यीकृत होने की उम्मीद कैसे की जाती है। आपका अनुमान मॉडल कच्ची छवियों या कच्चे संरचित डेटा को संसाधित करने में सक्षम होगा, और मॉडल के उपयोगकर्ताओं को विवरण के बारे में जागरूक होने की आवश्यकता नहीं होगी जैसे पाठ के लिए उपयोग की जाने वाली टोकन योजना, श्रेणीबद्ध सुविधाओं के लिए उपयोग की जाने वाली अनुक्रमण योजना, चाहे छवि पिक्सेल मान करने के लिए सामान्यीकृत कर रहे हैं [-1, +1] या करने के लिए [0, 1] , आदि यह विशेष रूप से शक्तिशाली है अगर आप इस तरह के TensorFlow.js के रूप में, एक और क्रम में अपने मॉडल को निर्यात कर रहे हैं: यदि आप अपने पूर्व प्रसंस्करण reimplement नहीं होगा जावास्क्रिप्ट में पाइपलाइन।

आरंभ में आप अपने में अपने preprocessing परतों डाल दिया 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)

टोकन इंडेक्स के अनुक्रम के रूप में एन्कोडिंग टेक्स्ट

यह आप कैसे preprocess चाहिए पाठ एक को पास करने की है 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 परत इनपुट पाइपलाइन के हिस्से के रूप।

बहु-गर्म एन्कोडिंग के साथ एनग्राम के घने मैट्रिक्स के रूप में एन्कोडिंग पाठ

यह आप कैसे preprocess चाहिए पाठ एक को पास करने की है 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)

TF-IDF भारोत्तोलन के साथ ngrams के घने मैट्रिक्स के रूप में एन्कोडिंग पाठ

यह यह एक करने के लिए पारित करने से पहले पाठ preprocessing का एक वैकल्पिक तरीका है 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 परत। आमतौर पर, 500MB से बड़ी शब्दावली को "बहुत बड़ा" माना जाएगा।

ऐसे मामले में, सर्वश्रेष्ठ प्रदर्शन के लिए, आप का उपयोग कर से बचना चाहिए adapt() । इसके बजाय, अपनी शब्दावली की अग्रिम रूप से गणना करें (आप इसके लिए Apache Beam या TF Transform का उपयोग कर सकते हैं) और इसे एक फ़ाइल में संग्रहीत करें। तब के रूप में filepath पास करके निर्माण समय में परत में शब्दावली लोड vocabulary तर्क।

एक TPU फली पर या के साथ देखने परतों का उपयोग `ParameterServerStrategy` ।

वहाँ एक उत्कृष्ट मुद्दा यह है कि नीचा दिखाने के लिए प्रदर्शन का कारण बनता है जब एक का उपयोग कर रहा है TextVectorization , StringLookup , या IntegerLookup परत, जबकि एक TPU फली पर या के माध्यम से कई मशीनों पर प्रशिक्षण ParameterServerStrategy । इसे TensorFlow 2.7 में ठीक किया जाना है।

प्रीप्रोसेसिंग परतों के साथ काम करना

केरस प्रीप्रोसेसिंग

उपलब्ध प्रीप्रोसेसिंग

टेक्स्ट प्रीप्रोसेसिंग

संख्यात्मक विशेषताएं प्रीप्रोसेसिंग

स्पष्ट विशेषताएं प्रीप्रोसेसिंग

छवि प्रीप्रोसेसिंग

छवि डेटा वृद्धि

adapt() विधि

मॉडल से पहले या मॉडल के अंदर प्रीप्रोसेसिंग डेटा

अनुमान के समय मॉडल के अंदर प्रीप्रोसेसिंग करने के लाभ

त्वरित व्यंजन

छवि डेटा वृद्धि

संख्यात्मक विशेषताओं का सामान्यीकरण

एक-हॉट एन्कोडिंग के माध्यम से एन्कोडिंग स्ट्रिंग श्रेणीबद्ध विशेषताएं

एक-हॉट एन्कोडिंग के माध्यम से पूर्णांक श्रेणीबद्ध सुविधाओं को एन्कोड करना

हैशिंग ट्रिक को एक पूर्णांक श्रेणीबद्ध विशेषता पर लागू करना

टोकन इंडेक्स के अनुक्रम के रूप में एन्कोडिंग टेक्स्ट

बहु-गर्म एन्कोडिंग के साथ एनग्राम के घने मैट्रिक्स के रूप में एन्कोडिंग पाठ

TF-IDF भारोत्तोलन के साथ ngrams के घने मैट्रिक्स के रूप में एन्कोडिंग पाठ

महत्वपूर्ण गठिया

बहुत बड़ी शब्दावली के साथ लुकअप परतों के साथ कार्य करना

एक TPU फली पर या के साथ देखने परतों का उपयोग ParameterServerStrategy ।

`adapt()` विधि

एक TPU फली पर या के साथ देखने परतों का उपयोग `ParameterServerStrategy` ।