Yardım Kaggle üzerinde TensorFlow ile Büyük Bariyer Resifi korumak Meydan Üyelik

TensorFlow Transform'u Kullanmaya Başlayın

Bu kılavuz, tf.Transform temel kavramlarını ve tf.Transform nasıl kullanılacağını açıklamaktadır. Olacak:

  • Ham verileri bir makine öğrenimi modelini eğitmek için kullanılan verilere dönüştüren boru hattının mantıksal bir açıklaması olan bir ön işleme işlevi tanımlayın.
  • Ön işleme işlevini bir Beam ardışık düzenine dönüştürerek verileri dönüştürmek için kullanılan Apache Beam uygulamasını gösterin.
  • Ek kullanım örneklerini gösterin.

Bir ön işleme işlevi tanımlayın

Ön işleme fonksiyonu , tf.Transform en önemli kavramıdır. Ön işleme işlevi, veri kümesinin dönüşümünün mantıksal bir açıklamasıdır. Ön işleme işlevi, bir tensör sözlüğünü kabul eder ve döndürür; burada bir tensör , Tensor veya SparseTensor anlamına gelir. Ön işleme işlevini tanımlamak için kullanılan iki tür işlev vardır:

  1. Tensörleri kabul eden ve döndüren herhangi bir işlev. Bunlar, ham verileri dönüştürülmüş verilere dönüştüren grafiğe TensorFlow işlemlerini ekler.
  2. tf.Transform tarafından sağlanan analizörlerden herhangi biri. Analiz aynı zamanda kabul edip tensörleri döner ancak TensorFlow fonksiyonları aksine, onlar grafiğe işlemleri eklemeyin. Bunun yerine, çözümleyiciler tf.Transform dışında bir tam geçiş işlemi hesaplamasına neden olur. Çıktı olarak döndürülen sabit bir tensör oluşturmak için tüm veri kümesinde girdi tensör değerlerini kullanırlar. Örneğin, tft.min , veri kümesi üzerindeki minimum tensörü hesaplar. tf.Transform sabit bir çözümleyici seti sağlar, ancak bu gelecek sürümlerde genişletilecektir.

Ön işleme işlevi örneği

Analizörleri ve normal TensorFlow işlevlerini birleştirerek, kullanıcılar verileri dönüştürmek için esnek ardışık düzenler oluşturabilir. Aşağıdaki ön işleme işlevi, üç özelliğin her birini farklı şekillerde dönüştürür ve özelliklerden ikisini birleştirir:

import tensorflow as tf
import tensorflow_transform as tft
import tensorflow_transform.beam as tft_beam

def preprocessing_fn(inputs):
  x = inputs['x']
  y = inputs['y']
  s = inputs['s']
  x_centered = x - tft.mean(x)
  y_normalized = tft.scale_to_0_1(y)
  s_integerized = tft.compute_and_apply_vocabulary(s)
  x_centered_times_y_normalized = x_centered * y_normalized
  return {
      'x_centered': x_centered,
      'y_normalized': y_normalized,
      'x_centered_times_y_normalized': x_centered_times_y_normalized,
      's_integerized': s_integerized
  }

Burada x , y ve s , giriş özelliklerini temsil eden Tensor . , Oluşturulan ilk yeni tensör x_centered uygulayarak inşa edilmiştir tft.mean için x ve bu çıkarılarak x . tft.mean(x) tensör ortalama temsil eden bir tensörünün döner x . x_centered , ortalama çıkarılmış x tensördür.

İkinci yeni tensör, y_normalized , benzer bir şekilde, ancak uygunluk yöntemi tft.scale_to_0_1 kullanılarak tft.scale_to_0_1 . Bu yöntem, bilgi işleme benzer bir şey yapar x_centered yani maksimum ve minimum işlem ve ölçek bu kullanarak, y .

Tensör s_integerized , dizge s_integerized bir örneğini gösterir. Bu durumda, bir dizge alıp onu bir tamsayı ile eşleştiriyoruz. Bu,tft.compute_and_apply_vocabulary kolaylık işlevinitft.compute_and_apply_vocabulary . Bu işlev, giriş dizeleri tarafından alınan benzersiz değerleri hesaplamak için bir analizci kullanır ve ardından giriş dizelerini benzersiz değerler tablosundaki dizinlere dönüştürmek için TensorFlow işlemlerini kullanır.

