Komponen Pipa TFX Transform

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Komponen pipa Transform TFX melakukan rekayasa fitur pada tf.Contoh yang dipancarkan dari komponen ExampleGen , menggunakan skema data yang dibuat oleh komponen SchemaGen , dan memancarkan SavedModel serta statistik pada data pra-transformasi dan pasca-transformasi. Saat dijalankan, SavedModel akan menerima tf.Examples yang dipancarkan dari komponen ExampleGen dan memancarkan data fitur yang diubah.

  • Menggunakan: tf.Examples dari komponen ExampleGen, dan skema data dari komponen SchemaGen.
  • Memancarkan: Model Tersimpan ke komponen Pelatih, statistik pra-transformasi dan pasca-transformasi.

Mengonfigurasi Komponen Transform

Setelah preprocessing_fn Anda ditulis, itu perlu didefinisikan dalam modul python yang kemudian diberikan ke komponen Transform sebagai input. Modul ini akan dimuat oleh transform dan fungsi bernama preprocessing_fn akan ditemukan dan digunakan oleh Transform untuk membangun pipa preprocessing.

transform = Transform(
    examples=example_gen.outputs['examples'],
    schema=schema_gen.outputs['schema'],
    module_file=os.path.abspath(_taxi_transform_module_file))

Selain itu, Anda mungkin ingin memberikan opsi untuk perhitungan statistik pra-transformasi atau pasca-transformasi berbasis TFDV . Untuk melakukannya, tentukan stats_options_updater_fn dalam modul yang sama.

Transformasi dan Transformasi TensorFlow

Transform memanfaatkan TensorFlow Transform secara ekstensif untuk melakukan rekayasa fitur pada set data Anda. TensorFlow Transform adalah alat yang hebat untuk mengubah data fitur sebelum masuk ke model Anda dan sebagai bagian dari proses pelatihan. Transformasi fitur umum meliputi:

  • Embedding : mengubah fitur sparse (seperti ID integer yang dihasilkan oleh kosakata) menjadi fitur padat dengan menemukan pemetaan yang bermakna dari ruang berdimensi tinggi ke ruang berdimensi rendah. Lihat unit Penyematan di Kursus Singkat Machine-learning untuk pengenalan penyematan.
  • Pembuatan kosakata : mengubah string atau fitur non-numerik lainnya menjadi bilangan bulat dengan membuat kosakata yang memetakan setiap nilai unik ke nomor ID.
  • Menormalkan nilai : mengubah fitur numerik sehingga semuanya berada dalam kisaran yang sama.
  • Bucketization : mengonversi fitur bernilai berkelanjutan menjadi fitur kategoris dengan menetapkan nilai ke bucket diskrit.
  • Memperkaya fitur teks : menghasilkan fitur dari data mentah seperti token, n-gram, entitas, sentimen, dll., untuk memperkaya kumpulan fitur.

TensorFlow Transform menyediakan dukungan untuk ini dan banyak jenis transformasi lainnya:

  • Secara otomatis menghasilkan kosakata dari data terbaru Anda.

  • Lakukan transformasi arbitrer pada data Anda sebelum mengirimkannya ke model Anda. TensorFlow Transform membuat transformasi ke dalam grafik TensorFlow untuk model Anda sehingga transformasi yang sama dilakukan pada waktu pelatihan dan inferensi. Anda dapat menentukan transformasi yang merujuk ke properti global data, seperti nilai maksimal fitur di semua instance pelatihan.

Anda dapat mengubah data Anda sesuka Anda sebelum menjalankan TFX. Namun jika Anda melakukannya dalam TensorFlow Transform, transformasi menjadi bagian dari grafik TensorFlow. Pendekatan ini membantu menghindari kemiringan pelatihan/penyajian.

Transformasi di dalam kode pemodelan Anda menggunakan FeatureColumns. Menggunakan FeatureColumns, Anda dapat menentukan bucketizations, integerizations yang menggunakan kosa kata yang telah ditentukan, atau transformasi lain yang dapat didefinisikan tanpa melihat data.

