Mendapatkan prediksi dari model deteksi objek image

Halaman ini menunjukkan cara mendapatkan prediksi online (real-time) dan prediksi batch dari model deteksi objek gambar menggunakan konsol Google Cloud atau Vertex AI API.

Perbedaan antara prediksi online dan batch

Prediksi online adalah permintaan sinkron yang dibuat ke endpoint model. Gunakan prediksi online saat Anda membuat permintaan sebagai respons terhadap input aplikasi atau dalam situasi yang memerlukan inferensi tepat waktu.

Prediksi batch adalah permintaan asinkron. Anda meminta prediksi batch secara langsung dari resource model tanpa perlu men-deploy model ke endpoint. Untuk data gambar, gunakan prediksi batch jika Anda tidak memerlukan respons langsung dan ingin memproses data yang terakumulasi menggunakan satu permintaan.

Mendapatkan prediksi online

Men-deploy model ke endpoint

Anda harus men-deploy model ke endpoint sebelum model tersebut dapat digunakan untuk menyajikan prediksi online. Men-deploy model akan mengaitkan resource fisik dengan model tersebut, sehingga dapat menyajikan prediksi online dengan latensi rendah.

Anda dapat men-deploy lebih dari satu model ke satu endpoint, dan dapat men-deploy model ke beberapa endpoint. Untuk mengetahui informasi selengkapnya tentang opsi dan kasus penggunaan untuk men-deploy model, lihat Tentang men-deploy model.

Gunakan salah satu metode berikut ini untuk men-deploy model:

Konsol Google Cloud

  1. Di konsol Google Cloud, di bagian Vertex AI, buka halaman Model.

    Buka halaman Model

  2. Klik nama model yang ingin di-deploy untuk membuka halaman detailnya.

  3. Pilih tab Deploy & Uji.

    Jika model Anda sudah di-deploy ke endpoint, model tersebut akan tercantum di bagian Deploy model Anda.

  4. Klik Deploy ke endpoint.

  5. Untuk men-deploy model ke endpoint baru, pilih Buat endpoint baru, lalu berikan nama untuk endpoint baru tersebut. Untuk men-deploy model ke endpoint yang ada, pilih Tambah ke endpoint yang ada, lalu pilih endpoint dari menu drop-down.

    Anda dapat menambahkan beberapa model ke satu endpoint, dan Anda dapat menambahkan satu model ke beberapa endpoint. Pelajari lebih lanjut.

  6. Jika Anda men-deploy model ke endpoint yang sudah ada dan memiliki satu atau beberapa model yang di-deploy, Anda harus memperbarui persentase Pemisahan traffic untuk model yang sedang di-deploy dan model yang sudah di-deploy, sehingga jumlah semua persentasenya menjadi 100%.

  7. Pilih Image AutoML dan konfigurasi sebagai berikut:

    1. Jika Anda men-deploy model ke endpoint baru, terima nilai 100 untuk Pemisahan traffic. Jika tidak, sesuaikan nilai pemisahan traffic untuk semua model di endpoint sehingga jumlahnya menjadi 100.

    2. Masukkan Number of computer nodes yang ingin diberikan untuk model Anda.

      Ini adalah jumlah node yang selalu tersedia untuk model ini. Anda akan dikenai biaya untuk node tersebut, meski tanpa traffic prediksi. Lihat halaman harga.

    3. Pelajari cara mengubah setelan default untuk logging prediksi.

    4. Khusus model klasifikasi (opsional): Di bagian Explainability options, pilih Enable feature attributions for this model guna mengaktifkan Vertex Explainable AI. Terima visualization settings yang ada atau pilih nilai baru, lalu klik Done.

      Men-deploy model klasifikasi gambar AutoML dengan Vertex Explainable AI yang dikonfigurasi dan melakukan prediksi dengan penjelasan bersifat opsional. Mengaktifkan Vertex Explainable AI pada waktu deployment akan menimbulkan biaya tambahan berdasarkan jumlah node yang di-deploy dan waktu deployment. Lihat Harga untuk informasi selengkapnya.

    5. Klik Done untuk model Anda, dan jika semua persentase Pemisahan traffic sudah benar, klik Continue.

      Region tempat model Anda men-deploy ditampilkan. Area ini harus menjadi region tempat Anda membuat model.

    6. Klik Deploy untuk men-deploy model Anda ke endpoint.