Son sütun, tensörleri birleştirerek yeni özellikler oluşturmak için TensorFlow işlemlerini kullanmanın mümkün olduğunu gösterir.

Ön işleme işlevi, bir veri kümesindeki işlemlerin bir kanalını tanımlar. Boru hattını uygulamak için tf.Transform API'nin somut bir uygulamasına güveniyoruz. Apache Beam uygulaması, bir kullanıcının ön işleme işlevini verilere uygulayan PTransform sağlar. Bir tf.Transform kullanıcısının tipik iş akışı bir ön işleme işlevi oluşturacak, ardından bunu daha büyük bir Beam boru hattına dahil ederek eğitim için veri oluşturacaktır.

Harmanlama

Gruplama, TensorFlow'un önemli bir parçasıdır. tf.Transform hedeflerinden biri, ön işleme için sunum grafiğine (ve isteğe bağlı olarak eğitim grafiğine) dahil edilebilen bir TensorFlow grafiği sağlamak olduğundan, toplu işlem de tf.Transform önemli bir kavramdır.

Yukarıdaki örnekte açık olmasa da, TensorFlow ile eğitim ve hizmet sırasında olduğu gibi, kullanıcı tanımlı ön işleme işlevi, tek tek örnekleri değil, partileri temsil eden tensörlerden geçirilir. Öte yandan, çözümleyiciler, veri kümesinin tamamı üzerinde tek bir değer döndüren ve bir grup değer döndüren bir hesaplama gerçekleştirir. x a, Tensor bir şekle sahip (batch_size,) ise, tft.mean(x) a, Tensor bir şekle sahip () . Çıkarma x - tft.mean(x) bir yayın değeri burada tft.mean(x) ile temsil edilen yığının her eleman çıkartılmaktadır x .

Apache Beam Uygulaması

Ön işleme işlevi , birden çok veri işleme çerçevesinde uygulanan bir ön işleme ardışık tf.Transform mantıksal bir açıklaması olarak tasarlanırken, tf.Transform , Apache tf.Transform kullanılan kanonik bir uygulama sağlar. Bu uygulama, bir uygulamadan gereken işlevselliği gösterir. Bu işlevsellik için resmi bir API yoktur, bu nedenle her uygulama kendi özel veri işleme çerçevesi için deyimsel olan bir API kullanabilir.

Apache Beam uygulaması, bir ön işleme işlevi için verileri işlemek üzere kullanılan iki PTransform sağlar. Aşağıda, bileşik PTransform AnalyzeAndTransformDataset için kullanım gösterilmektedir:

raw_data = [
    {'x': 1, 'y': 1, 's': 'hello'},
    {'x': 2, 'y': 2, 's': 'world'},
    {'x': 3, 'y': 3, 's': 'hello'}
]

raw_data_metadata = ...
transformed_dataset, transform_fn = (
    (raw_data, raw_data_metadata) | tft_beam.AnalyzeAndTransformDataset(
        preprocessing_fn))
transformed_data, transformed_metadata = transformed_dataset

transformed_data içeriği aşağıda gösterilmektedir ve dönüştürülmüş sütunları ham verilerle aynı formatta içerir. Özellikle, s_integerized değerleri [0, 1, 0] dır - bu değerler hello ve world kelimelerinin deterministik olan tamsayılara nasıl eşlendiğine bağlıdır. x_centered sütunu için, ortalamayı x_centered , böylece [1.0, 2.0, 3.0] olan x sütununun değerleri [-1.0, 0.0, 1.0] . Benzer şekilde, sütunların geri kalanı da beklenen değerleriyle eşleşir.

[{u's_integerized': 0,
  u'x_centered': -1.0,
  u'x_centered_times_y_normalized': -0.0,
  u'y_normalized': 0.0},
 {u's_integerized': 1,
  u'x_centered': 0.0,
  u'x_centered_times_y_normalized': 0.0,
  u'y_normalized': 0.5},
 {u's_integerized': 0,
  u'x_centered': 1.0,
  u'x_centered_times_y_normalized': 1.0,
  u'y_normalized': 1.0}]

