Mendapatkan prediksi batch dari model terlatih kustom

Halaman ini menunjukkan cara mendapatkan prediksi batch dari model terlatih kustom menggunakan Konsol Google Cloud atau Vertex AI API.

Untuk membuat permintaan prediksi batch, tentukan sumber input dan lokasi output, baik Cloud Storage maupun BigQuery, tempat Vertex AI menyimpan hasil prediksi.

Untuk meminimalkan waktu pemrosesan, lokasi input dan output Anda harus berada di region atau multi-region yang sama. Misalnya, jika input berada di us-central1, output dapat berada di us-central1 atau US, namun tidak di europe-west4. Untuk mempelajari lebih lanjut, lihat lokasi Cloud Storage dan lokasi BigQuery.

Input dan output Anda juga harus berada di region atau multi-region yang sama dengan model Anda.

Persyaratan data input

Input untuk permintaan batch menentukan item yang akan dikirim ke model Anda untuk mendapatkan prediksi. Kami mendukung format input berikut:

JSON Lines

Gunakan file JSON Lines untuk menentukan daftar instance input yang akan digunakan untuk membuat prediksi. Simpan file JSON Lines dalam bucket Cloud Storage.

Contoh 1

Contoh berikut menunjukkan file JSON Lines yang setiap barisnya berisi array:

[1, 2, 3, 4]
[5, 6, 7, 8]

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP:

Semua container lainnya

{"instances": [ [1, 2, 3, 4], [5, 6, 7, 8] ]}

Container PyTorch

{"instances": [
{ "data": [1, 2, 3, 4] },
{ "data": [5, 6, 7, 8] } ]}

Contoh 2

Contoh berikut menunjukkan file JSON Lines yang setiap barisnya berisi sebuah objek.

{ "values": [1, 2, 3, 4], "key": 1 }
{ "values": [5, 6, 7, 8], "key": 2 }

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP. Perhatikan bahwa isi permintaan yang sama dikirim ke semua container.

{"instances": [
  { "values": [1, 2, 3, 4], "key": 1 },
  { "values": [5, 6, 7, 8], "key": 2 }
]}

Contoh 3

Untuk container bawaan PyTorch, pastikan Anda menggabungkan setiap instance dalam kolom data seperti yang disyaratkan oleh pengendali default TorchServe; Vertex AI tidak akan menggabungkan instance untuk Anda. Contoh:

{ "data": { "values": [1, 2, 3, 4], "key": 1 } }
{ "data": { "values": [5, 6, 7, 8], "key": 2 } }

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP:

{"instances": [
  { "data": { "values": [1, 2, 3, 4], "key": 1 } },
  { "data": { "values": [5, 6, 7, 8], "key": 2 } }
]}

TFRecord

Simpan instance input dalam format TFRecord. Anda dapat memilih untuk mengompresi file TFRecord dengan Gzip. Simpan file TFRecord dalam bucket Cloud Storage.

Vertex AI membaca setiap instance dalam file TFRecord Anda sebagai biner, lalu mengenkode base64 instance sebagai objek JSON dengan satu kunci bernama b64.

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP:

Semua container lainnya

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Container PyTorch

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

Pastikan container prediksi Anda mengetahui cara men-dekode instance.

CSV

