Mendapatkan inferensi batch dari model terlatih kustom

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

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

Batasan dan persyaratan

Pertimbangkan batasan dan persyaratan berikut saat mendapatkan inferensi batch:

• Untuk meminimalkan waktu pemrosesan, lokasi input dan output Anda harus berada di region atau multi-region yang sama. Misalnya, jika input Anda dalam us-central1, output Anda dapat dalam us-central1 atau US, tetapi tidak dalam 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.
• Model BigQuery ML bukan model yang dilatih secara kustom. Namun, informasi di halaman ini dapat digunakan untuk mendapatkan inferensi batch dari model BigQuery ML dengan kondisi berikut:
  • Model BigQuery ML harus didaftarkan ke Vertex AI Model Registry.
  • Untuk menggunakan tabel BigQuery sebagai input, Anda harus menetapkan InstanceConfig.instanceType ke "object" menggunakan Vertex AI API.
• Model inferensi batch yang dimuat akan mengalami waktu tunggu habis setelah sekitar 40 menit. Jika Anda melihat pesan error berikut, gunakan model yang lebih kecil untuk inferensi batch: Error: model server never became ready. Please validate that your model file or container configuration are valid.

Persyaratan data input

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Data partisi

Inferensi batch menggunakan MapReduce untuk membagi input ke setiap replika. Untuk memanfaatkan fitur MapReduce, input harus dapat dipartisi.

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

Vertex AI tidak otomatis mempartisi file CSV karena file tersebut tidak secara alami cocok untuk dipartisi. Baris dalam file CSV tidak menjelaskan sendiri, diketik, dan mungkin berisi baris baru. Sebaiknya jangan gunakan input CSV untuk aplikasi yang sensitif terhadap 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 harus minimal sama dengan jumlah replika yang ditentukan.

Memfilter dan mengubah data input

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

Pemfilteran memungkinkan Anda mengecualikan kolom tertentu yang ada dalam data input dari permintaan inferensi Anda, atau menyertakan hanya subset kolom dari data input dalam permintaan inferensi Anda, tanpa harus melakukan pra-pemrosesan atau pasca-pemrosesan khusus di container inferensi. 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 dalam format JSON array atau object. Lihat instanceType untuk mengetahui informasi selengkapnya.

Misalnya, jika tabel input Anda berisi data berikut:

dan tentukan instanceConfig berikut:

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

Selanjutnya, instance dalam permintaan inferensi 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 Inferensi batch model kustom dengan pemfilteran fitur.

Meminta inferensi batch

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

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

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

{
  "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,
  }
}

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"

$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

{
  "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",
}

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_T4)
              .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());
    }
  }
}

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

Pilih jenis mesin dan jumlah replika

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

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

Agar biaya lebih efektif, sebaiknya pilih jumlah replika sehingga tugas inferensi 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 gunakan starting_replica_count dalam ratusan. Anda juga dapat menggunakan formula berikut untuk memperkirakan jumlah replika:

N / (T * (60 / Tb))

Dengan:

• N: Jumlah batch dalam tugas. Misalnya, 1 juta instance / 100 ukuran batch = 10.000 batch.
• T: Perkiraan waktu untuk tugas inferensi 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 ini, 10.000 batch / (10 menit * (60 / 1 dtk)) mengumpulkan hingga 17 replika.

Tidak seperti inferensi online, tugas inferensi batch tidak melakukan penskalaan otomatis. Karena semua data input diketahui di awal, sistem memartisi data ke setiap replika saat tugas dimulai. Sistem menggunakan parameter starting_replica_count. Parameter max_replica_count diabaikan.

Semua rekomendasi ini merupakan panduan perkiraan. Rekomendasi tersebut belum tentu memberikan throughput yang optimal untuk setiap model. Perkiraan ini tidak memberikan estimasi waktu dan biaya pemrosesan yang tepat. Selain itu, perkiraan tersebut belum tentu mencatat keuntungan biaya versus throughput terbaik 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 sebelumnya (yang juga berlaku 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 inferensi batch agar proporsi waktu dan biaya yang dihabiskan terasa wajar untuk menghasilkan inferensi.

Mengambil hasil inferensi batch

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

Contoh hasil inferensi 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 inferensi 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.
• instance: Untuk daftar file, berisi Cloud Storage URI. Untuk semua format input lainnya, berisi nilai yang dikirim ke penampung dalam isi permintaan HTTP.

Contoh 1

Jika permintaan HTTP berisi:

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

Dan container akan menampilkan:

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

Kemudian, file output JSON Lines adalah:

{ "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 akan menampilkan:

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

Kemudian, file output JSON Lines adalah:

{ "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 jalankan penjelasan berbasis fitur pada data dalam jumlah besar. Hal ini karena setiap input berpotensi dipecah menjadi ribuan permintaan berdasarkan kumpulan nilai fitur yang mungkin akan menghasilkan peningkatan waktu dan biaya pemrosesan secara besar-besaran. Secara umum, set data kecil sudah cukup untuk memahami kepentingan fitur.

Inferensi batch tidak mendukung penjelasan berbasis contoh.

Notebook

Langkah berikutnya

• Pelajari Resource komputasi untuk inferensi.