Hem raw_data hem de transformed_data , veri kümeleridir. Sonraki iki bölüm, Beam uygulamasının veri kümelerini nasıl temsil ettiğini ve verilerin diske nasıl okunup yazılacağını gösterir. Diğer dönüş değeri olan transform_fn , aşağıda ayrıntılı olarak ele alınan verilere uygulanan dönüşümü temsil eder.

AnalyzeAndTransformDataset , AnalyzeDataset ve TransformDataset uygulaması tarafından sağlanan iki temel dönüşümün bileşimidir. Dolayısıyla, aşağıdaki iki kod parçacığı eşdeğerdir:

transformed_data, transform_fn = (
    my_data | tft_beam.AnalyzeAndTransformDataset(preprocessing_fn))
transform_fn = my_data | tft_beam.AnalyzeDataset(preprocessing_fn)
transformed_data = (my_data, transform_fn) | tft_beam.TransformDataset()

transform_fn , veri kümesinin her satırına uygulanan bir işlemi temsil eden saf bir işlevdir. Özellikle, analizör değerleri halihazırda hesaplanmış ve sabitler olarak değerlendirilmiştir. Örnekte, transform_fn sabit olarak x sütununun ortalamasını, y sütununun minimum ve maksimumunu ve dizeleri tamsayılarla eşlemek için kullanılan kelime dağarcığını içerir.

tf.Transform önemli bir özelliği, transform_fn satırlar üzerindeki bir haritayı temsil tf.Transform - her satıra ayrı ayrı uygulanan saf bir işlevdir. Satırları toplamak için tüm hesaplamalar AnalyzeDataset içinde AnalyzeDataset . Ayrıca, transform_fn , sunum grafiğine gömülebilen bir TensorFlow Graph olarak temsil edilir.

AnalyzeAndTransformDataset , bu özel durumda optimizasyonlar için sağlanır. Bu, scikit-learn'de kullanılan kalıpla aynıdır ve fit , transform ve fit_transform yöntemlerini sağlar.

Veri Biçimleri ve Şema

TFT Beam uygulaması iki farklı giriş veri formatını kabul eder. "Örnek dikte" biçimi (yukarıdaki örnekte ve simple_example.py ) sezgisel bir biçimdir ve küçük veri kümeleri için uygunken, TFXIO ( Apache Ok ) biçimi gelişmiş performans sağlar ve büyük veri kümeleri için uygundur.

Beam uygulaması, PCollection'a eşlik eden "meta veriler" tarafından giriş PCollection'ın hangi formatta olacağını söyler:

(raw_data, raw_data_metadata) | tft.AnalyzeDataset(...)
  • raw_data_metadata bir dataset_metadata.DatasetMetadata (aşağıdaki "'örnek raw_data ' biçimi" bölümüne bakın), raw_data "örnek diktesi" biçiminde olması beklenir.
  • Eğer raw_data_metadata bir olduğunu tfxio.TensorAdapterConfig (aşağıya bakınız, "TFXIO biçimi" bölümü), sonra raw_data TFXIO biçiminde olması bekleniyor.

"Örnek dikte" biçimi

Önceki kod örneklerinde, raw_data_metadata tanımlayan kod ihmal edilmiştir. Meta veriler, verilerin düzenini tanımlayan şemayı içerir, böylece çeşitli formatlardan okunur ve bu formatlara yazılır. Son bölümde gösterilen bellek içi format bile kendi kendini tanımlamaz ve tensörler olarak yorumlanabilmesi için şemayı gerektirir.

Örnek veriler için şema tanımı şöyledir:

from tensorflow_transform.tf_metadata import dataset_metadata
from tensorflow_transform.tf_metadata import schema_utils

raw_data_metadata = dataset_metadata.DatasetMetadata(
      schema_utils.schema_from_feature_spec({
        's': tf.io.FixedLenFeature([], tf.string),
        'y': tf.io.FixedLenFeature([], tf.float32),
        'x': tf.io.FixedLenFeature([], tf.float32),
    }))