Sebaliknya, TensorFlow Transform dirancang untuk transformasi yang memerlukan pemindahan data secara penuh untuk menghitung nilai yang tidak diketahui sebelumnya. Misalnya, generasi kosa kata membutuhkan lulus penuh atas data.

Selain menghitung nilai menggunakan Apache Beam, TensorFlow Transform memungkinkan pengguna untuk menyematkan nilai ini ke dalam grafik TensorFlow, yang kemudian dapat dimuat ke dalam grafik pelatihan. Misalnya saat menormalkan fitur, fungsi tft.scale_to_z_score akan menghitung mean dan standar deviasi fitur, dan juga representasi, dalam grafik TensorFlow, dari fungsi yang mengurangi mean dan membaginya dengan standar deviasi. Dengan memancarkan grafik TensorFlow, bukan hanya statistik, TensorFlow Transform menyederhanakan proses pembuatan pipeline prapemrosesan Anda.

Karena prapemrosesan diekspresikan sebagai grafik, itu bisa terjadi di server, dan dijamin konsisten antara pelatihan dan penayangan. Konsistensi ini menghilangkan salah satu sumber kemiringan pelatihan/penyajian.

TensorFlow Transform memungkinkan pengguna menentukan pipeline prapemrosesan mereka menggunakan kode TensorFlow. Ini berarti bahwa pipeline dibuat dengan cara yang sama seperti grafik TensorFlow. Jika hanya operasi TensorFlow yang digunakan dalam grafik ini, pipeline akan menjadi peta murni yang menerima batch input dan mengembalikan batch output. Pipeline seperti itu akan sama dengan menempatkan grafik ini di dalam input_fn Anda saat menggunakan tf.Estimator API. Untuk menentukan operasi full-pass seperti komputasi kuantil, TensorFlow Transform menyediakan fungsi khusus yang disebut analyzers yang tampak seperti operasi TensorFlow, tetapi sebenarnya menentukan komputasi yang ditangguhkan yang akan dilakukan oleh Apache Beam, dan outputnya dimasukkan ke dalam grafik sebagai konstan. Sementara operasi TensorFlow biasa akan mengambil satu batch sebagai inputnya, melakukan beberapa komputasi hanya pada batch itu dan mengeluarkan satu batch, analyzer akan melakukan pengurangan global (diimplementasikan di Apache Beam) pada semua batch dan mengembalikan hasilnya.

Dengan menggabungkan operasi TensorFlow biasa dan penganalisis TensorFlow Transform, pengguna dapat membuat pipeline yang kompleks untuk memproses data sebelumnya. Misalnya fungsi tft.scale_to_z_score mengambil tensor input dan mengembalikan tensor yang dinormalisasi menjadi mean 0 dan varians 1 . Ini dilakukan dengan memanggil penganalisis mean dan var di bawah tenda, yang secara efektif akan menghasilkan konstanta dalam grafik yang sama dengan mean dan varians dari tensor input. Ini kemudian akan menggunakan operasi TensorFlow untuk mengurangi mean dan membaginya dengan standar deviasi.

TensorFlow Transform preprocessing_fn

Komponen Transform TFX menyederhanakan penggunaan Transform dengan menangani panggilan API yang terkait dengan membaca dan menulis data, dan menulis output SavedModel ke disk. Sebagai pengguna TFX, Anda hanya perlu mendefinisikan satu fungsi yang disebut preprocessing_fn . Dalam preprocessing_fn Anda mendefinisikan serangkaian fungsi yang memanipulasi dict input tensor untuk menghasilkan dict output tensor. Anda dapat menemukan fungsi pembantu seperti scale_to_0_1 dan compute_and_apply_vocabulary pada TensorFlow Transform API atau menggunakan fungsi TensorFlow biasa seperti yang ditunjukkan di bawah ini.

