Arsitektur Analisis Model Tensorflow

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

Ringkasan

Pipeline TensorFlow Model Analysis (TFMA) digambarkan sebagai berikut:

Pipa TFMA

Pipa terdiri dari empat komponen utama:

  • Baca Masukan
  • Ekstraksi
  • Evaluasi
  • Tulis Hasil

Komponen ini menggunakan dua tipe utama: tfma.Extracts dan tfma.evaluators.Evaluation . Jenis tfma.Extracts mewakili data yang diekstraksi selama pemrosesan pipa dan mungkin sesuai dengan satu atau lebih contoh untuk model. tfma.evaluators.Evaluation merupakan output dari evaluasi ekstrak di berbagai titik selama proses ekstraksi. Untuk menyediakan API yang fleksibel, tipe ini hanyalah dicts di mana kuncinya didefinisikan (dicadangkan untuk digunakan) oleh implementasi yang berbeda. Jenis-jenisnya didefinisikan sebagai berikut:

# Extracts represent data extracted during pipeline processing.
# For example, the PredictExtractor stores the data for the
# features, labels, and predictions under the keys "features",
# "labels", and "predictions".
Extracts = Dict[Text, Any]

# Evaluation represents the output from evaluating extracts at
# particular point in the pipeline. The evaluation outputs are
# keyed by their associated output type. For example, the metric / plot
# dictionaries from evaluating metrics and plots will be stored under
# "metrics" and "plots" respectively.
Evaluation = Dict[Text, beam.pvalue.PCollection]

Perhatikan bahwa tfma.Extracts tidak pernah ditulis secara langsung mereka harus selalu melalui evaluator untuk menghasilkan tfma.evaluators.Evaluation yang kemudian ditulis. Perhatikan juga bahwa tfma.Extracts adalah dicts yang disimpan dalam beam.pvalue.PCollection (yaitu beam.PTransform s mengambil sebagai input beam.pvalue.PCollection[tfma.Extracts] ) sedangkan tfma.evaluators.Evaluation adalah dict yang nilainya adalah beam.pvalue.PCollection s (yaitu beam.PTransform s mengambil dict itu sendiri sebagai argumen untuk input beam.value.PCollection ). Dengan kata lain tfma.evaluators.Evaluation digunakan pada waktu konstruksi pipeline, tetapi tfma.Extracts digunakan pada saat pipeline runtime.

Baca Masukan

Tahap ReadInputs terdiri dari transformasi yang mengambil input mentah (tf.train.Example, CSV, ...) dan mengubahnya menjadi ekstrak. Hari ini ekstrak direpresentasikan sebagai byte input mentah yang disimpan di bawah tfma.INPUT_KEY , namun ekstrak dapat dalam bentuk apa pun yang kompatibel dengan pipa ekstraksi -- artinya ia membuat tfma.Extracts sebagai output, dan ekstrak tersebut kompatibel dengan hilir ekstraktor. Terserah ekstraktor yang berbeda untuk dengan jelas mendokumentasikan apa yang mereka butuhkan.

Ekstraksi

Proses ekstraksi adalah daftar beam.PTransform s yang dijalankan secara seri. Ekstraktor mengambil tfma.Extracts sebagai input dan mengembalikan tfma.Extracts sebagai output. Ekstraktor proto-tipikal adalah tfma.extractors.PredictExtractor yang menggunakan ekstrak input yang dihasilkan oleh transformasi input baca dan menjalankannya melalui model untuk menghasilkan ekstrak prediksi. Ekstraktor yang disesuaikan dapat dimasukkan kapan saja asalkan transformasinya sesuai dengan tfma.Extracts in dan tfma.Extracts out API. Sebuah extractor didefinisikan sebagai berikut:

# An Extractor is a PTransform that takes Extracts as input and returns
# Extracts as output. A typical example is a PredictExtractor that receives
# an 'input' placeholder for input and adds additional 'predictions' extracts.
Extractor = NamedTuple('Extractor', [
    ('stage_name', Text),
    ('ptransform', beam.PTransform)])  # Extracts -> Extracts

InputExtractor