Schema protokolü, verileri disk üzerindeki veya bellek içi biçiminden tensörlere ayrıştırmak için gereken bilgileri içerir. Genellikle arayarak inşa edilmiştir schema_utils.schema_from_feature_spec için dict haritalama özelliği tuşlarıyla tf.io.FixedLenFeature , tf.io.VarLenFeature ve tf.io.SparseFeature değerler. Daha fazla ayrıntı için tf.parse_example belgelerine bakın.

Yukarıda, her bir özelliğin sabit sayıda değer, bu durumda tek bir skaler değer içerdiğini belirtmek için tf.io.FixedLenFeature kullanıyoruz. tf.Transform toplu iş örnekleri olduğundan, özelliği temsil eden gerçek Tensor , bilinmeyen boyutun toplu iş boyutu olduğu bir şekle (None,) sahip olacaktır.

TFXIO biçimi

Bu formatla, verilerin bir pyarrow.RecordBatch içinde yer alması beklenir. RecordBatch veriler için Apache Beam uygulamamız, aşağıdaki türlerdeki sütunlardan oluşan Arrow RecordBatch kabul eder:

  • pa.list_(<primitive>) , burada <primitive> , pa.int64() , pa.float32() pa.binary() veya pa.large_binary() .

  • pa.large_list(<primitive>)

Yukarıda kullandığımız oyuncak girdi veri kümesi, RecordBatch olarak temsil edildiğinde aşağıdaki gibi görünür:

raw_data = [
    pa.record_batch([
        pa.array([[1], [2], [3]], pa.list_(pa.float32())),
        pa.array([[1], [2], [3]], pa.list_(pa.float32())),
        pa.array([['hello'], ['world'], ['hello']], pa.list_(pa.binary())),
    ], ['x', 'y', 's'])
]

DatasetMetadata benzer "örneği dict" biçimini eşlik edecek gerekli olan, bir tfxio.TensorAdapterConfig eşlik etmek gereklidir RecordBatch es. TensorRepresentations sütunların nasıl RecordBatch Tensors (tf.Tensor, tf.SparseTensor dahil ancak bunlarla sınırlı olmamak üzere) olarak nasıl yorumlanabileceğini benzersiz şekilde belirlemek için RecordBatch Arrow şemasından ve RecordBatch oluşur.

TensorRepresentations , preprocessing_fn kabul ettiği bir Tensör ile RecordBatch sütunlar arasındaki ilişkiyi kuran bir Dict[Text, TensorRepresentation] dir. Örneğin:

tensor_representation = {
    'x': text_format.Parse(
        """dense_tensor { column_name: "col1" shape { dim { size: 2 } } }"""
        schema_pb2.TensorRepresentation())
}

Araçlarının inputs['x'] içinde preprocessing_fn yoğun olmalıdır, değerleri adı kolonu gelen tf.Tensor, 'col1' giriş olarak RecordBatch es, ve (harmanlanmış) şeklinde olmalıdır [batch_size, 2] .

TensorRepresentation , TensorFlow Metadata'da tanımlanan bir Protobuf'tur.

TensorFlow ile uyumluluk