API

Saat men-deploy model menggunakan Vertex AI API, Anda harus menyelesaikan langkah-langkah berikut:

  1. Buat endpoint jika perlu.
  2. Dapatkan ID endpoint.
  3. Deploy model ke endpoint.

Membuat endpoint

Jika Anda men-deploy model ke endpoint yang ada, Anda dapat melewati langkah ini.

gcloud

Contoh berikut menggunakan perintah gcloud ai endpoints create:

gcloud ai endpoints create \
  --region=LOCATION \
  --display-name=ENDPOINT_NAME

Ganti kode berikut:

  • LOCATION_ID: Region tempat Anda menggunakan Vertex AI.
  • ENDPOINT_NAME: Nama tampilan endpoint.

Alat Google Cloud CLI mungkin memerlukan waktu beberapa detik untuk membuat endpoint.

REST

Sebelum menggunakan data permintaan mana pun, lakukan penggantian berikut:

  • LOCATION_ID: Region Anda.
  • PROJECT_ID: Project ID Anda.
  • ENDPOINT_NAME: Nama tampilan endpoint.

Metode HTTP dan URL: 

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

Meminta isi JSON: 

{
  "display_name": "ENDPOINT_NAME"
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

Anda akan melihat respons JSON seperti berikut:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}
Anda dapat melakukan polling untuk status operasi hingga respons menyertakan "done": true.

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, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

Node.js

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

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

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

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_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

Mengambil ID endpoint

Anda memerlukan ID endpoint untuk men-deploy model.

gcloud

Contoh berikut menggunakan perintah gcloud ai endpoints list:

gcloud ai endpoints list \
  --region=LOCATION \
  --filter=display_name=ENDPOINT_NAME

Ganti kode berikut:

  • LOCATION_ID: Region tempat Anda menggunakan Vertex AI.
  • ENDPOINT_NAME: Nama tampilan endpoint.

Perhatikan angka yang muncul di kolom ENDPOINT_ID. Gunakan ID ini dalam langkah berikut.

REST

Sebelum menggunakan data permintaan mana pun, lakukan penggantian berikut:

  • LOCATION_ID: Region tempat Anda menggunakan Vertex AI.
  • PROJECT_ID: Project ID Anda.
  • ENDPOINT_NAME: Nama tampilan endpoint.

Metode HTTP dan URL: 

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

Untuk mengirim permintaan, perluas salah satu opsi berikut:

Anda akan melihat respons JSON seperti berikut:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}
Perhatikan ENDPOINT_ID.

Men-deploy model

Pilih tab di bawah ini untuk bahasa atau lingkungan Anda:

gcloud

Contoh berikut menggunakan perintah gcloud ai endpoints deploy-model.

Contoh berikut men-deploy Model ke Endpoint tanpa membagi traffic antara beberapa resource DeployedModel:

Sebelum menggunakan salah satu data perintah di bawah, lakukan penggantian berikut:

  • ENDPOINT_ID: ID untuk endpoint.
  • LOCATION_ID: Region tempat Anda menggunakan Vertex AI.
  • MODEL_ID: ID untuk model yang akan di-deploy.
  • DEPLOYED_MODEL_NAME: Nama untuk DeployedModel. Anda juga dapat menggunakan nama tampilan Model untuk DeployedModel.
  • MIN_REPLICA_COUNT: Jumlah minimum node untuk deployment ini. Jumlah node dapat ditingkatkan atau diturunkan sesuai kebutuhan beban prediksi, hingga mencapai jumlah maksimum node dan tidak pernah kurang dari jumlah ini.
  • MAX_REPLICA_COUNT: Jumlah maksimum node untuk deployment ini. Jumlah node dapat ditingkatkan atau diturunkan sesuai kebutuhan beban prediksi, hingga mencapai jumlah maksimum node dan tidak pernah kurang dari jumlah ini. Jika Anda menghapus tanda --max-replica-count, jumlah maksimum node akan ditetapkan ke nilai --min-replica-count.

Jalankan perintah gcloud ai endpoints deploy-model:

Linux, macOS, atau Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100
  

Membagi traffic

Flag --traffic-split=0=100 pada contoh sebelumnya mengirim 100% traffic prediksi yang diterima Endpoint ke DeployedModel baru, yang diwakili oleh ID sementara 0. Jika Endpoint sudah memiliki resource DeployedModel lain, Anda dapat membagi traffic antara DeployedModel baru dan yang lama. Misalnya, untuk mengirim 20% traffic ke DeployedModel baru dan 80% traffic ke yang lebih lama, jalankan perintah berikut.

Sebelum menggunakan salah satu data perintah di bawah, lakukan penggantian berikut:

  • OLD_DEPLOYED_MODEL_ID: ID DeployedModel yang ada.

Jalankan perintah gcloud ai endpoints deploy-model:

Linux, macOS, atau Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80
  

REST

Men-deploy model.

Sebelum menggunakan data permintaan mana pun, lakukan penggantian berikut:

  • LOCATION_ID: Region tempat Anda menggunakan Vertex AI.
  • PROJECT_ID: Project ID Anda.
  • ENDPOINT_ID: ID untuk endpoint tersebut.
  • MODEL_ID: ID untuk model yang akan di-deploy.
  • DEPLOYED_MODEL_NAME: Nama untuk DeployedModel. Anda juga dapat menggunakan nama tampilan Model untuk DeployedModel.
  • MIN_REPLICA_COUNT: Jumlah minimum node untuk deployment ini. Jumlah node dapat ditingkatkan atau diturunkan sesuai kebutuhan beban prediksi, hingga mencapai jumlah maksimum node dan tidak pernah kurang dari jumlah ini.
  • MAX_REPLICA_COUNT: Jumlah maksimum node untuk deployment ini. Jumlah node dapat ditingkatkan atau diturunkan sesuai kebutuhan beban prediksi, hingga mencapai jumlah maksimum node dan tidak pernah kurang dari jumlah ini.
  • TRAFFIC_SPLIT_THIS_MODEL: Persentase traffic prediksi ke endpoint ini yang akan dirutekan ke model yang di-deploy dengan operasi ini. Setelan defaultnya adalah 100. Semua persentase traffic harus berjumlah 100. Pelajari pemisahan traffic lebih lanjut.
  • DEPLOYED_MODEL_ID_N: Opsional. Jika model lain di-deploy ke endpoint ini, Anda harus memperbarui persentase pemisahan traffic agar semua persentase berjumlah 100.
  • TRAFFIC_SPLIT_MODEL_N: Nilai persentase pemisahan traffic untuk kunci ID model yang di-deploy.
  • PROJECT_NUMBER: Nomor project yang dibuat secara otomatis untuk project Anda

Metode HTTP dan URL: 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

Meminta isi JSON: 

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "automaticResources": {
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT
     }
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

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

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

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, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.api.gax.longrunning.OperationTimedPollAlgorithm;
import com.google.api.gax.retrying.RetrySettings;
import com.google.cloud.aiplatform.v1.AutomaticResources;
import com.google.cloud.aiplatform.v1.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.stub.EndpointServiceStubSettings;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.threeten.bp.Duration;

