সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

প্রিপ্রোসেসিং স্তরগুলির সাথে কাজ করা

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 : STRING টোকেন এবং পূর্ণসংখ্যা সূচকের মধ্যে একটি ম্যাপিং ঝুলিতে
  • StringLookup এবং IntegerLookup : ইনপুট মান এবং পূর্ণসংখ্যা সূচকের মধ্যে একটি ম্যাপিং ধরে রাখুন।
  • Normalization : বৈশিষ্ট্য গড় এবং মানক চ্যুতির ঝুলিতে।
  • Discretization : VALUE বালতি গণ্ডি সম্পর্কে তথ্য ঝুলিতে।

গভীরভাবে, এই তিনটি স্তরের অ 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 স্তর ইতিমধ্যে বিদ্যমান, সেই সরাসরি লুকআপ টেবিলের মধ্যে লেয়ারটির কনস্ট্রাকটর আর্গুমেন্ট মধ্যে শব্দভান্ডার ফাইলের পাথ ক্ষণস্থায়ী দ্বারা লোড করা যাবে।

এখানে একটি উদাহরণ যেখানে আমরা একটি instantiate এর 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 ত্বরণ থেকে উপকৃত হবে। আপনি যদি জিপিইউ আছি প্রশিক্ষণ, এই জন্য সবচেয়ে ভাল বিকল্প Normalization স্তর, এবং সমস্ত ইমেজ প্রাক-প্রক্রিয়াকরণ ও ডেটা বৃদ্ধি স্তরগুলির জন্য।

অপশন 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। আপনি যদি CPU-তে প্রশিক্ষণ নিচ্ছেন এবং আপনি ইমেজ প্রিপ্রসেসিং স্তরগুলি ব্যবহার করেন তবে এটি একটি ভাল বিকল্প হতে পারে।

যখন নমনীয় চালু রাখার জন্য, আপনি সবসময় মধ্যে স্তর preprocessing স্থান উচিত tf.data পাইপলাইন (ব্যতিক্রম Normalization এবং Rescaling , যা নমনীয় উপর জরিমানা চালানো এবং সাধারণত হিসাবে প্রথম স্তর একটি চিত্র মডেল ব্যবহার করা হয়)।

অনুমান সময়ে মডেলের ভিতরে প্রিপ্রসেসিং করার সুবিধা

এমনকি যদি আপনি বিকল্প 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 ওজন সহ এনগ্রামের ঘন ম্যাট্রিক্স হিসাবে পাঠ্য এনকোডিং

এটি একটি ক্ষণস্থায়ী আগে টেক্সট 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 যুক্তি।

একটি নমনীয় শুঁটি বা সঙ্গে লুকআপ স্তর ব্যবহার ParameterServerStrategy

সেখানে একটি অসামান্য সমস্যাটি হল এই যে জমিতে কর্মক্ষমতা ঘটায় যখন একটি ব্যবহার করছে TextVectorization , StringLookup , অথবা IntegerLookup স্তর যখন একটি নমনীয় শুঁটি বা মাধ্যমে একাধিক মেশিনে প্রশিক্ষণ ParameterServerStrategy । এটি TensorFlow 2.7 এ ঠিক করা হবে।