def preprocessing_fn(inputs):
  """tf.transform's callback function for preprocessing inputs.

  Args:
    inputs: map from feature keys to raw not-yet-transformed features.

  Returns:
    Map from string feature key to transformed feature operations.
  """
  outputs = {}
  for key in _DENSE_FLOAT_FEATURE_KEYS:
    # If sparse make it dense, setting nan's to 0 or '', and apply zscore.
    outputs[_transformed_name(key)] = transform.scale_to_z_score(
        _fill_in_missing(inputs[key]))

  for key in _VOCAB_FEATURE_KEYS:
    # Build a vocabulary for this feature.
    outputs[_transformed_name(
        key)] = transform.compute_and_apply_vocabulary(
            _fill_in_missing(inputs[key]),
            top_k=_VOCAB_SIZE,
            num_oov_buckets=_OOV_SIZE)

  for key in _BUCKET_FEATURE_KEYS:
    outputs[_transformed_name(key)] = transform.bucketize(
        _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT)

  for key in _CATEGORICAL_FEATURE_KEYS:
    outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])

  # Was this passenger a big tipper?
  taxi_fare = _fill_in_missing(inputs[_FARE_KEY])
  tips = _fill_in_missing(inputs[_LABEL_KEY])
  outputs[_transformed_name(_LABEL_KEY)] = tf.where(
      tf.is_nan(taxi_fare),
      tf.cast(tf.zeros_like(taxi_fare), tf.int64),
      # Test if the tip was > 20% of the fare.
      tf.cast(
          tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))

  return outputs

Memahami input ke preprocessing_fn

preprocessing_fn menjelaskan serangkaian operasi pada tensor (yaitu, Tensor s atau SparseTensor s) dan untuk menulis preprocessing_fn dengan benar, perlu untuk memahami bagaimana data Anda direpresentasikan sebagai tensor. Input ke preprocessing_fn ditentukan oleh skema. Proto Schema berisi daftar Feature s, dan Transform mengonversinya menjadi "spesifikasi fitur" (terkadang disebut "spesifikasi parsing") yang merupakan dict yang kuncinya adalah nama fitur dan nilainya adalah salah satu dari FixedLenFeature atau VarLenFeature (atau opsi yang tidak digunakan oleh TensorFlow Transform).

Aturan untuk menyimpulkan spesifikasi fitur dari Schema adalah

  • Setiap feature dengan kumpulan shape akan menghasilkan tf.FixedLenFeature dengan bentuk dan default_value=None . presence.min_fraction harus 1 jika tidak dan kesalahan akan terjadi, karena ketika tidak ada nilai default, tf.FixedLenFeature membutuhkan fitur untuk selalu ada.
  • Setiap feature dengan shape yang tidak disetel akan menghasilkan VarLenFeature .
  • Setiap sparse_feature akan menghasilkan tf.SparseFeature yang size dan is_sorted ditentukan oleh bidang fixed_shape dan is_sorted dari pesan SparseFeature .
  • Fitur yang digunakan sebagai index_feature atau value_feature dari sparse_feature tidak akan memiliki entri sendiri yang dihasilkan dalam spesifikasi fitur.
  • Korespondensi antara bidang type feature (atau fitur nilai dari proto sparse_feature ) dan tipe dtype dari spesifikasi fitur diberikan oleh tabel berikut:
type dtype
schema_pb2.INT tf.int64
schema_pb2.FLOAT tf.float32
schema_pb2.BYTES tf.string

Menggunakan TensorFlow Transform untuk menangani label string

Biasanya seseorang ingin menggunakan TensorFlow Transform untuk menghasilkan kosakata dan menerapkan kosakata itu untuk mengonversi string menjadi bilangan bulat. Saat mengikuti alur kerja ini, input_fn yang dibuat dalam model akan menampilkan string bilangan bulat. Namun label merupakan pengecualian, karena agar model dapat memetakan label keluaran (bilangan bulat) kembali ke string, model memerlukan input_fn untuk mengeluarkan label string, bersama dengan daftar kemungkinan nilai label. Misalnya jika labelnya adalah cat dan dog maka output dari input_fn harus berupa string mentah ini, dan kunci ["cat", "dog"] harus diteruskan ke estimator sebagai parameter (lihat detail di bawah).