public class DeployModelSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String deployedModelDisplayName = "YOUR_DEPLOYED_MODEL_DISPLAY_NAME";
    String endpointId = "YOUR_ENDPOINT_NAME";
    String modelId = "YOUR_MODEL_ID";
    int timeout = 900;
    deployModelSample(project, deployedModelDisplayName, endpointId, modelId, timeout);
  }

  static void deployModelSample(
      String project,
      String deployedModelDisplayName,
      String endpointId,
      String modelId,
      int timeout)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {

    // Set long-running operations (LROs) timeout
    final OperationTimedPollAlgorithm operationTimedPollAlgorithm =
        OperationTimedPollAlgorithm.create(
            RetrySettings.newBuilder()
                .setInitialRetryDelay(Duration.ofMillis(5000L))
                .setRetryDelayMultiplier(1.5)
                .setMaxRetryDelay(Duration.ofMillis(45000L))
                .setInitialRpcTimeout(Duration.ZERO)
                .setRpcTimeoutMultiplier(1.0)
                .setMaxRpcTimeout(Duration.ZERO)
                .setTotalTimeout(Duration.ofSeconds(timeout))
                .build());

    EndpointServiceStubSettings.Builder endpointServiceStubSettingsBuilder =
        EndpointServiceStubSettings.newBuilder();
    endpointServiceStubSettingsBuilder
        .deployModelOperationSettings()
        .setPollingAlgorithm(operationTimedPollAlgorithm);
    EndpointServiceStubSettings endpointStubSettings = endpointServiceStubSettingsBuilder.build();
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.create(endpointStubSettings);
    endpointServiceSettings =
        endpointServiceSettings.toBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      EndpointName endpointName = EndpointName.of(project, location, endpointId);
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      ModelName modelName = ModelName.of(project, location, modelId);
      AutomaticResources automaticResourcesInput =
          AutomaticResources.newBuilder().setMinReplicaCount(1).setMaxReplicaCount(1).build();
      DeployedModel deployedModelInput =
          DeployedModel.newBuilder()
              .setModel(modelName.toString())
              .setDisplayName(deployedModelDisplayName)
              .setAutomaticResources(automaticResourcesInput)
              .build();

      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> deployModelResponseFuture =
          endpointServiceClient.deployModelAsync(endpointName, deployedModelInput, trafficSplit);
      System.out.format(
          "Operation name: %s\n", deployModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      DeployModelResponse deployModelResponse = deployModelResponseFuture.get(20, TimeUnit.MINUTES);

      System.out.println("Deploy Model Response");
      DeployedModel deployedModel = deployModelResponse.getDeployedModel();
      System.out.println("\tDeployed Model");
      System.out.format("\t\tid: %s\n", deployedModel.getId());
      System.out.format("\t\tmodel: %s\n", deployedModel.getModel());
      System.out.format("\t\tDisplay Name: %s\n", deployedModel.getDisplayName());
      System.out.format("\t\tCreate Time: %s\n", deployedModel.getCreateTime());

      DedicatedResources dedicatedResources = deployedModel.getDedicatedResources();
      System.out.println("\t\tDedicated Resources");
      System.out.format("\t\t\tMin Replica Count: %s\n", dedicatedResources.getMinReplicaCount());

      MachineSpec machineSpec = dedicatedResources.getMachineSpec();
      System.out.println("\t\t\tMachine Spec");
      System.out.format("\t\t\t\tMachine Type: %s\n", machineSpec.getMachineType());
      System.out.format("\t\t\t\tAccelerator Type: %s\n", machineSpec.getAcceleratorType());
      System.out.format("\t\t\t\tAccelerator Count: %s\n", machineSpec.getAcceleratorCount());

      AutomaticResources automaticResources = deployedModel.getAutomaticResources();
      System.out.println("\t\tAutomatic Resources");
      System.out.format("\t\t\tMin Replica Count: %s\n", automaticResources.getMinReplicaCount());
      System.out.format("\t\t\tMax Replica Count: %s\n", automaticResources.getMaxReplicaCount());
    }
  }
}

Node.js

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

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

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const modelId = "YOUR_MODEL_ID";
// const endpointId = 'YOUR_ENDPOINT_ID';
// const deployedModelDisplayName = 'YOUR_DEPLOYED_MODEL_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