Tentukan satu instance input per baris dalam file CSV. Baris pertama harus berupa baris header. Anda harus memasukkan semua string dengan tanda kutip ganda ("). Kami tidak menerima nilai sel yang berisi karakter newline. Nilai yang tidak dikutip dibaca sebagai bilangan floating point.

Contoh berikut menunjukkan file CSV dengan dua instance input:

"input1","input2","input3"
0.1,1.2,"cat1"
4.0,5.0,"cat2"

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP:

Semua container lainnya

{"instances": [ [0.1,1.2,"cat1"], [4.0,5.0,"cat2"] ]}

Container PyTorch

{"instances": [
{ "data": [0.1,1.2,"cat1"] },
{ "data": [4.0,5.0,"cat2"] } ]}

Daftar file

Buat file teks dengan setiap baris berupa Cloud Storage URI ke file. Vertex AI membaca konten setiap file sebagai biner, lalu mengenkode base64 instance sebagai objek JSON dengan satu kunci bernama b64.

Jika Anda berencana menggunakan Konsol Google Cloud untuk mendapatkan prediksi batch, tempelkan daftar file Anda langsung ke Konsol Google Cloud. Jika tidak, simpan daftar file Anda di bucket Cloud Storage.

Contoh berikut menampilkan daftar file dengan dua instance input:

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP:

Semua container lainnya

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Container PyTorch

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

Pastikan container prediksi Anda mengetahui cara men-dekode instance.

BigQuery

Tentukan tabel BigQuery sebagai projectId.datasetId.tableId. Vertex AI mengubah setiap baris dari tabel ke instance JSON.

Misalnya, jika tabel Anda berisi data berikut:

Kolom 1 Kolom 2 Kolom 3
1.0 3.0 "Cat1"
2.0 4.0 "Cat2"

Berikut adalah hal-hal yang dikirim ke container prediksi di isi permintaan HTTP:

Semua container lainnya

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

Container PyTorch

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

Berikut cara jenis data BigQuery dikonversi ke JSON:

Jenis BigQuery Jenis JSON Nilai contoh
String String "abc"
Bilangan bulat Bilangan Bulat 1
Float Float 1,2
Angka Float 4925.000000000
Boolean Boolean benar
TimeStamp String "2019-01-01 23:59:59.999999+00:00"
Tanggal String "2018-12-31"
Waktu String "23:59:59.999999"
DateTime String "2019-01-01T00:00:00"
Record Objek { "A": 1,"B": 2}
Jenis Berulang Array[Type] [1, 2]
Kumpulan Data Bertingkat Objek {"A": {"a": 0}, "B": 1}

Data partisi

Prediksi batch menggunakan MapReduce untuk melakukan sharding input ke setiap replika. Untuk memanfaatkan fitur MapReduce, input harus dapat dipartisi.

Vertex AI secara otomatis mempartisi BigQuery, daftar file, dan input baris JSON.

Vertex AI tidak secara otomatis mempartisi file CSV karena file tersebut tidak cocok untuk partisi secara alami. Baris dalam file CSV tidak bersifat deskriptif, diketik, dan dapat berisi baris baru. Sebaiknya jangan gunakan input CSV untuk aplikasi yang sensitif dengan throughput.

Untuk input TFRecord, pastikan Anda mempartisi data secara manual dengan membagi instance menjadi file yang lebih kecil dan meneruskan file ke tugas dengan karakter pengganti (misalnya, gs://my-bucket/*.tfrecord). Jumlah file minimal harus sejumlah replika yang ditentukan.

Memfilter dan mengubah data input

Anda dapat memfilter dan/atau mengubah input batch dengan menentukan instanceConfig dalam permintaan BatchPredictionJob.

Pemfilteran memungkinkan Anda mengecualikan kolom tertentu yang ada dalam data input dari permintaan prediksi Anda, atau menyertakan hanya subset kolom dari data input dalam permintaan prediksi Anda, tanpa harus melakukan pra/pasca-pemrosesan khusus di container prediksi. Hal ini berguna saat file data input Anda memiliki kolom tambahan yang tidak diperlukan model, seperti kunci atau data tambahan.

Mentransformasi memungkinkan Anda mengirim instance ke container prediksi dalam format JSON array atau object. Lihat instanceType untuk mengetahui informasi selengkapnya.

Misalnya, jika tabel input Anda berisi data berikut:

customerId col1 col2
1001 1 2
1002 5 6

dan tentukan instanceConfig berikut:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "excludedFields":"customerId"
    "instanceType":"object"
  }
}

Kemudian, instance dalam permintaan prediksi Anda akan dikirim sebagai objek JSON, dan kolom customerId dikecualikan:

{"col1":1,"col2":2}
{"col1":5,"col2":6}

Perhatikan bahwa menentukan instanceConfig berikut akan memberikan hasil yang sama:

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "includedFields": ["col1","col2"]
    "instanceType":"object"
  }
}

Untuk demonstrasi tentang cara menggunakan filter fitur, lihat notebook Prediksi batch model kustom dengan pemfilteran fitur.

Meminta prediksi batch

Untuk permintaan prediksi batch, Anda dapat menggunakan Konsol Google Cloud atau Vertex AI API. Bergantung pada jumlah item input yang Anda kirimkan, tugas prediksi batch dapat memerlukan waktu beberapa saat untuk diselesaikan.

Saat Anda meminta prediksi batch, container prediksi akan berjalan sebagai akun layanan kustom yang disediakan pengguna. Operasi baca/tulis, seperti membaca instance prediksi dari sumber data atau menulis hasil prediksi, dilakukan menggunakan agen layanan Vertex AI, yang secara default , memiliki akses ke BigQuery dan Cloud Storage.

