Google I/O bir tamamlamadır! TensorFlow oturumlarını takip edin Oturumları görüntüleyin

feature_columns'u TF2'nin Keras Ön İşleme Katmanlarına Taşıma

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)
tutucu4 l10n-yer
<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)
tutucu6 l10n-yer
<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]})
tutucu8 l10n-yer
<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])
tutucu10 l10n-yer
<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.]])})
tutucu12 l10n-yer
<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.]]))
tutucu14 l10n-yer
<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.])})
tutucu16 l10n-yer
<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.]))
tutucu18 l10n-yer
<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']})
tutucu20 l10n-yer
<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'])
tutucu22 l10n-yer
<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']})
tutucu24 l10n-yer
<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']))
tutucu26 l10n-yer
<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})
tutucu28 l10n-yer
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))
tutucu30 l10n-yer
<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})
tutucu32 l10n-yer
<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))
tutucu34 l10n-yer
<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)
tutucu38 l10n-yer
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))
tutucu40 l10n-yer
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())
tutucu43 l10n-yer
({'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)
tutucu46 l10n-yer
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)
tutucu48 l10n-yer
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)
tutucu50 l10n-yer
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:

Özellik Sütunu Keras Katmanı
feature_column.bucketized_column layers.Discretization
feature_column.categorical_column_with_hash_bucket layers.Hashing
feature_column.categorical_column_with_identity layers.CategoryEncoding
feature_column.categorical_column_with_vocabulary_file layers.StringLookup veya layers.IntegerLookup
feature_column.categorical_column_with_vocabulary_list layers.StringLookup veya layers.IntegerLookup
feature_column.crossed_column Uygulanmadı.
feature_column.embedding_column layers.Embedding
feature_column.indicator_column output_mode='one_hot' veya output_mode='multi_hot' *
feature_column.numeric_column layers.Normalization
feature_column.sequence_categorical_column_with_hash_bucket layers.Hashing
feature_column.sequence_categorical_column_with_identity layers.CategoryEncoding
feature_column.sequence_categorical_column_with_vocabulary_file layers.StringLookup , layers.IntegerLookup veya layer.TextVectorization
feature_column.sequence_categorical_column_with_vocabulary_list layers.StringLookup , layers.IntegerLookup veya layer.TextVectorization
feature_column.sequence_numeric_column layers.Normalization
feature_column.weighted_categorical_column layers.CategoryEncoding

* 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