Komponen fungsi Python khusus

Definisi komponen berbasis fungsi Python memudahkan Anda membuat komponen khusus TFX, dengan menghemat upaya Anda dalam menentukan kelas spesifikasi komponen, kelas eksekutor, dan kelas antarmuka komponen. Dalam gaya definisi komponen ini, Anda menulis fungsi yang dianotasi dengan petunjuk tipe. Petunjuk jenis menjelaskan artefak masukan, artefak keluaran, dan parameter komponen Anda.

Menulis komponen kustom Anda dengan gaya ini sangat mudah, seperti pada contoh berikut.

class MyOutput(TypedDict):
  accuracy: float

@component
def MyValidationComponent(
    model: InputArtifact[Model],
    blessing: OutputArtifact[Model],
    accuracy_threshold: Parameter[int] = 10,
) -> MyOutput:
  '''My simple custom model validation component.'''

  accuracy = evaluate_model(model)
  if accuracy >= accuracy_threshold:
    write_output_blessing(blessing)

  return {
    'accuracy': accuracy
  }

Di bawah tenda, ini mendefinisikan komponen khusus yang merupakan subkelas dari BaseComponent dan kelas Spec dan Executornya.

Catatan: fitur (komponen berbasis BaseBeamComponent dengan memberi anotasi fungsi dengan @component(use_beam=True) ) yang dijelaskan di bawah ini bersifat eksperimental dan tidak ada jaminan kompatibilitas mundur publik.

Jika Anda ingin mendefinisikan subkelas BaseBeamComponent sehingga Anda dapat menggunakan pipa balok dengan konfigurasi bersama berdasarkan pipa TFX, yaitu beam_pipeline_args saat mengkompilasi pipa ( Contoh Pipa Taksi Chicago ) Anda dapat mengatur use_beam=True di dekorator dan menambahkan BeamComponentParameter lain dengan nilai default None di fungsi Anda seperti contoh berikut:

@component(use_beam=True)
def MyDataProcessor(
    examples: InputArtifact[Example],
    processed_examples: OutputArtifact[Example],
    beam_pipeline: BeamComponentParameter[beam.Pipeline] = None,
    ) -> None:
  '''My simple custom model validation component.'''

  with beam_pipeline as p:
    # data pipeline definition with beam_pipeline begins
    ...
    # data pipeline definition with beam_pipeline ends

Jika Anda baru mengenal saluran pipa TFX, pelajari lebih lanjut tentang konsep inti saluran pipa TFX .

Input, output, dan parameter

Di TFX, input dan output dilacak sebagai objek Artefak yang mendeskripsikan lokasi dan properti metadata yang terkait dengan data yang mendasarinya; informasi ini disimpan dalam Metadata ML. Artefak dapat mendeskripsikan tipe data kompleks atau tipe data sederhana, seperti: int, float, byte, atau string unicode.

Parameter adalah argumen (int, float, bytes, atau string unicode) ke komponen yang diketahui pada waktu konstruksi pipeline. Parameter berguna untuk menentukan argumen dan hyperparameter seperti jumlah iterasi pelatihan, tingkat dropout, dan konfigurasi lainnya pada komponen Anda. Parameter disimpan sebagai properti eksekusi komponen saat dilacak di Metadata ML.

Catatan: Saat ini, nilai tipe data keluaran sederhana tidak dapat digunakan sebagai parameter karena nilai tersebut tidak diketahui pada waktu eksekusi. Demikian pula, nilai tipe data input sederhana saat ini tidak dapat mengambil nilai konkret yang diketahui pada waktu konstruksi pipa. Kami dapat menghapus pembatasan ini pada rilis TFX mendatang.

Definisi

Untuk membuat komponen khusus, tulis fungsi yang mengimplementasikan logika khusus Anda dan hiasi dengan dekorator @component dari modul tfx.dsl.component.experimental.decorators . Untuk menentukan skema input dan output komponen Anda, beri anotasi pada argumen fungsi Anda dan kembalikan nilai menggunakan anotasi dari modul tfx.dsl.component.experimental.annotations :

• Untuk setiap artefak input , terapkan anotasi petunjuk jenis InputArtifact[ArtifactType] . Ganti ArtifactType dengan tipe artefak, yang merupakan subkelas dari tfx.types.Artifact . Masukan ini dapat berupa argumen opsional.