Konsol Google Cloud

Gunakan Konsol Google Cloud untuk meminta prediksi batch.

  1. Di Konsol Google Cloud, di bagian Vertex AI, buka halaman Batch Predictions.

Buka halaman Batch predictions

  1. Klik Create untuk membuka jendela New batch prediction.

  2. Di bagian Define your batch prediction, selesaikan langkah-langkah berikut:

    1. Masukkan nama untuk prediksi batch.

    2. Untuk Model name, pilih nama model yang akan digunakan untuk prediksi batch ini.

    3. Untuk Pilih sumber, pilih sumber yang berlaku untuk data input Anda:

      • Jika Anda telah memformat input sebagai JSON Line, CSV, atau TFRecord, pilih File on Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord Gzip). Selanjutnya, tentukan file input Anda di kolom Source path.
      • Jika Anda menggunakan daftar file sebagai input, pilih Files on Cloud Storage (other) dan tempel daftar file Anda ke kotak teks berikut.
      • Untuk input BigQuery, pilih Jalur BigQuery. Jika memilih BigQuery sebagai input, Anda juga harus memilih BigQuery sebagai output dan kunci enkripsi yang dikelola Google. Kunci enkripsi yang dikelola pelanggan (CMEK) tidak didukung dengan BigQuery sebagai input/output.

    4. Di kolom Destination path, tentukan direktori Cloud Storage tempat Anda ingin Vertex AI menyimpan output prediksi batch.

    5. Anda dapat memilih untuk mencentang Aktifkan atribusi fitur untuk model ini, agar mendapatkan atribusi fitur sebagai bagian dari respons prediksi batch. Kemudian, klik Edit untuk mengonfigurasi setelan penjelasan. (Mengedit setelan penjelasan bersifat opsional jika Anda sebelumnya mengonfigurasi setelan penjelasan untuk model, dan jika tidak diwajibkan.)

    6. Tentukan opsi komputasi untuk tugas prediksi batch: Jumlah node komputasi, Jenis Mesin, dan (opsional) Jenis akselerator dan Jumlah akselerator

  3. Opsional: Analisis Pemantauan Model untuk prediksi batch tersedia di Pratinjau. Lihat Prasyarat untuk menambahkan konfigurasi deteksi skew ke tugas prediksi batch Anda.

    1. Klik untuk mengaktifkan Enable model monitoring for this batch prediction.

    2. Pilih Training data source. Masukkan jalur data atau lokasi untuk sumber data pelatihan yang Anda pilih.

    3. Opsional: Di bagian Nilai minimum pemberitahuan, tentukan nilai minimum untuk memicu pemberitahuan.

    4. Di bagian Email notifikasi, masukkan satu atau beberapa alamat email yang dipisahkan koma, yang akan menerima pemberitahuan saat model melebihi nilai minimum pemberitahuan.

    5. Opsional: Untuk Notification channels, tambahkan saluran Cloud Monitoring untuk menerima pemberitahuan saat model melebihi nilai minimum pemberitahuan. Anda dapat memilih saluran Cloud Monitoring yang sudah ada atau membuat yang baru dengan mengklik Manage notifikasi channels. Konsol mendukung saluran notifikasi PagerDuty, Slack, dan Pub/Sub.

  4. Klik Create.

API

Gunakan Vertex AI API untuk mengirim permintaan prediksi batch. Pilih tab, bergantung pada alat yang Anda gunakan untuk mendapatkan prediksi batch:

REST

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

  • LOCATION_ID: Region tempat Model disimpan dan tugas prediksi batch dijalankan. Misalnya, us-central1.

  • PROJECT_ID: Project ID Anda.

  • BATCH_JOB_NAME: Nama tampilan untuk tugas prediksi batch.

  • MODEL_ID: ID untuk model yang akan digunakan untuk membuat prediksi.

  • INPUT_FORMAT: Format data input: jsonl, csv, tf-record, tf-record-gzip, atau file-list.

  • INPUT_URI: Cloud Storage URI data input Anda. Dapat berisi karakter pengganti.

  • OUTPUT_DIRECTORY: Cloud Storage URI dari direktori tempat Anda ingin Vertex AI menyimpan output.

  • MACHINE_TYPE: Resource mesin yang akan digunakan untuk tugas prediksi batch ini.

    Anda dapat memilih untuk mengonfigurasi kolom machineSpec untuk menggunakan akselerator, tetapi contoh berikut tidak menunjukkan hal ini.

  • BATCH_SIZE: Jumlah instance yang akan dikirim dalam setiap permintaan prediksi; default-nya adalah 64. Meningkatkan ukuran tumpukan dapat menyebabkan throughput yang lebih tinggi, tetapi juga dapat menyebabkan waktu tunggu permintaan habis.

  • STARTING_REPLICA_COUNT: Jumlah node untuk tugas prediksi batch ini.

