 TensorFlow.org'da görüntüleyin |  Google Colab'da çalıştırın |  Kaynağı GitHub'da görüntüleyin |  Not defterini indir |
Bir modeli eğitmek, özellikle yapılandırılmış verilerle uğraşırken, genellikle bir miktar özellik ön işleme ile birlikte gelir. TF1'de bir tf.estimator.Estimator , bu özellik ön işlemesi genellikle tf.feature_column API ile yapılır. TF2'de bu ön işleme, doğrudan ön işleme katmanları adı verilen Keras katmanlarıyla yapılabilir.
Bu geçiş kılavuzunda, hem özellik sütunlarını hem de ön işleme katmanlarını kullanarak bazı ortak özellik dönüşümlerini gerçekleştirecek ve ardından her iki API ile de eksiksiz bir modeli eğiteceksiniz.
İlk olarak, birkaç gerekli ithalatla başlayın,
import tensorflow as tf
import tensorflow.compat.v1 as tf1
import math
ve gösteri için bir özellik sütunu çağırmak için bir yardımcı program ekleyin:
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)
giriş işleme
Bir tahmin edici ile özellik sütunlarını kullanmak için, model girdilerinin her zaman bir tensör sözlüğü olması beklenir:
input_dict = {
'foo': tf.constant([1]),
'bar': tf.constant([0]),
'baz': tf.constant([-1])
}
Her özellik sütununun, kaynak verilere endekslenmesi için bir anahtarla oluşturulması gerekir. Tüm özellik sütunlarının çıktısı birleştirilir ve tahmin edici model tarafından kullanılır.
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)>
Keras'ta model girişi çok daha esnektir. Bir tf.keras.Model , tek bir tensör girdisini, bir tensör özellikleri listesini veya bir tensör özellikleri sözlüğünü işleyebilir. Model oluşturmada bir tf.keras.Input sözlüğünü ileterek sözlük girdisini işleyebilirsiniz. Girdiler otomatik olarak birleştirilmeyecek, bu da onların çok daha esnek şekillerde kullanılmasına izin veriyor. tf.keras.layers.Concatenate ile birleştirilebilirler.
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)>
Tek sıcak kodlama tamsayı kimlikleri
Ortak bir özellik dönüşümü, bilinen bir aralığın tek sıcak kodlama tamsayı girdileridir. Özellik sütunlarını kullanan bir örnek:
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)>
Keras ön işleme katmanları kullanılarak bu sütunlar, output_mode 'one_hot' olarak ayarlanmış tek bir tf.keras.layers.CategoryEncoding katmanıyla değiştirilebilir:
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)>
Sayısal özellikleri normalleştirme
Özellik sütunlarıyla sürekli, kayan nokta özelliklerini işlerken, bir tf.feature_column.numeric_column kullanmanız gerekir. Girişin zaten normalleştirilmiş olması durumunda, bunu Keras'a dönüştürmek önemsizdir. Yukarıda gösterildiği gibi, doğrudan modelinize bir tf.keras.Input kullanabilirsiniz.
Girişi normalleştirmek için bir numeric_column da kullanılabilir:
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)>
Buna karşılık, Keras ile bu normalleştirme tf.keras.layers.Normalization ile yapılabilir.
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)>
Paketleme ve one-hot kodlama sayısal özellikleri
Sürekli, kayan noktalı girdilerin başka bir yaygın dönüşümü, daha sonra sabit bir aralıktaki tam sayılara gruplandırmaktır.
Özellik sütunlarında bu, bir tf.feature_column.bucketized_column ile başarılabilir:
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)>
Keras'ta bu, tf.keras.layers.Discretization ile değiştirilebilir:
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)>
Bir kelime ile tek sıcak kodlama dizisi verileri
Dize özelliklerini işlemek, genellikle dizeleri dizinlere çevirmek için bir kelime araması gerektirir. Dizeleri aramak için özellik sütunlarını kullanan bir örnek ve ardından endeksleri tek seferde kodlamak:
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)>
Keras ön işleme katmanlarını kullanarak, output_mode 'one_hot' olarak ayarlanmış tf.keras.layers.StringLookup katmanını kullanın:
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)>
Dize verilerini bir sözlükle gömme
Daha büyük sözlükler için, iyi performans için genellikle bir yerleştirme gerekir. Özellik sütunlarını kullanarak bir dize özelliğini gömme örneği:
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)>
Keras ön işleme katmanları kullanılarak bu, bir tf.keras.layers.StringLookup katmanı ve bir tf.keras.layers.Embedding katmanı birleştirilerek elde edilebilir. StringLookup için varsayılan çıktı, doğrudan bir gömmeye beslenebilen tamsayı endeksleri olacaktır.
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)>
Ağırlıklı kategorik verileri toplama
Bazı durumlarda, bir kategorinin her oluşumunun ilişkili bir ağırlıkla geldiği kategorik verilerle uğraşmanız gerekir. Özellik sütunlarında bu, tf.feature_column.weighted_categorical_column ile işlenir. Bir indicator_column eşleştirildiğinde, bu, kategori başına ağırlıkları toplama etkisine sahiptir.
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)>
Keras'ta bu, tf.keras.layers.CategoryEncoding öğesine bir count_weights girdisi ile tf.keras.layers.CategoryEncoding output_mode='count' yapılabilir.
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)>
Ağırlıklı kategorik verileri gömme
Alternatif olarak ağırlıklı kategorik girdileri gömmek isteyebilirsiniz. Özellik sütunlarında, embedding_column bir combiner bağımsız değişkeni içerir. Herhangi bir örnek bir kategori için birden fazla girdi içeriyorsa, bunlar bağımsız değişken ayarına göre birleştirilir (varsayılan olarak '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 için combiner seçeneği yoktur, ancak aynı efekti tf.keras.layers.Dense ile elde edebilirsiniz. Yukarıdaki embedding_column , gömme vektörlerini kategori ağırlığına göre doğrusal olarak birleştirir. İlk başta açık olmasa da, kategorik girdilerinizi seyrek ağırlık vektörü (num_tokens) olarak temsil etmeye ve bunları bir Dense şekil çekirdeği (embedding_size, num_tokens) ile değiştirmeye tam olarak eşdeğerdir.
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)>
Tam eğitim örneği
Eksiksiz bir eğitim iş akışını göstermek için, önce farklı türden üç özelliğe sahip bazı veriler hazırlayın:
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]}
Hem TF1 hem de TF2 iş akışları için bazı ortak sabitler tanımlayın:
vocab = ['small', 'medium', 'large']
one_hot_dims = 3
embedding_dims = 4
weight_mean = 2.0
weight_variance = 1.0
Özellik sütunları ile
Özellik sütunları, oluşturma sırasında tahminciye bir liste olarak iletilmelidir ve eğitim sırasında dolaylı olarak çağrılacaktır.
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>
Özellik sütunları, model üzerinde çıkarım çalıştırılırken girdi verilerini dönüştürmek için de kullanılacaktır.
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)}
Keras ön işleme katmanları ile
Keras ön işleme katmanları, çağrılabilecekleri yerlerde daha esnektir. Bir katman doğrudan tensörlere uygulanabilir, bir tf.data giriş hattı içinde kullanılabilir veya doğrudan eğitilebilir bir Keras modeline yerleştirilebilir.
Bu örnekte, bir tf.data giriş hattı içinde ön işleme katmanları uygulayacaksınız. Bunu yapmak için, giriş özelliklerinizi önceden işlemek için ayrı bir tf.keras.Model tanımlayabilirsiniz. Bu model eğitilebilir değildir, ancak ön işleme katmanlarını gruplamanın uygun bir yoludur.
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)
Artık bu modeli tf.data.Dataset.map çağrısına uygulayabilirsiniz. Lütfen map iletilen işlevin otomatik olarak bir tf.function dönüştürüleceğini ve tf.function kodunun yazılması için olağan uyarıların geçerli olduğunu (yan etki yok) unutmayın.
# 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))
Ardından, eğitilebilir katmanları içeren ayrı bir Model tanımlayabilirsiniz. Bu modele ilişkin girdilerin artık önceden işlenmiş unsur türlerini ve şekillerini nasıl yansıttığını not edin.
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)
Artık training_model tf.keras.Model.fit ile eğitebilirsiniz.
# 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>
Son olarak, çıkarım zamanında, bu ayrı aşamaları ham özellik girdilerini işleyen tek bir modelde birleştirmek faydalı olabilir.
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)
Oluşturulan bu model daha sonra kullanılmak üzere SavedModel olarak kaydedilebilir.
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)
Özellik sütunu denklik tablosu
Başvuru için, özellik sütunları ve ön işleme katmanları arasındaki yaklaşık bir yazışma aşağıda verilmiştir:
* output_mode , layers.CategoryEncoding , layers.StringLookup , layers.IntegerLookup ve layers.TextVectorization .
† layers.TextVectorization , serbest biçimli metin girişini doğrudan işleyebilir (örneğin, tüm cümleler veya paragraflar). Bu, TF1'deki kategorik dizi işleme için bire bir değiştirme değildir, ancak geçici metin ön işleme için uygun bir ikame sunabilir.
Sonraki adımlar
- Keras ön işleme katmanları hakkında daha fazla bilgi için, katmanları ön işleme kılavuzuna bakın.
- Yapılandırılmış verilere ön işleme katmanlarının uygulanmasına ilişkin daha ayrıntılı bir örnek için yapılandırılmış veri öğreticisine bakın.