const modelName = `projects/${project}/locations/${location}/models/${modelId}`;
const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint:
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function deployModel() {
  // Configure the parent resource
  // key '0' assigns traffic for the newly deployed model
  // Traffic percentage values must add up to 100
  // Leave dictionary empty if endpoint should not accept any traffic
  const trafficSplit = {0: 100};
  const deployedModel = {
    // format: 'projects/{project}/locations/{location}/models/{model}'
    model: modelName,
    displayName: deployedModelDisplayName,
    automaticResources: {minReplicaCount: 1, maxReplicaCount: 1},
  };
  const request = {
    endpoint,
    deployedModel,
    trafficSplit,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.deployModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Deploy model response');
  const modelDeployed = result.deployedModel;
  console.log('\tDeployed model');
  if (!modelDeployed) {
    console.log('\t\tId : {}');
    console.log('\t\tModel : {}');
    console.log('\t\tDisplay name : {}');
    console.log('\t\tCreate time : {}');

    console.log('\t\tDedicated resources');
    console.log('\t\t\tMin replica count : {}');
    console.log('\t\t\tMachine spec {}');
    console.log('\t\t\t\tMachine type : {}');
    console.log('\t\t\t\tAccelerator type : {}');
    console.log('\t\t\t\tAccelerator count : {}');

    console.log('\t\tAutomatic resources');
    console.log('\t\t\tMin replica count : {}');
    console.log('\t\t\tMax replica count : {}');
  } else {
    console.log(`\t\tId : ${modelDeployed.id}`);
    console.log(`\t\tModel : ${modelDeployed.model}`);
    console.log(`\t\tDisplay name : ${modelDeployed.displayName}`);
    console.log(`\t\tCreate time : ${modelDeployed.createTime}`);

    const dedicatedResources = modelDeployed.dedicatedResources;
    console.log('\t\tDedicated resources');
    if (!dedicatedResources) {
      console.log('\t\t\tMin replica count : {}');
      console.log('\t\t\tMachine spec {}');
      console.log('\t\t\t\tMachine type : {}');
      console.log('\t\t\t\tAccelerator type : {}');
      console.log('\t\t\t\tAccelerator count : {}');
    } else {
      console.log(
        `\t\t\tMin replica count : \
          ${dedicatedResources.minReplicaCount}`
      );
      const machineSpec = dedicatedResources.machineSpec;
      console.log('\t\t\tMachine spec');
      console.log(`\t\t\t\tMachine type : ${machineSpec.machineType}`);
      console.log(
        `\t\t\t\tAccelerator type : ${machineSpec.acceleratorType}`
      );
      console.log(
        `\t\t\t\tAccelerator count : ${machineSpec.acceleratorCount}`
      );
    }

    const automaticResources = modelDeployed.automaticResources;
    console.log('\t\tAutomatic resources');
    if (!automaticResources) {
      console.log('\t\t\tMin replica count : {}');
      console.log('\t\t\tMax replica count : {}');
    } else {
      console.log(
        `\t\t\tMin replica count : \
          ${automaticResources.minReplicaCount}`
      );
      console.log(
        `\t\t\tMax replica count : \
          ${automaticResources.maxReplicaCount}`
      );
    }
  }
}
deployModel();

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 deploy_model_with_automatic_resources_sample(
    project,
    location,
    model_name: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

    aiplatform.init(project=project, location=location)

    model = aiplatform.Model(model_name=model_name)

    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

Pelajari cara mengubah setelan default untuk logging prediksi.

Mendapatkan status operasi

Beberapa permintaan memulai operasi yang berjalan lama, yang memerlukan waktu beberapa saat untuk selesai. Permintaan ini menampilkan nama operasi, yang dapat Anda gunakan untuk melihat status operasi atau membatalkan operasi. Vertex AI menyediakan metode helper untuk melakukan panggilan terhadap operasi yang berjalan lama. Untuk mengetahui informasi selengkapnya, lihat Bekerja dengan operasi yang berjalan lama.

Membuat prediksi online menggunakan model yang di-deploy

Untuk membuat prediksi online, kirimkan satu atau beberapa item pengujian ke sebuah model untuk dianalisis, dan model ini akan menampilkan hasil yang didasarkan pada objektif model Anda. Untuk mengetahui informasi selengkapnya tentang hasil prediksi, lihat halaman Menafsirkan hasil.

Konsol

Menggunakan Konsol Google Cloud untuk meminta prediksi online. Model Anda harus di-deploy ke endpoint.

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

    Buka halaman Models

  2. Dari daftar model, klik nama model yang akan diminta prediksinya.

  3. Pilih tab Deploy & test.

  4. Di bagian Test your model, tambahkan item pengujian untuk meminta prediksi.

    Model AutoML untuk tujuan gambar mengharuskan Anda mengupload gambar untuk meminta prediksi.

    Untuk informasi tentang pentingnya fitur lokal, lihat Mendapatkan penjelasan.

    Setelah prediksi selesai, Vertex AI akan menampilkan hasilnya di konsol.

API

Gunakan Vertex AI API untuk meminta prediksi online. Model Anda harus di-deploy ke endpoint.

Objektif jenis data image mencakup klasifikasi dan deteksi objek.

Prediksi model edge: Saat menggunakan model Edge image AutoML untuk prediksi, Anda harus mengonversi file prediksi non-JPEG menjadi file JPEG sebelum mengirim permintaan prediksi.

gcloud

  1. Buat file bernama request.json dengan konten berikut:

    {
  "instances": [{
    "content": "CONTENT"
  }],
  "parameters": {
    "confidenceThreshold": THRESHOLD_VALUE,
    "maxPredictions": MAX_PREDICTIONS
  }
}

    Ganti kode berikut:

    • CONTENT: Konten image yang dienkode base64.
    • THRESHOLD_VALUE Opsional: Model hanya menampilkan prediksi yang memiliki skor keyakinan dengan minimal nilai ini.
    • MAX_PREDICTIONS Opsional: Model menampilkan hasil prediksi hingga sebanyak ini dengan skor keyakinan tertinggi.

  2. Jalankan perintah berikut:

    gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json

    Ganti kode berikut:

    • ENDPOINT_ID: ID untuk endpoint.
    • LOCATION_ID: Region tempat Anda menggunakan Vertex AI.

REST

Sebelum menggunakan data permintaan mana pun, lakukan penggantian berikut:

  • LOCATION_ID: Region tempat Endpoint berada. Misalnya, us-central1.
  • PROJECT_ID: Project ID Anda.
  • ENDPOINT_ID: ID untuk endpoint tersebut.
  • CONTENT: Konten image yang dienkode base64.
  • THRESHOLD_VALUE Opsional: Model hanya menampilkan prediksi yang memiliki skor keyakinan dengan minimal nilai ini.
  • MAX_PREDICTIONS Opsional: Model menampilkan hasil prediksi hingga sebanyak ini dengan skor keyakinan tertinggi.

Metode HTTP dan URL: 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict

Isi JSON permintaan: 

{
  "instances": [{
    "content": "CONTENT"
  }],
  "parameters": {
    "confidenceThreshold": THRESHOLD_VALUE,
    "maxPredictions": MAX_PREDICTIONS
  }
}

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/endpoints/ENDPOINT_ID:predict"

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/endpoints/ENDPOINT_ID:predict" | Select-Object -Expand Content

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

{
  "predictions": [
    {
      "confidences": [
        0.975873291,
        0.972160876,
        0.879488528,
        0.866532683,
        0.686478078
      ],
      "displayNames": [
        "Salad",
        "Salad",
        "Tomato",
        "Tomato",
        "Salad"
      ],
      "ids": [
        "7517774415476555776",
        "7517774415476555776",
        "2906088397049167872",
        "2906088397049167872",
        "7517774415476555776"
      ],
      "bboxes": [
        [
          0.0869686604,
          0.977020741,
          0.395135701,
          1
        ],
        [
          0,
          0.488701463,
          0.00157663226,
          0.512249
        ],
        [
          0.361617863,
          0.509664357,
          0.772928834,
          0.914706349
        ],
        [
          0.310678929,
          0.45781514,
          0.565507233,
          0.711237729
        ],
        [
          0.584359646,
          1,
          0.00116168708,
          0.130817384
        ]
      ]
    }
  ],
  "deployedModelId": "3860570043075002368"
}

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, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 


import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.instance.ImageObjectDetectionPredictionInstance;
import com.google.cloud.aiplatform.v1.schema.predict.params.ImageObjectDetectionPredictionParams;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.ImageObjectDetectionPredictionResult;
import com.google.protobuf.Value;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;

public class PredictImageObjectDetectionSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String fileName = "YOUR_IMAGE_FILE_PATH";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictImageObjectDetection(project, fileName, endpointId);
  }

  static void predictImageObjectDetection(String project, String fileName, String endpointId)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(settings)) {
      String location = "us-central1";
      EndpointName endpointName = EndpointName.of(project, location, endpointId);

      byte[] contents = Base64.getEncoder().encode(Files.readAllBytes(Paths.get(fileName)));
      String content = new String(contents, StandardCharsets.UTF_8);

      ImageObjectDetectionPredictionParams params =
          ImageObjectDetectionPredictionParams.newBuilder()
              .setConfidenceThreshold((float) (0.5))
              .setMaxPredictions(5)
              .build();

      ImageObjectDetectionPredictionInstance instance =
          ImageObjectDetectionPredictionInstance.newBuilder().setContent(content).build();

      List<Value> instances = new ArrayList<>();
      instances.add(ValueConverter.toValue(instance));

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, ValueConverter.toValue(params));
      System.out.println("Predict Image Object Detection Response");
      System.out.format("\tDeployed Model Id: %s\n", predictResponse.getDeployedModelId());

      System.out.println("Predictions");
      for (Value prediction : predictResponse.getPredictionsList()) {

        ImageObjectDetectionPredictionResult.Builder resultBuilder =
            ImageObjectDetectionPredictionResult.newBuilder();

        ImageObjectDetectionPredictionResult result =
            (ImageObjectDetectionPredictionResult)
                ValueConverter.fromValue(resultBuilder, prediction);

        for (int i = 0; i < result.getIdsCount(); i++) {
          System.out.printf("\tDisplay name: %s\n", result.getDisplayNames(i));
          System.out.printf("\tConfidences: %f\n", result.getConfidences(i));
          System.out.printf("\tIDs: %d\n", result.getIds(i));
          System.out.printf("\tBounding boxes: %s\n", result.getBboxes(i));
        }
      }
    }
  }
}