tfma.extractors.InputExtractor digunakan untuk mengekstrak fitur mentah, label mentah, dan bobot contoh mentah dari catatan tf.train.Example untuk digunakan dalam pemotongan dan penghitungan metrik. Secara default, nilai disimpan di bawah features kunci ekstrak, labels , dan example_weights masing-masing. Label model keluaran tunggal dan bobot contoh disimpan langsung sebagai nilai np.ndarray . Label model multi-output dan bobot contoh disimpan sebagai dikte nilai np.ndarray (dikunci dengan nama output). Jika evaluasi multi-model dilakukan, label dan bobot contoh akan dimasukkan lebih jauh ke dalam dict lain (dikunci dengan nama model).

PredictExtractor

tfma.extractors.PredictExtractor menjalankan prediksi model dan menyimpannya di bawah predictions kunci di dict tfma.Extracts . Prediksi model keluaran tunggal disimpan langsung sebagai nilai keluaran yang diprediksi. Prediksi model multi-output disimpan sebagai dict nilai output (dikunci dengan nama output). Jika evaluasi multi-model dilakukan, prediksi akan dimasukkan lebih jauh ke dalam dict lain (dikunci dengan nama model). Nilai keluaran aktual yang digunakan bergantung pada model (misalnya keluaran kembalian penaksir TF dalam bentuk dict sedangkan keras mengembalikan nilai np.ndarray ).

SliceKeyExtractor

tfma.extractors.SliceKeyExtractor menggunakan spesifikasi slicing untuk menentukan irisan mana yang berlaku untuk setiap input contoh berdasarkan fitur yang diekstraksi dan menambahkan nilai slicing yang sesuai ke ekstrak untuk digunakan nanti oleh evaluator.

Evaluasi

Evaluasi adalah proses mengambil ekstrak dan mengevaluasinya. Meskipun biasanya melakukan evaluasi di akhir jalur ekstraksi, ada kasus penggunaan yang memerlukan evaluasi lebih awal dalam proses ekstraksi. Dengan demikian, evaluator terkait dengan ekstraktor yang outputnya harus dievaluasi. Seorang evaluator didefinisikan sebagai berikut:

# An evaluator is a PTransform that takes Extracts as input and
# produces an Evaluation as output. A typical example of an evaluator
# is the MetricsAndPlotsEvaluator that takes the 'features', 'labels',
# and 'predictions' extracts from the PredictExtractor and evaluates
# them using post export metrics to produce metrics and plots dictionaries.
Evaluator = NamedTuple('Evaluator', [
  ('stage_name', Text),
  ('run_after', Text),              # Extractor.stage_name
  ('ptransform', beam.PTransform)]) # Extracts -> Evaluation

Perhatikan bahwa evaluator adalah beam.PTransform yang mengambil tfma.Extracts sebagai input. Tidak ada yang menghentikan implementasi dari melakukan transformasi tambahan pada ekstrak sebagai bagian dari proses evaluasi. Tidak seperti ekstraktor yang harus mengembalikan dict tfma.Extracts , tidak ada batasan pada jenis output yang dapat dihasilkan oleh evaluator meskipun sebagian besar evaluator juga mengembalikan dict (misalnya nama metrik dan nilai).

MetricsAndPlotsEvaluator

tfma.evaluators.MetricsAndPlotsEvaluator mengambil features , labels , dan predictions sebagai masukan, menjalankannya melalui tfma.slicer.FanoutSlices untuk mengelompokkannya berdasarkan irisan, lalu melakukan penghitungan metrik dan plot. Ini menghasilkan output dalam bentuk kamus metrik dan kunci plot dan nilai (ini kemudian dikonversi ke proto serial untuk output oleh tfma.writers.MetricsAndPlotsWriter ).

Tulis Hasil

Tahap WriteResults adalah tempat output evaluasi ditulis ke disk. WriteResults menggunakan penulis untuk menulis data berdasarkan kunci keluaran. Misalnya, tfma.evaluators.Evaluation mungkin berisi kunci untuk metrics dan plots . Ini kemudian akan dikaitkan dengan kamus metrik dan plot yang disebut 'metrik' dan 'plot'. Penulis menentukan cara menulis setiap file:

# A writer is a PTransform that takes evaluation output as input and
# serializes the associated PCollections of data to a sink.
Writer = NamedTuple('Writer', [
  ('stage_name', Text),
  ('ptransform', beam.PTransform)])    # Evaluation -> PDone

MetricsAndPlotsWriter

Kami menyediakan tfma.writers.MetricsAndPlotsWriter yang mengubah kamus metrik dan plot menjadi proto serial dan menulisnya ke disk.