Metode HTTP dan URL: 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Isi JSON permintaan: 

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

PowerShell

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

Anda akan menerima respons JSON yang mirip dengan yang berikut ini:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

Java

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Java Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Pada contoh berikut, ganti PREDICTIONS_FORMAT dengan jsonl. Untuk mempelajari cara mengganti placeholder lain, lihat tab REST & CMD LINE di bagian ini.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobSample(
        project,
        displayName,
        modelName,
        instancesFormat,
        gcsSourceUri,
        predictionsFormat,
        gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobSample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String gcsSourceUri,
      String predictionsFormat,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {

      // Passing in an empty Value object for model parameters
      Value modelParameters = ValueConverter.EMPTY_VALUE;

      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setGcsDestination(gcsDestination)
              .build();
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-2")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_K80)
              .setAcceleratorCount(1)
              .build();
      BatchDedicatedResources dedicatedResources =
          BatchDedicatedResources.newBuilder()
              .setMachineSpec(machineSpec)
              .setStartingReplicaCount(1)
              .setMaxReplicaCount(1)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .setDedicatedResources(dedicatedResources)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

Python

Untuk mempelajari cara menginstal atau mengupdate Vertex AI SDK untuk Python, lihat Menginstal Vertex AI SDK untuk Python. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi Python API. 

def create_batch_prediction_job_dedicated_resources_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    instances_format: str = "jsonl",
    machine_type: str = "n1-standard-2",
    accelerator_count: int = 1,
    accelerator_type: Union[str, aiplatform_v1.AcceleratorType] = "NVIDIA_TESLA_K80",
    starting_replica_count: int = 1,
    max_replica_count: int = 1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        instances_format=instances_format,
        machine_type=machine_type,
        accelerator_count=accelerator_count,
        accelerator_type=accelerator_type,
        starting_replica_count=starting_replica_count,
        max_replica_count=max_replica_count,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

Nilai penting fitur

Jika ingin nilai kepentingan fitur ditampilkan untuk prediksi, tetapkan properti generateExplanation ke true. Perhatikan bahwa model perkiraan tidak mendukung nilai penting fitur, sehingga Anda tidak dapat menyertakannya dalam permintaan prediksi batch.

Nilai penting fitur, yang terkadang disebut atribusi fitur, adalah bagian dari Vertex Explainable AI.

Anda hanya dapat menetapkan generateExplanation ke true kalau Anda telah mengonfigurasi Model untuk penjelasan atau jika Anda menentukan kolom explanationSpec BatchPredictionJob.

Pilih jenis mesin dan jumlah replika

Penskalaan secara horizontal dengan meningkatkan jumlah replika meningkatkan throughput secara lebih linear dan dapat diprediksi dibandingkan menggunakan jenis mesin yang lebih besar.

Secara umum, sebaiknya tentukan jenis mesin terkecil untuk tugas Anda dan tingkatkan jumlah replika.

Agar biaya lebih efektif, sebaiknya pilih jumlah replika sehingga tugas prediksi batch Anda akan berjalan minimal selama 10 menit. Hal ini karena Anda ditagih per jam kerja node replika, yang mencakup waktu sekitar 5 menit yang diperlukan untuk memulai setiap replika. Biaya menjadi tidak efisien apabila memproses hanya selama beberapa detik untuk kemudian dimatikan.

Sebagai panduan umum, untuk ribuan instance, sebaiknya gunakan starting_replica_count dalam puluhan. Untuk jutaan instance, sebaiknya menggunakan starting_replica_count di antara ratusan. Anda juga dapat menggunakan forumla berikut untuk memperkirakan jumlah replika:

N / (T * (60 / Tb))

Dengan keterangan:

  • N: Jumlah batch dalam tugas. Misalnya, 1 juta instance / 100 ukuran batch = 10.000 batch.
  • T: waktu yang diinginkan untuk tugas prediksi batch. Misalnya, 10 menit.
  • Tb: waktu dalam detik yang diperlukan replika untuk memproses satu batch. Misalnya, 1 detik per batch pada jenis mesin 2-core.

Dalam contoh kami, 10.000 batch / (10 menit * (60 / 1s)) membulatkan hingga 17 replika.

Tidak seperti prediksi online, tugas prediksi batch tidak melakukan penskalaan otomatis. Karena semua data input diketahui di awal, sistem akan mempartisi data tersebut ke setiap replika saat tugas dimulai. Sistem menggunakan parameter starting_replica_count; parameter max_replica_count diabaikan.

Semua rekomendasi ini merupakan panduan perkiraan. Tidak ada jaminan bahwa rekomendasi tersebut akan memberikan throughput yang optimal untuk setiap model. Perkiraan ini tidak memberikan prediksi waktu dan biaya pemrosesan yang tepat. Dan perkiraan tersebut belum tentu mencatat keuntungan biaya/kerugian throughput untuk setiap skenario. Gunakan rekomendasi tersebut sebagai titik awal yang wajar dan sesuaikan seperlunya. Untuk mengukur karakteristik seperti throughput untuk model Anda, jalankan notebook Menemukan jenis mesin yang ideal.

Untuk mesin dengan akselerasi GPU atau TPU

Ikuti panduan untuk model khusus CPU dengan pertimbangan tambahan berikut:

  • Anda mungkin memerlukan lebih banyak CPU dan GPU (misalnya untuk pra-pemrosesan data).
  • Jenis mesin GPU memerlukan waktu lebih lama untuk memulai (10 menit), jadi sebaiknya Anda menargetkan waktu yang lebih lama (misalnya, minimal 20 menit, bukan 10 menit) untuk tugas prediksi batch agar proporsi waktu dan biaya yang dihabiskan terasa wajar untuk menghasilkan prediksi.

Mengambil hasil prediksi batch

Ketika tugas prediksi batch selesai, output dari prediksi akan disimpan di bucket Cloud Storage atau lokasi BigQuery yang Anda tentukan dalam permintaan Anda.

Contoh hasil prediksi batch

Folder output berisi kumpulan file JSON Lines.

Nama filenya adalah {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. Jumlah file tidak deterministik karena sifat dari dari prediksi batch yang didistribusikan.

Setiap baris dalam file terkait dengan instance dari input dan memiliki key-value pair berikut:

  • prediction: berisi nilai yang ditampilkan oleh container prediksi.
  • instance: Untuk FileList, kode ini berisi Cloud Storage URI. Untuk semua format input lainnya, file ini berisi nilai yang dikirim ke container prediksi dalam isi permintaan HTTP.

Contoh 1

Jika permintaan HTTP berisi:

{
  "instances": [
    [1, 2, 3, 4],
    [5, 6, 7, 8]
]}

Dan container prediksi akan menampilkan:

{
  "predictions": [
    [0.1,0.9],
    [0.7,0.3]
  ],
}

Kemudian, file output jsonl berupa:

{ "instance": [1, 2, 3, 4], "prediction": [0.1,0.9]}
{ "instance": [5, 6, 7, 8], "prediction": [0.7,0.3]}

Contoh 2

Jika permintaan HTTP berisi:

{
  "instances": [
    {"values": [1, 2, 3, 4], "key": 1},
    {"values": [5, 6, 7, 8], "key": 2}
]}

Dan container prediksi akan menampilkan:

{
  "predictions": [
    {"result":1},
    {"result":0}
  ],
}

Kemudian, file output jsonl berupa:

{ "instance": {"values": [1, 2, 3, 4], "key": 1}, "prediction": {"result":1}}
{ "instance": {"values": [5, 6, 7, 8], "key": 2}, "prediction": {"result":0}}

Menggunakan Explainable AI

Sebaiknya jangan menjalankan penjelasan berbasis fitur pada data dalam jumlah besar. Hal ini karena setiap input berpotensi menyebarkan ribuan permintaan berdasarkan serangkaian nilai fitur yang memungkinkan, yang dapat mengakibatkan peningkatan waktu dan biaya pemrosesan yang sangat besar. Secara umum, {i>dataset<i} kecil sudah cukup untuk memahami nilai penting fitur.

Prediksi batch tidak mendukung penjelasan berbasis contoh.

Langkah selanjutnya