tf.Transform , yukarıdaki transform_fn TF 1.x veya TF 2.x SavedModel olarak dışa aktarmak için destek sağlar. 0.30 sürümünden önceki varsayılan davranış bir TF 1.x SavedModel dışa aktarıyordu. 0.30 sürümünden başlayarak, varsayılan davranış, TF 2.x davranışları açıkça devre dışı bırakılmadıkça (örneğin tf.compat.v1.disable_v2_behavior() çağırarak tf.compat.v1.disable_v2_behavior() bir TF 2.x SavedModel'i dışa aktarmaktır.

Estimators ve Sessions gibi TF 1.x kavramlarını kullanıyorsanız, tf.Transform bağımsız bir kitaplık olarak kullanıyorsanız veya tf.Transform Transform bileşenine force_tf_compat_v1=True to tft_beam.Context geçerek önceki davranışı koruyabilirsiniz.

transform_fn bir TF 2.x SavedModel olarak dışa aktarırken, preprocessing_fn tf.function kullanılarak izlenebilir olması beklenir. Ek olarak, ardışık DataflowRunner uzaktan çalıştırıyorsanız (örneğin, DataflowRunner ), preprocessing_fn ve tüm bağımlılıkların burada açıklandığı gibi düzgün bir şekilde paketlendiğinden emin olun.

TF 2.x SavedModel'i dışa aktarmak için tf.Transform ilgili bilinen sorunlar burada belgelenmiştir.

Apache Beam ile giriş ve çıkış

Şimdiye kadar, girdi ve çıktı verilerini python listelerinde ( RecordBatch es veya örnek sözlüklerinde) RecordBatch . Bu, Apache Beam'in listelerle çalışma yeteneğinin yanı sıra verilerin ana temsili olan PCollection dayanan bir basitleştirmedir.

Bir PCollection , bir Beam boru hattının bir parçasını oluşturan bir veri temsilidir. AnalyzeDataset ve TransformDataset dahil olmak üzere çeşitli PTransform uygulanarak ve AnalyzeDataset çalıştırılarak bir Beam ardışık PTransform oluşturulur. Ana ikilinin belleğinde bir PCollection oluşturulmaz, bunun yerine çalışanlar arasında dağıtılır (bu bölüm bellek içi yürütme modunu kullanmasına rağmen).

Önceden TFXIO PCollection Kaynakları ( TFXIO )

Uygulamamızın kabul ettiği RecordBatch biçimi, diğer TFX kitaplıklarının kabul ettiği yaygın bir biçimdir. Bu nedenle TFX, diskteki çeşitli formatlardaki dosyaları okuyan ve RecordBatch üreten ve ayrıca türetilmiş TensorRepresentations dahil TensorAdapterConfig verebilen kullanışlı "kaynaklar" (diğer adıyla TFXIO ) TensorRepresentations .

Bu TFXIO tfx_bsl ( tfx_bsl.public.tfxio ) paketinde tfx_bsl .

Örnek: "Nüfus Sayımı Geliri" veri kümesi

Aşağıdaki örnek, hem diske veri okumayı hem de diske veri yazmayı ve verileri bir PCollection (liste değil) olarak temsil census_example.py , bkz: census_example.py . Aşağıda verilerin nasıl indirileceğini ve bu örneğin nasıl çalıştırılacağını gösteriyoruz. "Nüfus Sayımı Geliri" veri kümesi, UCI Makine Öğrenimi Havuzu tarafından sağlanır. Bu veri kümesi hem kategorik hem de sayısal verileri içerir.

Veriler CSV formatındadır, işte ilk iki satır:

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K

Veri kümesinin sütunları kategorik veya sayısaldır. Bu veri kümesi bir sınıflandırma problemini açıklar: bireyin yılda 50.000'den fazla veya az kazandığı son sütunu tahmin etme. Bununla birlikte, tf.Transform perspektifinden bakıldığında, bu etiket sadece başka bir kategorik sütundur.

CSV satırlarını RecordBatches çevirmek için Pre-canned TFXIO , BeamRecordCsvTFXIO RecordBatches . TFXIO , iki önemli bilgi gerektirir:

  • her CSV sütunu hakkında tür ve şekil bilgilerini içeren bir TensorFlow Meta Veri Şeması . TensorRepresentation s, TensorRepresentation isteğe bağlı bir parçasıdır; Sağlanmazsa (bu örnekte durum budur), tür ve şekil bilgilerinden çıkarılacaktır. Şema, TF ayrıştırma özelliklerinden (bu örnekte gösterilmiştir) çevirmek için sağladığımız bir yardımcı işlevi kullanarak veya TensorFlow Veri Doğrulaması'nı çalıştırarak elde edilebilir .

  • CSV dosyasında göründükleri sırayla sütun adlarının listesi. Bu adların Şemadaki özellik adlarıyla eşleşmesi gerektiğini unutmayın.

Bu örnekte, education-num özelliğinin eksik olmasına izin veriyoruz. Bir şekilde temsil edilmiş olduğu bu araçlar tf.io.VarLenFeature feature_spec olarak ve şekilde tf.SparseTensor içinde preprocessing_fn . Diğer özellikler, preprocessing_fn aynı adı taşıyan tf.Tensor s olacaktır.

csv_tfxio = tfxio.BeamRecordCsvTFXIO(
    physical_format='text', column_names=ordered_columns, schema=SCHEMA)

record_batches = (
    p
    | 'ReadTrainData' >> textio.ReadFromText(train_data_file)
    | ...  # fix up csv lines
    | 'ToRecordBatches' >> csv_tfxio.BeamSource())

tensor_adapter_config = csv_tfxio.TensorAdapterConfig()

. Not biz CSV satırlardan sonra bazı ek düzeltme-up içinde okunur yapmak zorunda olduğunu Aksi takdirde, güvenebileceğini CsvTFXIO iki dosyayı okuma ve tercüme işlemek için RecordBatch es:

csv_tfxio = tfxio.CsvTFXIO(train_data_file, column_name=ordered_columns,
                           schema=SCHEMA)
record_batches = p | 'TFXIORead' >> csv_tfxio.BeamSource()
tensor_adapter_config = csv_tfxio.TensorAdapterConfig()

Ön işleme, her bir sütunu manuel olarak belirtmek yerine ön işleme işlevinin programlı olarak oluşturulması dışında önceki örneğe benzer. Aşağıdaki ön işleme işlevinde, NUMERICAL_COLUMNS ve CATEGORICAL_COLUMNS , sayısal ve kategorik sütunların adlarını içeren listelerdir:

def preprocessing_fn(inputs):
  """Preprocess input columns into transformed columns."""
  # Since we are modifying some features and leaving others unchanged, we
  # start by setting `outputs` to a copy of `inputs.
  outputs = inputs.copy()

  # Scale numeric columns to have range [0, 1].
  for key in NUMERIC_FEATURE_KEYS:
    outputs[key] = tft.scale_to_0_1(outputs[key])

  for key in OPTIONAL_NUMERIC_FEATURE_KEYS:
    # This is a SparseTensor because it is optional. Here we fill in a default
    # value when it is missing.
      sparse = tf.sparse.SparseTensor(outputs[key].indices, outputs[key].values,
                                      [outputs[key].dense_shape[0], 1])
      dense = tf.sparse.to_dense(sp_input=sparse, default_value=0.)
    # Reshaping from a batch of vectors of size 1 to a batch to scalars.
    dense = tf.squeeze(dense, axis=1)
    outputs[key] = tft.scale_to_0_1(dense)

  # For all categorical columns except the label column, we generate a
  # vocabulary but do not modify the feature.  This vocabulary is instead
  # used in the trainer, by means of a feature column, to convert the feature
  # from a string to an integer id.
  for key in CATEGORICAL_FEATURE_KEYS:
    tft.vocabulary(inputs[key], vocab_filename=key)

  # For the label column we provide the mapping from string to index.
  initializer = tf.lookup.KeyValueTensorInitializer(
      keys=['>50K', '<=50K'],
      values=tf.cast(tf.range(2), tf.int64),
      key_dtype=tf.string,
      value_dtype=tf.int64)
  table = tf.lookup.StaticHashTable(initializer, default_value=-1)

  outputs[LABEL_KEY] = table.lookup(outputs[LABEL_KEY])

  return outputs

Önceki örnekten bir fark, etiket sütununun dizeden bir dizine eşlemeyi manuel olarak belirtmesidir. Dolayısıyla, '>50' 0 ile eşlenir ve '<=50K' 1 ile eşlenir çünkü eğitilen modeldeki hangi dizinin hangi etikete karşılık geldiğini bilmek yararlıdır.

record_batches değişken bir temsil PCollection ait pyarrow.RecordBatch es. tensor_adapter_config verilir csv_tfxio anlaşılmaktadır, SCHEMA (TF ayrıştırma özellikleri ile ilgili olarak bu örnekte, sonuçta ve benzeri).

Son aşama, dönüştürülen verilerin diske yazılması ve ham verileri okumaya benzer bir biçime sahip olmasıdır. Bunu yapmak için kullanılan şema, çıktı verileri için bir şema oluşturan AnalyzeAndTransformDataset çıktısının bir parçasıdır. Diske yazılacak kod aşağıda gösterilmiştir. Şema, meta verilerin bir parçasıdır ancak tf.Transform API'sinde bu ikisini birbirinin yerine kullanır (yani meta verileri ExampleProtoCoder ). Bunun farklı bir biçimde yazdığını unutmayın. textio.WriteToText yerine Beam'in yerleşik TFRecord formatı desteğini kullanın ve verileri Example protos olarak kodlamak için bir kodlayıcı kullanın. Bu, sonraki bölümde gösterildiği gibi eğitim için kullanmak için daha iyi bir formattır. transformed_eval_data_base , yazılan tek tek parçalar için temel dosya adını sağlar.

transformed_data | "WriteTrainData" >> tfrecordio.WriteToTFRecord(
    transformed_eval_data_base,
    coder=tft.coders.ExampleProtoCoder(transformed_metadata))

Eğitim verilerine ek olarak, transform_fn ayrıca meta verilerle birlikte yazılır:

_ = (
    transform_fn
    | 'WriteTransformFn' >> tft_beam.WriteTransformFn(working_dir))
transformed_metadata | 'WriteMetadata' >> tft_beam.WriteMetadata(
    transformed_metadata_file, pipeline=p)

Tüm Beam ardışık p.run().wait_until_finish() ile çalıştırın p.run().wait_until_finish() . Bu noktaya kadar, Beam ardışık düzeni ertelenmiş, dağıtılmış bir hesaplamayı temsil eder. Ne yapılacağına dair talimatlar sağlar, ancak talimatlar yerine getirilmemiştir. Bu son çağrı, belirtilen ardışık düzeni yürütür.

Sayım veri kümesini indirin

Aşağıdaki kabuk komutlarını kullanarak sayım veri kümesini indirin:

  wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data
  wget https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test

census_example.py komut dosyasını çalıştırırken, bu verileri içeren dizini ilk argüman olarak census_example.py . Komut dosyası, önceden işlenmiş verileri eklemek için geçici bir alt dizin oluşturur.

TensorFlow Eğitimi ile entegre edin

census_example.py son bölümü, census_example.py işlenmiş verilerin bir modeli eğitmek için nasıl kullanıldığını gösterir. Ayrıntılar için Tahminciler belgelerine bakın. İlk adım, önceden işlenmiş sütunların açıklamasını gerektiren bir Estimator oluşturmaktır. Her sayısal sütun, sabit boyutlu (bu örnekte 1 ) yoğun bir vektörün etrafındaki sarmalayıcı olan real_valued_column olarak tanımlanır. Her kategorik sütun, dizeden tamsayılara eşlenir ve ardından indicator_column geçirilir. tft.TFTransformOutput , her kategorik özelliğin kelime dağarcığı dosya yolunu bulmak için kullanılır.

real_valued_columns = [feature_column.real_valued_column(key)
                       for key in NUMERIC_FEATURE_KEYS]

one_hot_columns = [
    tf.feature_column.indicator_column(
        tf.feature_column.categorical_column_with_vocabulary_file(
            key=key,
            vocabulary_file=tf_transform_output.vocabulary_file_by_name(
                vocab_filename=key)))
    for key in CATEGORICAL_FEATURE_KEYS]

estimator = tf.estimator.LinearClassifier(real_valued_columns + one_hot_columns)

Bir sonraki adım, eğitim ve değerlendirme için girdi işlevini oluşturmak üzere bir oluşturucu oluşturmaktır. tf.Learn tarafından kullanılan eğitimden farklıdır. Dönüştürülen verileri ayrıştırmak için bir özellik spesifikasyonu tf.Learn . Bunun yerine, bir özellik spesifikasyonu oluşturmak için dönüştürülen verilerin meta verilerini kullanın.

def _make_training_input_fn(tf_transform_output, transformed_examples,
                            batch_size):
  ...
  def input_fn():
    """Input function for training and eval."""
    dataset = tf.data.experimental.make_batched_features_dataset(
        ..., tf_transform_output.transformed_feature_spec(), ...)

    transformed_features = tf.compat.v1.data.make_one_shot_iterator(
        dataset).get_next()
    ...

  return input_fn

Kalan kod, Estimator sınıfının kullanılmasıyla aynıdır. Örnek, modeli SavedModel biçiminde dışa aktarmak için kod da içerir. Dışa aktarılan model, Tensorflow Serving veya Cloud ML Engine tarafından kullanılabilir.