Untuk menangani pemetaan label string ke bilangan bulat, Anda harus menggunakan TensorFlow Transform untuk menghasilkan kosakata. Kami menunjukkan ini dalam cuplikan kode di bawah ini:

def _preprocessing_fn(inputs):
  """Preprocess input features into transformed features."""

  ...


  education = inputs[features.RAW_LABEL_KEY]
  _ = tft.vocabulary(education, vocab_filename=features.RAW_LABEL_KEY)

  ...

Fungsi preprocessing di atas mengambil fitur raw input (yang juga akan dikembalikan sebagai bagian dari output dari fungsi preprocessing) dan memanggil tft.vocabulary di atasnya. Ini menghasilkan kosakata yang dihasilkan untuk education yang dapat diakses dalam model.

Contoh tersebut juga menunjukkan cara mengubah label dan kemudian menghasilkan kosakata untuk label yang diubah. Secara khusus dibutuhkan education label mentah dan mengubah semua kecuali 5 label teratas (berdasarkan frekuensi) menjadi UNKNOWN , tanpa mengubah label menjadi bilangan bulat.

Dalam kode model, classifier harus diberikan kosakata yang dihasilkan oleh tft.vocabulary sebagai argumen label_vocabulary . Ini dilakukan dengan terlebih dahulu membaca kosakata ini sebagai daftar dengan fungsi pembantu. Ini ditunjukkan dalam cuplikan di bawah ini. Perhatikan kode contoh menggunakan label yang diubah yang dibahas di atas tetapi di sini kami menunjukkan kode untuk menggunakan label mentah.

def create_estimator(pipeline_inputs, hparams):

  ...

  tf_transform_output = trainer_util.TFTransformOutput(
      pipeline_inputs.transform_dir)

  # vocabulary_by_name() returns a Python list.
  label_vocabulary = tf_transform_output.vocabulary_by_name(
      features.RAW_LABEL_KEY)

  return tf.contrib.learn.DNNLinearCombinedClassifier(
      ...
      n_classes=len(label_vocab),
      label_vocabulary=label_vocab,
      ...)

Mengonfigurasi statistik pra-transformasi dan pasca-transformasi

Seperti disebutkan di atas, komponen Transform memanggil TFDV untuk menghitung statistik pra-transformasi dan pasca-transformasi. TFDV mengambil sebagai input objek StatsOptions opsional. Pengguna mungkin ingin mengonfigurasi objek ini untuk mengaktifkan statistik tambahan tertentu (misalnya statistik NLP) atau untuk menetapkan ambang batas yang divalidasi (misalnya frekuensi token min/maks). Untuk melakukannya, tentukan stats_options_updater_fn dalam file modul.

def stats_options_updater_fn(stats_type, stats_options):
  ...
  if stats_type == stats_options_util.StatsType.PRE_TRANSFORM:
    # Update stats_options to modify pre-transform statistics computation.
    # Most constraints are specified in the schema which can be accessed
    # via stats_options.schema.
  if stats_type == stats_options_util.StatsType.POST_TRANSFORM
    # Update stats_options to modify post-transform statistics computation.
    # Most constraints are specified in the schema which can be accessed
    # via stats_options.schema.
  return stats_options

Statistik pasca-transformasi sering mendapat manfaat dari pengetahuan tentang kosakata yang digunakan untuk pra-pemrosesan fitur. Nama kosakata untuk pemetaan jalur disediakan untuk StatsOptions (dan karenanya TFDV) untuk setiap kosakata yang dihasilkan TFT. Selain itu, pemetaan untuk kosakata yang dibuat secara eksternal dapat ditambahkan dengan (i) memodifikasi kamus vocab_paths secara langsung dalam StatsOptions atau dengan (ii) menggunakan tft.annotate_asset .