Bantuan melindungi Great Barrier Reef dengan TensorFlow pada Kaggle Bergabung Tantangan

Arsitektur Analisis Model Tensorflow

Ringkasan

Pipeline TensorFlow Model Analysis (TFMA) digambarkan sebagai berikut:

Pipa TFMA

Pipa terdiri dari empat komponen utama:

  • Baca Masukan
  • Ekstraksi
  • Evaluasi
  • Tulis Hasil

Komponen-komponen ini menggunakan dua jenis utama: tfma.Extracts dan tfma.evaluators.Evaluation . Jenis tfma.Extracts mewakili data yang diekstrak selama pemrosesan pipa sedangkan jenis tfma.evaluators.Evaluation merupakan output dari mengevaluasi ekstrak pada 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 langsung mereka harus selalu pergi melalui evaluator untuk menghasilkan tfma.evaluators.Evaluation yang kemudian ditulis. Juga mencatat bahwa tfma.Extracts adalah dicts yang disimpan dalam beam.pvalue.PCollection (yaitu beam.PTransform s take sebagai masukan beam.pvalue.PCollection[tfma.Extracts] ) sedangkan tfma.evaluators.Evaluation adalah dict yang nilai yang beam.pvalue.PCollection s (yaitu beam.PTransform s mengambil dict itu sendiri sebagai argumen untuk beam.value.PCollection input). Dengan kata lain tfma.evaluators.Evaluation digunakan pada saat konstruksi pipa, tetapi tfma.Extracts digunakan pada saat runtime pipa.

Baca Masukan

The ReadInputs tahap terdiri dari transformasi yang mengambil masukan mentah (tf.train.Example, CSV, ...) dan bertobat menjadi ekstrak. Hari ini ekstrak direpresentasikan sebagai masukan baku byte disimpan di bawah tfma.INPUT_KEY , namun ekstrak bisa dalam bentuk apapun yang kompatibel dengan pipa ekstraksi - yang berarti bahwa itu menciptakan tfma.Extracts sebagai output, dan bahwa mereka ekstrak 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 dalam seri. Extractors mengambil tfma.Extracts sebagai masukan dan kembali tfma.Extracts sebagai output. The extractor proto-khas adalah tfma.extractors.PredictExtractor yang menggunakan ekstrak masukan yang dihasilkan oleh input membaca mengubah dan berjalan melalui sebuah model untuk ekstrak hasil prediksi. Extractors disesuaikan dapat dimasukkan pada setiap titik yang disediakan transformasi mereka sesuai dengan tfma.Extracts dan tfma.Extracts keluar 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

Perhatikan bahwa di luar kasus yang sangat khusus, hampir selalu terjadi bahwa salah satu tfma.Extracts di beam.pvalue.PCollection akan sesuai dengan salah satu contoh dari model.

InputExtractor

The tfma.extractors.InputExtractor digunakan untuk mengekstrak fitur baku, label baku, dan contoh baku bobot dari tf.train.Example catatan untuk menggunakan dalam metrik mengiris dan perhitungan. Secara default nilai-nilai yang disimpan di bawah kunci ekstrak features , labels , dan example_weights masing-masing. Single-Output Model label dan contoh bobot disimpan secara langsung sebagai np.ndarray nilai-nilai. Multi-Output Model label dan contoh bobot disimpan sebagai dicts dari np.ndarray nilai (mengetik 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

The tfma.extractors.PredictExtractor berjalan prediksi Model dan menyimpannya di bawah kunci predictions di tfma.Extracts dict. 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 output aktual yang digunakan tergantung pada model (misalnya TF estimator ini output kembali dalam bentuk dict sedangkan keras kembali np.ndarray nilai-nilai).

SliceKeyExtractor

The tfma.extractors.SliceKeyExtractor menggunakan mengiris spesifikasi untuk menentukan irisan berlaku untuk setiap masukan contoh berdasarkan pada fitur diekstrak dan menambahkan nilai-nilai mengiris korespondennya ke ekstrak untuk kemudian digunakan 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 masukan. Tidak ada yang menghentikan implementasi dari melakukan transformasi tambahan pada ekstrak sebagai bagian dari proses evaluasi. Tidak seperti extractors yang harus mengembalikan tfma.Extracts dict, tidak ada pembatasan pada jenis output evaluator dapat menghasilkan meskipun sebagian besar evaluator juga kembali dict (misalnya metrik nama dan nilai-nilai).

MetricsAndPlotsEvaluator

The tfma.evaluators.MetricsAndPlotsEvaluator mengambil features , labels , dan predictions sebagai input, menjalankan mereka melalui tfma.slicer.FanoutSlices untuk kelompok mereka dengan irisan, dan kemudian melakukan metrik dan plot perhitungan. Ini menghasilkan output berupa kamus metrik dan kunci plot dan nilai-nilai (ini kemudian dikonversi ke protos serial untuk output oleh tfma.writers.MetricsAndPlotsWriter ).

Tulis Hasil

The WriteResults panggung di mana output evaluasi akan ditulis ke disk. WriteResults menggunakan penulis untuk menulis data berdasarkan kunci keluaran. Sebagai contoh, sebuah 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 metrik dan plot kamus untuk protos serial dan menulis ke disk.

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

Kustomisasi

The tfma.run_model_analysis metode mengambil extractors , evaluators , dan writers argumen untuk customing extractors, evaluator, dan penulis digunakan oleh pipa. Jika tidak ada argumen yang disediakan kemudian tfma.default_extractors , tfma.default_evaluators , dan tfma.default_writers digunakan secara default.

Ekstraktor Kustom

Untuk membuat extractor kustom, membuat tfma.extractors.Extractor jenis yang membungkus beam.PTransform mengambil tfma.Extracts sebagai masukan dan kembali tfma.Extracts sebagai output. Contoh extractors tersedia di bawah tfma.extractors .

Evaluator Kustom

Untuk membuat evaluator kustom, membuat tfma.evaluators.Evaluator jenis yang membungkus beam.PTransform mengambil tfma.Extracts sebagai masukan dan kembali tfma.evaluators.Evaluation sebagai output. Sebuah evaluator sangat dasar mungkin hanya mengambil masuk tfma.Extracts dan output mereka untuk menyimpan dalam sebuah tabel. Ini adalah persis apa yang tfma.evaluators.AnalysisTableEvaluator tidak. 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 dukungan metrik kustom (lihat metrik untuk lebih jelasnya).

Penulis Kustom

Untuk membuat penulis kustom, membuat tfma.writers.Writer jenis yang membungkus beam.PTransform taking tfma.evaluators.Evaluation sebagai masukan dan kembali 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, output adalah proto serial yang diproduksi oleh tfma.evaluators.MetricsAndPlotsEvaluator . Seorang penulis untuk tfma.evaluators.AnalysisTableEvaluator akan bertanggung jawab untuk menulis sebuah beam.pvalue.PCollection dari tfma.Extracts .

Perhatikan bahwa penulis dikaitkan dengan output dari sebuah evaluator melalui tombol output 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 ketika kedua 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