Node.js

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

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

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const filename = "YOUR_PREDICTION_FILE_NAME";
// const endpointId = "YOUR_ENDPOINT_ID";
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {instance, params, prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction Service Client library
const {PredictionServiceClient} = aiplatform.v1;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictImageObjectDetection() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;

  const parametersObj = new params.ImageObjectDetectionPredictionParams({
    confidenceThreshold: 0.5,
    maxPredictions: 5,
  });
  const parameters = parametersObj.toValue();

  const fs = require('fs');
  const image = fs.readFileSync(filename, 'base64');
  const instanceObj = new instance.ImageObjectDetectionPredictionInstance({
    content: image,
  });

  const instanceVal = instanceObj.toValue();
  const instances = [instanceVal];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict image object detection response');
  console.log(`\tDeployed model id : ${response.deployedModelId}`);
  const predictions = response.predictions;
  console.log('Predictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.ImageObjectDetectionPredictionResult.fromValue(
        predictionResultVal
      );
    for (const [i, label] of predictionResultObj.displayNames.entries()) {
      console.log(`\tDisplay name: ${label}`);
      console.log(`\tConfidences: ${predictionResultObj.confidences[i]}`);
      console.log(`\tIDs: ${predictionResultObj.ids[i]}`);
      console.log(`\tBounding boxes: ${predictionResultObj.bboxes[i]}\n\n`);
    }
  }
}
predictImageObjectDetection();

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. 

