 TensorFlow.org এ দেখুন |  Google Colab-এ চালান |  GitHub-এ উৎস দেখুন |  নোটবুক ডাউনলোড করুন |
একটি মডেলের প্রশিক্ষণ সাধারণত কিছু পরিমাণ ফিচার প্রিপ্রসেসিং দিয়ে আসে, বিশেষ করে যখন স্ট্রাকচার্ড ডেটা নিয়ে কাজ করা হয়। TF1-এ একটি tf.estimator.Estimator প্রশিক্ষণ দেওয়ার সময়, এই বৈশিষ্ট্যটি প্রিপ্রসেসিং সাধারণত tf.feature_column API দিয়ে করা হয়। TF2-এ, এই প্রিপ্রসেসিং সরাসরি কেরাস লেয়ার দিয়ে করা যেতে পারে, যাকে বলা হয় প্রিপ্রসেসিং লেয়ার ।
এই মাইগ্রেশন গাইডে, আপনি ফিচার কলাম এবং প্রিপ্রসেসিং লেয়ার উভয় ব্যবহার করে কিছু সাধারণ ফিচার ট্রান্সফরমেশন করবেন, তারপর উভয় API-এর সাথে একটি সম্পূর্ণ মডেলকে প্রশিক্ষণ দেবেন।
প্রথমে, কয়েকটি প্রয়োজনীয় আমদানি দিয়ে শুরু করুন,
import tensorflow as tf
import tensorflow.compat.v1 as tf1
import math
এবং প্রদর্শনের জন্য একটি বৈশিষ্ট্য কলাম কল করার জন্য একটি ইউটিলিটি যোগ করুন:
def call_feature_columns(feature_columns, inputs):
# This is a convenient way to call a `feature_column` outside of an estimator
# to display its output.
feature_layer = tf1.keras.layers.DenseFeatures(feature_columns)
return feature_layer(inputs)
ইনপুট হ্যান্ডলিং
একটি অনুমানকারীর সাথে বৈশিষ্ট্য কলামগুলি ব্যবহার করতে, মডেল ইনপুটগুলি সর্বদা টেনসরগুলির একটি অভিধান হতে প্রত্যাশিত হয়:
input_dict = {
'foo': tf.constant([1]),
'bar': tf.constant([0]),
'baz': tf.constant([-1])
}
প্রতিটি বৈশিষ্ট্য কলাম উৎস ডেটাতে সূচক করার জন্য একটি কী দিয়ে তৈরি করা প্রয়োজন। সমস্ত বৈশিষ্ট্য কলামের আউটপুট অনুমানকারী মডেল দ্বারা সংযুক্ত এবং ব্যবহৃত হয়।
columns = [
tf1.feature_column.numeric_column('foo'),
tf1.feature_column.numeric_column('bar'),
tf1.feature_column.numeric_column('baz'),
]
call_feature_columns(columns, input_dict)
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[ 0., -1., 1.]], dtype=float32)>
কেরাসে, মডেল ইনপুট অনেক বেশি নমনীয়। একটি tf.keras.Model একটি একক টেনসর ইনপুট, টেনসর বৈশিষ্ট্যগুলির একটি তালিকা, বা টেনসর বৈশিষ্ট্যগুলির একটি অভিধান পরিচালনা করতে পারে। আপনি মডেল তৈরিতে tf.keras.Input এর একটি অভিধান পাস করে অভিধান ইনপুট পরিচালনা করতে পারেন। ইনপুটগুলি স্বয়ংক্রিয়ভাবে সংযুক্ত হবে না, যা তাদের আরও নমনীয় উপায়ে ব্যবহার করার অনুমতি দেয়। এগুলি tf.keras.layers.Concatenate দিয়ে সংযুক্ত করা যেতে পারে।
inputs = {
'foo': tf.keras.Input(shape=()),
'bar': tf.keras.Input(shape=()),
'baz': tf.keras.Input(shape=()),
}
# Inputs are typically transformed by preprocessing layers before concatenation.
outputs = tf.keras.layers.Concatenate()(inputs.values())
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model(input_dict)
<tf.Tensor: shape=(3,), dtype=float32, numpy=array([ 1., 0., -1.], dtype=float32)>
এক-হট এনকোডিং পূর্ণসংখ্যা আইডি
একটি সাধারণ বৈশিষ্ট্য রূপান্তর হল একটি পরিচিত পরিসরের এক-হট এনকোডিং পূর্ণসংখ্যা ইনপুট। এখানে বৈশিষ্ট্য কলাম ব্যবহার করে একটি উদাহরণ:
categorical_col = tf1.feature_column.categorical_column_with_identity(
'type', num_buckets=3)
indicator_col = tf1.feature_column.indicator_column(categorical_col)
call_feature_columns(indicator_col, {'type': [0, 1, 2]})
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]], dtype=float32)>
কেরাস প্রিপ্রসেসিং স্তরগুলি ব্যবহার করে, এই কলামগুলিকে একটি একক tf.keras.layers.CategoryEncoding স্তর দিয়ে output_mode সেট করা 'one_hot' দ্বারা প্রতিস্থাপিত করা যেতে পারে:
one_hot_layer = tf.keras.layers.CategoryEncoding(
num_tokens=3, output_mode='one_hot')
one_hot_layer([0, 1, 2])
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]], dtype=float32)>
সংখ্যাসূচক বৈশিষ্ট্য স্বাভাবিককরণ
ফিচার কলাম সহ ক্রমাগত, ফ্লোটিং-পয়েন্ট বৈশিষ্ট্যগুলি পরিচালনা করার সময়, আপনাকে একটি tf.feature_column.numeric_column ব্যবহার করতে হবে। যে ক্ষেত্রে ইনপুট ইতিমধ্যেই স্বাভাবিক করা হয়েছে, এটি কেরাসে রূপান্তর করা তুচ্ছ। আপনি সহজভাবে আপনার মডেলে একটি tf.keras.Input .ইনপুট ব্যবহার করতে পারেন, যেমন উপরে দেখানো হয়েছে।
একটি numeric_column এছাড়াও ইনপুট স্বাভাবিক করার জন্য ব্যবহার করা যেতে পারে:
def normalize(x):
mean, variance = (2.0, 1.0)
return (x - mean) / math.sqrt(variance)
numeric_col = tf1.feature_column.numeric_column('col', normalizer_fn=normalize)
call_feature_columns(numeric_col, {'col': tf.constant([[0.], [1.], [2.]])})
<tf.Tensor: shape=(3, 1), dtype=float32, numpy=
array([[-2.],
[-1.],
[ 0.]], dtype=float32)>
বিপরীতে, কেরাসের সাথে, এই স্বাভাবিককরণটি tf.keras.layers.Normalization দিয়ে করা যেতে পারে।
normalization_layer = tf.keras.layers.Normalization(mean=2.0, variance=1.0)
normalization_layer(tf.constant([[0.], [1.], [2.]]))
<tf.Tensor: shape=(3, 1), dtype=float32, numpy=
array([[-2.],
[-1.],
[ 0.]], dtype=float32)>
বাকেটাইজিং এবং ওয়ান-হট এনকোডিং সংখ্যাসূচক বৈশিষ্ট্য
একটানা, ফ্লোটিং পয়েন্ট ইনপুটগুলির আরেকটি সাধারণ রূপান্তর হল একটি নির্দিষ্ট পরিসরের পূর্ণসংখ্যাগুলিকে বাকেটাইজ করা।
বৈশিষ্ট্য কলামে, এটি একটি tf.feature_column.bucketized_column দিয়ে অর্জন করা যেতে পারে :
numeric_col = tf1.feature_column.numeric_column('col')
bucketized_col = tf1.feature_column.bucketized_column(numeric_col, [1, 4, 5])
call_feature_columns(bucketized_col, {'col': tf.constant([1., 2., 3., 4., 5.])})
<tf.Tensor: shape=(5, 4), dtype=float32, numpy=
array([[0., 1., 0., 0.],
[0., 1., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]], dtype=float32)>
কেরাসে, এটি tf.keras.layers.Discretization দ্বারা প্রতিস্থাপিত হতে পারে:
discretization_layer = tf.keras.layers.Discretization(bin_boundaries=[1, 4, 5])
one_hot_layer = tf.keras.layers.CategoryEncoding(
num_tokens=4, output_mode='one_hot')
one_hot_layer(discretization_layer([1., 2., 3., 4., 5.]))
<tf.Tensor: shape=(5, 4), dtype=float32, numpy=
array([[0., 1., 0., 0.],
[0., 1., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]], dtype=float32)>
একটি শব্দভান্ডার সহ ওয়ান-হট এনকোডিং স্ট্রিং ডেটা
স্ট্রিং বৈশিষ্ট্যগুলি পরিচালনা করার জন্য প্রায়শই সূচকগুলিতে স্ট্রিংগুলি অনুবাদ করার জন্য একটি শব্দভাণ্ডার সন্ধানের প্রয়োজন হয়। এখানে স্ট্রিংগুলি দেখার জন্য বৈশিষ্ট্য কলাম ব্যবহার করে একটি উদাহরণ দেওয়া হল এবং তারপরে সূচকগুলিকে এক-হট এনকোড করুন:
vocab_col = tf1.feature_column.categorical_column_with_vocabulary_list(
'sizes',
vocabulary_list=['small', 'medium', 'large'],
num_oov_buckets=0)
indicator_col = tf1.feature_column.indicator_column(vocab_col)
call_feature_columns(indicator_col, {'sizes': ['small', 'medium', 'large']})
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]], dtype=float32)>
কেরাস প্রিপ্রসেসিং লেয়ার ব্যবহার করে, tf.keras.layers.StringLookup লেয়ার ব্যবহার করুন output_mode সহ ' output_mode 'one_hot' এ সেট করুন :
string_lookup_layer = tf.keras.layers.StringLookup(
vocabulary=['small', 'medium', 'large'],
num_oov_indices=0,
output_mode='one_hot')
string_lookup_layer(['small', 'medium', 'large'])
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]], dtype=float32)>
একটি শব্দভান্ডার সহ স্ট্রিং ডেটা এম্বেড করা
বৃহত্তর শব্দভান্ডারের জন্য, ভাল পারফরম্যান্সের জন্য একটি এমবেডিং প্রায়ই প্রয়োজন হয়। এখানে বৈশিষ্ট্য কলাম ব্যবহার করে একটি স্ট্রিং বৈশিষ্ট্য এমবেড করার একটি উদাহরণ রয়েছে:
vocab_col = tf1.feature_column.categorical_column_with_vocabulary_list(
'col',
vocabulary_list=['small', 'medium', 'large'],
num_oov_buckets=0)
embedding_col = tf1.feature_column.embedding_column(vocab_col, 4)
call_feature_columns(embedding_col, {'col': ['small', 'medium', 'large']})
<tf.Tensor: shape=(3, 4), dtype=float32, numpy=
array([[-0.01798586, -0.2808677 , 0.27639154, 0.06081508],
[ 0.05771849, 0.02464074, 0.20080602, 0.50164527],
[-0.9208247 , -0.40816694, -0.49132794, 0.9203153 ]],
dtype=float32)>
কেরাস প্রিপ্রসেসিং স্তরগুলি ব্যবহার করে, এটি একটি tf.keras.layers.StringLookup স্তর এবং একটি tf.keras.layers.Embedding স্তরকে একত্রিত করে অর্জন করা যেতে পারে। StringLookup জন্য ডিফল্ট আউটপুট হবে পূর্ণসংখ্যা সূচক যা সরাসরি একটি এম্বেডিংয়ে খাওয়ানো যেতে পারে।
string_lookup_layer = tf.keras.layers.StringLookup(
vocabulary=['small', 'medium', 'large'], num_oov_indices=0)
embedding = tf.keras.layers.Embedding(3, 4)
embedding(string_lookup_layer(['small', 'medium', 'large']))
<tf.Tensor: shape=(3, 4), dtype=float32, numpy=
array([[ 0.04838837, -0.04014301, 0.02001903, -0.01150769],
[-0.04580117, -0.04319514, 0.03725603, -0.00572466],
[-0.0401094 , 0.00997342, 0.00111955, 0.00132702]],
dtype=float32)>
ওয়েটেড ক্যাটাগরিকাল ডেটার সারসংক্ষেপ
কিছু ক্ষেত্রে, আপনাকে শ্রেণীবদ্ধ ডেটার সাথে মোকাবিলা করতে হবে যেখানে একটি বিভাগের প্রতিটি ঘটনা একটি সম্পর্কিত ওজনের সাথে আসে। বৈশিষ্ট্য কলামে, এটি tf.feature_column.weighted_categorical_column দিয়ে পরিচালনা করা হয়। যখন একটি indicator_column এর সাথে পেয়ার করা হয়, এটি প্রতি বিভাগ প্রতি ওজনের যোগফলের প্রভাব ফেলে।
ids = tf.constant([[5, 11, 5, 17, 17]])
weights = tf.constant([[0.5, 1.5, 0.7, 1.8, 0.2]])
categorical_col = tf1.feature_column.categorical_column_with_identity(
'ids', num_buckets=20)
weighted_categorical_col = tf1.feature_column.weighted_categorical_column(
categorical_col, 'weights')
indicator_col = tf1.feature_column.indicator_column(weighted_categorical_col)
call_feature_columns(indicator_col, {'ids': ids, 'weights': weights})
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/feature_column/feature_column_v2.py:4203: sparse_merge (from tensorflow.python.ops.sparse_ops) is deprecated and will be removed in a future version.
Instructions for updating:
No similar op available at this time.
<tf.Tensor: shape=(1, 20), dtype=float32, numpy=
array([[0. , 0. , 0. , 0. , 0. , 1.2, 0. , 0. , 0. , 0. , 0. , 1.5, 0. ,
0. , 0. , 0. , 0. , 2. , 0. , 0. ]], dtype=float32)>
tf.keras.layers.CategoryEncoding , এটি output_mode='count' সহ tf.keras.layers.CategoryEncoding-এ একটি count_weights ইনপুট পাস করে করা যেতে পারে।
ids = tf.constant([[5, 11, 5, 17, 17]])
weights = tf.constant([[0.5, 1.5, 0.7, 1.8, 0.2]])
# Using sparse output is more efficient when `num_tokens` is large.
count_layer = tf.keras.layers.CategoryEncoding(
num_tokens=20, output_mode='count', sparse=True)
tf.sparse.to_dense(count_layer(ids, count_weights=weights))
<tf.Tensor: shape=(1, 20), dtype=float32, numpy=
array([[0. , 0. , 0. , 0. , 0. , 1.2, 0. , 0. , 0. , 0. , 0. , 1.5, 0. ,
0. , 0. , 0. , 0. , 2. , 0. , 0. ]], dtype=float32)>
ওয়েটেড ক্যাটাগরিকাল ডেটা এমবেড করা
আপনি বিকল্পভাবে ওজনযুক্ত শ্রেণীবদ্ধ ইনপুটগুলি এম্বেড করতে চাইতে পারেন। ফিচার কলামে, embedding_column একটি combiner আর্গুমেন্ট থাকে। যদি কোনও নমুনায় একটি বিভাগের জন্য একাধিক এন্ট্রি থাকে, তবে সেগুলি আর্গুমেন্ট সেটিং অনুসারে একত্রিত হবে (ডিফল্ট 'mean' )।
ids = tf.constant([[5, 11, 5, 17, 17]])
weights = tf.constant([[0.5, 1.5, 0.7, 1.8, 0.2]])
categorical_col = tf1.feature_column.categorical_column_with_identity(
'ids', num_buckets=20)
weighted_categorical_col = tf1.feature_column.weighted_categorical_column(
categorical_col, 'weights')
embedding_col = tf1.feature_column.embedding_column(
weighted_categorical_col, 4, combiner='mean')
call_feature_columns(embedding_col, {'ids': ids, 'weights': weights})
<tf.Tensor: shape=(1, 4), dtype=float32, numpy=
array([[ 0.02666993, 0.289671 , 0.18065728, -0.21045178]],
dtype=float32)>
কেরাসে, tf.keras.layers.Embedding-এর কোনো combiner বিকল্প নেই, কিন্তু আপনি tf.keras.layers.Embedding এর মাধ্যমে একই প্রভাব tf.keras.layers.Dense করতে পারেন। উপরের এমবেডিং_কলামটি ক্যাটাগরির ওজন অনুসারে embedding_column ভেক্টরকে রৈখিকভাবে একত্রিত করছে। প্রথমে স্পষ্ট না হলেও, এটি আপনার শ্রেণীবদ্ধ ইনপুটগুলিকে আকারের একটি স্পার্স ওজন ভেক্টর (num_tokens) হিসাবে উপস্থাপন করার এবং আকৃতির একটি Dense কার্নেল (embedding_size, num_tokens) দ্বারা মিটিপ্লাই করার সমান।
ids = tf.constant([[5, 11, 5, 17, 17]])
weights = tf.constant([[0.5, 1.5, 0.7, 1.8, 0.2]])
# For `combiner='mean'`, normalize your weights to sum to 1. Removing this line
# would be eqivalent to an `embedding_column` with `combiner='sum'`.
weights = weights / tf.reduce_sum(weights, axis=-1, keepdims=True)
count_layer = tf.keras.layers.CategoryEncoding(
num_tokens=20, output_mode='count', sparse=True)
embedding_layer = tf.keras.layers.Dense(4, use_bias=False)
embedding_layer(count_layer(ids, count_weights=weights))
<tf.Tensor: shape=(1, 4), dtype=float32, numpy=
array([[-0.03897291, -0.27131438, 0.09332469, 0.04333957]],
dtype=float32)>
সম্পূর্ণ প্রশিক্ষণের উদাহরণ
একটি সম্পূর্ণ প্রশিক্ষণ কর্মপ্রবাহ দেখানোর জন্য, প্রথমে বিভিন্ন ধরণের তিনটি বৈশিষ্ট্য সহ কিছু ডেটা প্রস্তুত করুন:
features = {
'type': [0, 1, 1],
'size': ['small', 'small', 'medium'],
'weight': [2.7, 1.8, 1.6],
}
labels = [1, 1, 0]
predict_features = {'type': [0], 'size': ['foo'], 'weight': [-0.7]}
TF1 এবং TF2 উভয় কর্মপ্রবাহের জন্য কিছু সাধারণ ধ্রুবক সংজ্ঞায়িত করুন:
vocab = ['small', 'medium', 'large']
one_hot_dims = 3
embedding_dims = 4
weight_mean = 2.0
weight_variance = 1.0
বৈশিষ্ট্য কলাম সঙ্গে
ফিচার কলামগুলি অবশ্যই একটি তালিকা হিসাবে তৈরির অনুমানকারীর কাছে প্রেরণ করতে হবে এবং প্রশিক্ষণের সময় অন্তর্নিহিতভাবে ডাকা হবে৷
categorical_col = tf1.feature_column.categorical_column_with_identity(
'type', num_buckets=one_hot_dims)
# Convert index to one-hot; e.g. [2] -> [0,0,1].
indicator_col = tf1.feature_column.indicator_column(categorical_col)
# Convert strings to indices; e.g. ['small'] -> [1].
vocab_col = tf1.feature_column.categorical_column_with_vocabulary_list(
'size', vocabulary_list=vocab, num_oov_buckets=1)
# Embed the indices.
embedding_col = tf1.feature_column.embedding_column(vocab_col, embedding_dims)
normalizer_fn = lambda x: (x - weight_mean) / math.sqrt(weight_variance)
# Normalize the numeric inputs; e.g. [2.0] -> [0.0].
numeric_col = tf1.feature_column.numeric_column(
'weight', normalizer_fn=normalizer_fn)
estimator = tf1.estimator.DNNClassifier(
feature_columns=[indicator_col, embedding_col, numeric_col],
hidden_units=[1])
def _input_fn():
return tf1.data.Dataset.from_tensor_slices((features, labels)).batch(1)
estimator.train(_input_fn)
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp8lwbuor2
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp8lwbuor2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
rewrite_options {
meta_optimizer_iterations: ONE
}
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/adagrad.py:77: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp8lwbuor2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 0.54634213, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 3...
INFO:tensorflow:Saving checkpoints for 3 into /tmp/tmp8lwbuor2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 3...
INFO:tensorflow:Loss for final step: 0.7308526.
<tensorflow_estimator.python.estimator.canned.dnn.DNNClassifier at 0x7f90685d53d0>
মডেলে অনুমান চালানোর সময় বৈশিষ্ট্য কলামগুলি ইনপুট ডেটা রূপান্তর করতেও ব্যবহার করা হবে।
def _predict_fn():
return tf1.data.Dataset.from_tensor_slices(predict_features).batch(1)
next(estimator.predict(_predict_fn))
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp8lwbuor2/model.ckpt-3
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
{'logits': array([0.5172372], dtype=float32),
'logistic': array([0.6265015], dtype=float32),
'probabilities': array([0.37349847, 0.6265015 ], dtype=float32),
'class_ids': array([1]),
'classes': array([b'1'], dtype=object),
'all_class_ids': array([0, 1], dtype=int32),
'all_classes': array([b'0', b'1'], dtype=object)}
কেরাস প্রিপ্রসেসিং লেয়ার সহ
কেরাস প্রিপ্রসেসিং স্তরগুলি যেখানে বলা যেতে পারে সেখানে আরও নমনীয়। একটি স্তর সরাসরি টেনসরগুলিতে প্রয়োগ করা যেতে পারে, একটি tf.data ইনপুট পাইপলাইনের ভিতরে ব্যবহার করা যেতে পারে, বা সরাসরি একটি প্রশিক্ষণযোগ্য কেরাস মডেলে তৈরি করা যেতে পারে।
এই উদাহরণে, আপনি একটি tf.data ইনপুট পাইপলাইনের ভিতরে প্রিপ্রসেসিং স্তরগুলি প্রয়োগ করবেন। এটি করার জন্য, আপনি আপনার ইনপুট বৈশিষ্ট্যগুলিকে প্রিপ্রসেস করার জন্য একটি পৃথক tf.keras.Model সংজ্ঞায়িত করতে পারেন। এই মডেলটি প্রশিক্ষিত নয়, তবে প্রিপ্রসেসিং স্তরগুলিকে গোষ্ঠীভুক্ত করার একটি সুবিধাজনক উপায়।
inputs = {
'type': tf.keras.Input(shape=(), dtype='int64'),
'size': tf.keras.Input(shape=(), dtype='string'),
'weight': tf.keras.Input(shape=(), dtype='float32'),
}
# Convert index to one-hot; e.g. [2] -> [0,0,1].
type_output = tf.keras.layers.CategoryEncoding(
one_hot_dims, output_mode='one_hot')(inputs['type'])
# Convert size strings to indices; e.g. ['small'] -> [1].
size_output = tf.keras.layers.StringLookup(vocabulary=vocab)(inputs['size'])
# Normalize the numeric inputs; e.g. [2.0] -> [0.0].
weight_output = tf.keras.layers.Normalization(
axis=None, mean=weight_mean, variance=weight_variance)(inputs['weight'])
outputs = {
'type': type_output,
'size': size_output,
'weight': weight_output,
}
preprocessing_model = tf.keras.Model(inputs, outputs)
আপনি এখন tf.data.Dataset.map এ একটি কলের মধ্যে এই মডেলটি প্রয়োগ করতে পারেন। অনুগ্রহ করে মনে রাখবেন যে map পাস করা ফাংশনটি স্বয়ংক্রিয়ভাবে একটি tf.function এ রূপান্তরিত হবে এবং tf.function কোড লেখার জন্য সাধারণ সতর্কতা প্রযোজ্য হবে (কোন পার্শ্ব প্রতিক্রিয়া নেই)।
# Apply the preprocessing in tf.data.Dataset.map.
dataset = tf.data.Dataset.from_tensor_slices((features, labels)).batch(1)
dataset = dataset.map(lambda x, y: (preprocessing_model(x), y),
num_parallel_calls=tf.data.AUTOTUNE)
# Display a preprocessed input sample.
next(dataset.take(1).as_numpy_iterator())
({'type': array([[1., 0., 0.]], dtype=float32),
'size': array([1]),
'weight': array([0.70000005], dtype=float32)},
array([1], dtype=int32))
এর পরে, আপনি প্রশিক্ষিত স্তর সমন্বিত একটি পৃথক Model সংজ্ঞায়িত করতে পারেন। নোট করুন কিভাবে এই মডেলের ইনপুটগুলি এখন প্রি-প্রসেসড বৈশিষ্ট্যের ধরন এবং আকারগুলি প্রতিফলিত করে।
inputs = {
'type': tf.keras.Input(shape=(one_hot_dims,), dtype='float32'),
'size': tf.keras.Input(shape=(), dtype='int64'),
'weight': tf.keras.Input(shape=(), dtype='float32'),
}
# Since the embedding is trainable, it needs to be part of the training model.
embedding = tf.keras.layers.Embedding(len(vocab), embedding_dims)
outputs = tf.keras.layers.Concatenate()([
inputs['type'],
embedding(inputs['size']),
tf.expand_dims(inputs['weight'], -1),
])
outputs = tf.keras.layers.Dense(1)(outputs)
training_model = tf.keras.Model(inputs, outputs)
আপনি এখন tf.keras.Model.fit এর সাথে tf.keras.Model.fit training_model দিতে পারেন।
# Train on the preprocessed data.
training_model.compile(
loss=tf.keras.losses.BinaryCrossentropy(from_logits=True))
training_model.fit(dataset)
3/3 [==============================] - 0s 3ms/step - loss: 0.7248 <keras.callbacks.History at 0x7f9041a294d0>
অবশেষে, অনুমানের সময়ে, এই পৃথক পর্যায়গুলিকে একটি একক মডেলে একত্রিত করা কার্যকর হতে পারে যা কাঁচা বৈশিষ্ট্য ইনপুটগুলি পরিচালনা করে।
inputs = preprocessing_model.input
outpus = training_model(preprocessing_model(inputs))
inference_model = tf.keras.Model(inputs, outpus)
predict_dataset = tf.data.Dataset.from_tensor_slices(predict_features).batch(1)
inference_model.predict(predict_dataset)
array([[0.936637]], dtype=float32)
এই রচিত মডেলটি পরবর্তীতে ব্যবহারের জন্য সংরক্ষিত মডেল হিসাবে সংরক্ষণ করা যেতে পারে।
inference_model.save('model')
restored_model = tf.keras.models.load_model('model')
restored_model.predict(predict_dataset)
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model. 2021-10-27 01:23:25.649967: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them. INFO:tensorflow:Assets written to: model/assets WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually. array([[0.936637]], dtype=float32)
বৈশিষ্ট্য কলাম সমতুল্য টেবিল
রেফারেন্সের জন্য, এখানে বৈশিষ্ট্য কলাম এবং প্রিপ্রসেসিং স্তরগুলির মধ্যে একটি আনুমানিক চিঠিপত্র রয়েছে:
* output_mode layers.CategoryEncoding করা যেতে পারে। ক্যাটাগরি এনকোডিং, লেয়ার। layers.IntegerLookup , লেয়ার। ইন্টিজার লুকআপ এবং layers.TextVectorization layers.StringLookup
† স্তর। layers.TextVectorization সরাসরি ফ্রিফর্ম টেক্সট ইনপুট পরিচালনা করতে পারে (যেমন সম্পূর্ণ বাক্য বা অনুচ্ছেদ)। এটি TF1-এ শ্রেণীবদ্ধ ক্রম পরিচালনার জন্য এক থেকে এক প্রতিস্থাপন নয়, তবে অ্যাড-হক পাঠ্য প্রিপ্রসেসিংয়ের জন্য একটি সুবিধাজনক প্রতিস্থাপনের প্রস্তাব দিতে পারে।
পরবর্তী পদক্ষেপ
- কেরাস প্রিপ্রসেসিং লেয়ার সম্পর্কে আরও তথ্যের জন্য, প্রিপ্রসেসিং লেয়ারের গাইড দেখুন।
- স্ট্রাকচার্ড ডেটাতে প্রিপ্রসেসিং লেয়ার প্রয়োগ করার আরও গভীর উদাহরণের জন্য, স্ট্রাকচার্ড ডেটা টিউটোরিয়াল দেখুন।