Jika Anda ingin menggunakan format serialisasi yang berbeda, Anda dapat membuat penulis kustom dan menggunakannya sebagai gantinya. Karena tfma.evaluators.Evaluation yang diteruskan ke penulis berisi output untuk semua gabungan evaluator, transformasi helper tfma.writers.Write disediakan bahwa penulis dapat menggunakan dalam implementasi ptransform mereka untuk memilih balok yang beam.PCollection s berdasarkan pada kunci output (lihat di bawah untuk contoh).

Kustomisasi

Metode tfma.run_model_analysis mengambil argumen extractors , evaluators , dan writers untuk menyesuaikan ekstraktor, evaluator, dan penulis yang digunakan oleh pipeline. Jika tidak ada argumen yang diberikan maka tfma.default_extractors , tfma.default_evaluators , dan tfma.default_writers digunakan secara default.

Ekstraktor Kustom

Untuk membuat ekstraktor kustom, buat jenis tfma.extractors.Extractor yang membungkus beam.PTransform mengambil tfma.Extracts sebagai input dan mengembalikan tfma.Extracts sebagai output. Contoh ekstraktor tersedia di bawah tfma.extractors .

Evaluator Kustom

Untuk membuat evaluator kustom, buat jenis tfma.evaluators.Evaluator yang membungkus beam.PTransform mengambil tfma.Extracts sebagai input dan mengembalikan tfma.evaluators.Evaluation sebagai output. Seorang evaluator yang sangat mendasar mungkin hanya mengambil tfma.Extracts yang masuk dan mengeluarkannya untuk disimpan dalam sebuah tabel. Inilah yang dilakukan oleh tfma.evaluators.AnalysisTableEvaluator . Evaluator yang lebih rumit mungkin melakukan pemrosesan tambahan dan agregasi data. Lihat tfma.evaluators.MetricsAndPlotsEvaluator sebagai contoh.

Perhatikan bahwa tfma.evaluators.MetricsAndPlotsEvaluator itu sendiri dapat disesuaikan untuk mendukung metrik khusus (lihat metrik untuk detail selengkapnya).

Penulis Kustom

Untuk membuat penulis kustom, buat tipe tfma.writers.Writer yang membungkus beam.PTransform mengambil tfma.evaluators.Evaluation sebagai input dan mengembalikan beam.pvalue.PDone sebagai output. Berikut ini adalah contoh dasar penulis untuk menulis TFRecords yang berisi metrik:

tfma.writers.Writer(
  stage_name='WriteTFRecord(%s)' % tfma.METRICS_KEY,
  ptransform=tfma.writers.Write(
    key=tfma.METRICS_KEY,
    ptransform=beam.io.WriteToTFRecord(file_path_prefix=output_file))

Input seorang penulis bergantung pada output dari evaluator terkait. Untuk contoh di atas, outputnya adalah proto serial yang diproduksi oleh tfma.evaluators.MetricsAndPlotsEvaluator . Seorang penulis untuk tfma.evaluators.AnalysisTableEvaluator akan bertanggung jawab untuk menulis beam.pvalue.PCollection dari tfma.Extracts .

Perhatikan bahwa penulis diasosiasikan dengan keluaran evaluator melalui kunci keluaran yang digunakan (misalnya tfma.METRICS_KEY , tfma.ANALYSIS_KEY , dll).

Contoh Langkah demi Langkah

Berikut ini adalah contoh langkah-langkah yang terlibat dalam pipa ekstraksi dan evaluasi saat tfma.evaluators.MetricsAndPlotsEvaluator dan tfma.evaluators.AnalysisTableEvaluator digunakan:

run_model_analysis(
    ...
    extractors=[
        tfma.extractors.InputExtractor(...),
        tfma.extractors.PredictExtractor(...),
        tfma.extractors.SliceKeyExtrator(...)
    ],
    evaluators=[
        tfma.evaluators.MetricsAndPlotsEvaluator(...),
        tfma.evaluators.AnalysisTableEvaluator(...)
    ])

ReadInputs

# Out
Extracts {
  'input': bytes                 # CSV, Proto, ...
}

ExtractAndEvaluate

# In:  ReadInputs Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
}

# In:  InputExtractor Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
}

# In: PredictExtractor Extracts
# Out:
Extracts {
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
  'slice_key': Tuple[bytes...]      # Slice
}

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
}

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'analysis': PCollection[Extracts] # Final Extracts
}

WriteResults

# In:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
  'analysis': PCollection[Extracts] # Final Extracts
}
# Out: metrics, plots, and analysis files