import base64

from google.cloud import aiplatform
from google.cloud.aiplatform.gapic.schema import predict


def predict_image_object_detection_sample(
    project: str,
    endpoint_id: str,
    filename: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.PredictionServiceClient(client_options=client_options)
    with open(filename, "rb") as f:
        file_content = f.read()

    # The format of each instance should conform to the deployed model's prediction input schema.
    encoded_content = base64.b64encode(file_content).decode("utf-8")
    instance = predict.instance.ImageObjectDetectionPredictionInstance(
        content=encoded_content,
    ).to_value()
    instances = [instance]
    # See gs://google-cloud-aiplatform/schema/predict/params/image_object_detection_1.0.0.yaml for the format of the parameters.
    parameters = predict.params.ImageObjectDetectionPredictionParams(
        confidence_threshold=0.5,
        max_predictions=5,
    ).to_value()
    endpoint = client.endpoint_path(
        project=project, location=location, endpoint=endpoint_id
    )
    response = client.predict(
        endpoint=endpoint, instances=instances, parameters=parameters
    )
    print("response")
    print(" deployed_model_id:", response.deployed_model_id)
    # See gs://google-cloud-aiplatform/schema/predict/prediction/image_object_detection_1.0.0.yaml for the format of the predictions.
    predictions = response.predictions
    for prediction in predictions:
        print(" prediction:", dict(prediction))

Mendapatkan prediksi batch

Untuk membuat permintaan prediksi batch, tentukan sumber input dan format output tempat Vertex AI menyimpan hasil prediksi. Prediksi batch untuk jenis model gambar AutoML memerlukan file JSON Lines input dan nama bucket Cloud Storage untuk menyimpan output.

Persyaratan data input

Input untuk permintaan batch menentukan item yang akan dikirim ke model Anda untuk mendapatkan prediksi. Untuk model deteksi objek image, Anda dapat menggunakan file JSON Lines untuk menentukan daftar image yang akan dibuat prediksi, kemudian menyimpan file JSON Lines tersebut dalam bucket Cloud Storage. Contoh berikut menunjukkan satu baris dalam file JSON Lines input:

{"content": "gs://sourcebucket/datasets/images/source_image.jpg", "mimeType": "image/jpeg"}

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.

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 Prediksi batch

  2. Klik Create untuk membuka jendela New batch predictions dan 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 Source path, tentukan lokasi Cloud Storage tempat file input JSON Lines Anda berada.
    4. Untuk Destination path, tentukan lokasi Cloud Storage tempat hasil prediksi batch disimpan. Format Output ditentukan oleh tujuan model Anda. Model AutoML untuk tujuan gambar menghasilkan file JSON Lines.

API

Gunakan Vertex AI API untuk mengirim permintaan prediksi batch.

REST

Sebelum menggunakan data permintaan apa pun, buat pengganti 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 batch
  • MODEL_ID: ID yang akan digunakan oleh model untuk membuat prediksi
  • THRESHOLD_VALUE (opsional): Vertex AI hanya menampilkan prediksi yang memiliki skor keyakinan dengan nilai minimal ini. Dafaultnya adalah 0.0.
  • MAX_PREDICTIONS (opsional): Vertex AI menampilkan prediksi hingga sebanyak ini dimulai dengan prediksi yang memiliki skor keyakinan tertinggi. Defaultnya adalah 10.
  • URI: Cloud Storage URI tempat file JSON Lines input Anda berada.
  • BUCKET: Bucket Cloud Storage Anda
  • PROJECT_NUMBER: Nomor project yang dibuat secara otomatis untuk project Anda

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/locations/LOCATION/models/MODEL_ID",
    "modelParameters": {
      "confidenceThreshold": THRESHOLD_VALUE,
      "maxPredictions": MAX_PREDICTIONS
    },
    "inputConfig": {
        "instancesFormat": "jsonl",
        "gcsSource": {
            "uris": ["URI"],
        },
    },
    "outputConfig": {
        "predictionsFormat": "jsonl",
        "gcsDestination": {
            "outputUriPrefix": "OUTPUT_BUCKET",
        },
    },
}

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 seperti berikut:

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