• Untuk setiap artefak keluaran , terapkan anotasi petunjuk tipe OutputArtifact[ArtifactType] . Ganti ArtifactType dengan tipe artefak, yang merupakan subkelas dari tfx.types.Artifact . Artefak keluaran komponen harus diteruskan sebagai argumen masukan fungsi, sehingga komponen Anda dapat menulis keluaran ke lokasi yang dikelola sistem dan menyetel properti metadata artefak yang sesuai. Argumen ini bisa opsional atau argumen ini bisa didefinisikan dengan nilai default.

• Untuk setiap parameter , gunakan anotasi petunjuk tipe Parameter[T] . Ganti T dengan tipe parameternya. Saat ini kami hanya mendukung tipe python primitif: bool , int , float , str , atau bytes .

• Untuk beam pipeline , gunakan anotasi petunjuk tipe BeamComponentParameter[beam.Pipeline] . Tetapkan nilai default menjadi None . Nilai None akan digantikan oleh beam pipeline yang dibuat oleh _make_beam_pipeline() dari BaseBeamExecutor

• Untuk setiap input tipe data sederhana ( int , float , str atau bytes ) yang tidak diketahui pada waktu konstruksi pipa, gunakan petunjuk tipe T . Perhatikan bahwa dalam rilis TFX 0.22, nilai konkrit tidak dapat diteruskan pada waktu konstruksi pipa untuk jenis masukan ini (gunakan anotasi Parameter , seperti yang dijelaskan di bagian sebelumnya). Argumen ini bisa opsional atau argumen ini bisa didefinisikan dengan nilai default. Jika komponen Anda memiliki keluaran tipe data sederhana ( int , float , str atau bytes ), Anda dapat mengembalikan keluaran ini dengan menggunakan TypedDict sebagai anotasi tipe kembalian, dan mengembalikan objek dict yang sesuai.

Di badan fungsi Anda, artefak input dan output diteruskan sebagai objek tfx.types.Artifact ; Anda dapat memeriksa .uri -nya untuk mendapatkan lokasi yang dikelola sistem dan membaca/mengatur properti apa pun. Parameter masukan dan masukan tipe data sederhana diteruskan sebagai objek dengan tipe tertentu. Output tipe data sederhana harus dikembalikan sebagai kamus, dengan kunci adalah nama output yang sesuai dan nilainya adalah nilai kembalian yang diinginkan.

Komponen fungsi yang telah selesai dapat terlihat seperti ini:

from typing import TypedDict
import tfx.v1 as tfx
from tfx.dsl.component.experimental.decorators import component

class MyOutput(TypedDict):
  loss: float
  accuracy: float

@component
def MyTrainerComponent(
    training_data: tfx.dsl.components.InputArtifact[tfx.types.standard_artifacts.Examples],
    model: tfx.dsl.components.OutputArtifact[tfx.types.standard_artifacts.Model],
    dropout_hyperparameter: float,
    num_iterations: tfx.dsl.components.Parameter[int] = 10
) -> MyOutput:
  '''My simple trainer component.'''

  records = read_examples(training_data.uri)
  model_obj = train_model(records, num_iterations, dropout_hyperparameter)
  model_obj.write_to(model.uri)

  return {
    'loss': model_obj.loss,
    'accuracy': model_obj.accuracy
  }

# Example usage in a pipeline graph definition:
# ...
trainer = MyTrainerComponent(
    examples=example_gen.outputs['examples'],
    dropout_hyperparameter=other_component.outputs['dropout'],
    num_iterations=1000)
pusher = Pusher(model=trainer.outputs['model'])
# ...

Contoh sebelumnya mendefinisikan MyTrainerComponent sebagai komponen kustom berbasis fungsi Python. Komponen ini menggunakan examples artefak sebagai masukannya, dan menghasilkan artefak model sebagai keluarannya. Komponen menggunakan artifact_instance.uri untuk membaca atau menulis artefak di lokasi yang dikelola sistemnya. Komponen mengambil parameter masukan num_iterations dan nilai tipe data sederhana dropout_hyperparameter , dan komponen mengeluarkan metrik loss dan accuracy sebagai nilai keluaran tipe data sederhana. Artefak model keluaran kemudian digunakan oleh komponen Pusher .