Anda dapat melakukan polling untuk status tugas batch menggunakan BATCH_JOB_ID hingga state tugas menjadi JOB_STATE_SUCCEEDED.

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_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    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,
        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

Mengambil hasil prediksi batch

Vertex AI mengirimkan output prediksi batch ke tujuan yang Anda tentukan.

Ketika tugas prediksi batch selesai, output prediksi disimpan di bucket Cloud Storage yang Anda tentukan dalam permintaan Anda.

Contoh hasil prediksi batch

Berikut ini contoh hasil prediksi batch dari model deteksi objek image.

Penting: Kotak pembatas ditentukan sebagai:

"bboxes": [ [xMin, xMax, yMin, yMax], ...]

Dengan xMin dan xMax adalah nilai x minimum dan maksimum, serta yMin dan yMax masing-masing adalah nilai y minimum dan maksimum. 

{
  "instance": {"content": "gs://bucket/image.jpg", "mimeType": "image/jpeg"},
  "prediction": {
    "ids": [1, 2],
    "displayNames": ["cat", "dog"],
    "bboxes":  [
      [0.1, 0.2, 0.3, 0.4],
      [0.2, 0.3, 0.4, 0.5]
    ],
    "confidences": [0.7, 0.5]
  }
}

Sebelumnya
Evaluasi model
Berikutnya
Menafsirkan Hasil