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 beberapa model ke satu endpoint, dan Anda dapat men-deploy satu model ke beberapa endpoint. Untuk mengetahui informasi selengkapnya tentang opsi dan kasus penggunaan untuk men-deploy model, lihat Alasan men-deploy lebih dari satu model ke endpoint yang sama di bawah ini.

Men-deploy model ke endpoint

Gunakan salah satu metode berikut 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 dan ID versi model yang ingin Anda 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 to endpoint.

  5. Untuk men-deploy model ke endpoint baru, pilih Buat endpoint baru, dan beri nama untuk endpoint baru tersebut. Untuk men-deploy model ke endpoint yang ada, pilih Add to existing endpoint, lalu pilih endpoint dari menu drop-down.

    Anda dapat menambahkan lebih dari satu model ke endpoint dan dapat menambahkan model ke lebih dari satu endpoint.

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

  7. 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.

  8. Masukkan Jumlah minimum node komputasi yang ingin Anda berikan untuk model Anda.

    Jumlah minimum merupakan jumlah node yang selalu tersedia untuk model setiap saat.

    Anda akan dikenai biaya untuk node yang digunakan, baik untuk menangani beban prediksi maupun untuk node standby (minimum) meskipun tanpa traffic prediksi. Lihat halaman harga.

    Jumlah node komputasi dapat meningkat jika diperlukan untuk menangani traffic prediksi, tetapi tidak akan pernah melebihi jumlah maksimum node.

  9. Untuk menggunakan penskalaan otomatis, masukkan Jumlah maksimum node komputasi yang Anda inginkan untuk ditingkatkan skalanya oleh Vertex AI.

  10. Pilih Jenis mesin.

    Resource mesin yang lebih besar akan meningkatkan performa prediksi dan meningkatkan biaya. Bandingkan jenis mesin yang tersedia.

  11. Pilih Jenis akselerator dan Jumlah akselerator.

    Jika Anda mengaktifkan penggunaan akselerator saat mengimpor atau membuat model, opsi ini akan ditampilkan.

    Untuk mengetahui jumlah akselerator, lihat tabel GPU untuk memeriksa jumlah GPU yang valid yang dapat Anda gunakan dengan setiap jenis mesin CPU. Jumlah akselerator mengacu pada jumlah akselerator per node, bukan total jumlah akselerator dalam deployment Anda.

  12. Jika Anda ingin menggunakan akun layanan kustom untuk deployment, pilih akun layanan di kotak drop-down Akun layanan.

  13. Pelajari cara mengubah setelan default untuk logging prediksi.

  14. Klik Selesai untuk model Anda, dan jika semua persentase Pemisahan traffic sudah benar, klik Lanjutkan.

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

  15. 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. Create endpoint jika diperlukan.
  2. Get ID endpoint.
  3. Deploy model ke endpoint.

Membuat endpoint

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

gcloud

Contoh berikut menggunakan perintah gcloud ai endpoints create:

gcloud ai endpoints create \
  --region=LOCATION_ID \
  --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 salah satu data permintaan, 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.

Terraform

Contoh berikut menggunakan resource Terraform google_vertex_ai_endpoint untuk membuat endpoint.

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

# Endpoint name must be unique for the project
resource "random_id" "endpoint_id" {
  byte_length = 4
}

resource "google_vertex_ai_endpoint" "default" {
  name         = substr(random_id.endpoint_id.dec, 0, 10)
  display_name = "sample-endpoint"
  description  = "A sample Vertex AI endpoint"
  location     = "us-central1"
  labels = {
    label-one = "value-one"
  }
}

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. 


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, baca 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_ID \
  --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 salah satu data permintaan, 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 menggunakan GPU untuk mempercepat inferensi prediksi dan tanpa membagi traffic antara beberapa resource DeployedModel:

Sebelum menggunakan data perintah mana pun di bawah ini, 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 endpoint 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 endpoint 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 salah satu data permintaan, 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.
  • MACHINE_TYPE: Opsional. Resource mesin yang digunakan untuk setiap node deployment ini. Setelan defaultnya adalah n1-standard-2. Pelajari jenis-jenis mesin lebih lanjut.
  • ACCELERATOR_TYPE: Jenis akselerator yang akan dipasang ke mesin. Opsional jika ACCELERATOR_COUNT tidak ditentukan atau nol. Tidak direkomendasikan untuk model AutoML atau model yang dilatih secara khusus yang menggunakan image non-GPU. Pelajari lebih lanjut.
  • ACCELERATOR_COUNT: Jumlah akselerator untuk setiap replika yang akan digunakan. Opsional. Harus nol atau tidak ditentukan untuk model AutoML atau model yang dilatih secara khusus yang menggunakan image non-GPU.
  • MIN_REPLICA_COUNT: Jumlah minimum node untuk deployment ini. Jumlah node dapat ditambah atau dikurangi sesuai kebutuhan oleh beban prediksi hingga mencapai jumlah maksimum node, dan node tidak pernah kurang dari jumlah ini. Nilai ini harus lebih besar dari atau sama dengan 1.
  • 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/locations/us-central1/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "dedicatedResources": {
       "machineSpec": {
         "machineType": "MACHINE_TYPE",
         "acceleratorType": "ACCELERATOR_TYPE",
         "acceleratorCount": "ACCELERATOR_COUNT"
       },
       "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/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, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

import com.google.api.gax.longrunning.OperationFuture;
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 java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class DeployModelCustomTrainedModelSample {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String endpointId = "ENDPOINT_ID";
    String modelName = "MODEL_NAME";
    String deployedModelDisplayName = "DEPLOYED_MODEL_DISPLAY_NAME";
    deployModelCustomTrainedModelSample(project, endpointId, modelName, deployedModelDisplayName);
  }

  static void deployModelCustomTrainedModelSample(
      String project, String endpointId, String model, String deployedModelDisplayName)
      throws IOException, ExecutionException, InterruptedException {
    EndpointServiceSettings settings =
        EndpointServiceSettings.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 (EndpointServiceClient client = EndpointServiceClient.create(settings)) {
      MachineSpec machineSpec = MachineSpec.newBuilder().setMachineType("n1-standard-2").build();
      DedicatedResources dedicatedResources =
          DedicatedResources.newBuilder().setMinReplicaCount(1).setMachineSpec(machineSpec).build();

      String modelName = ModelName.of(project, location, model).toString();
      DeployedModel deployedModel =
          DeployedModel.newBuilder()
              .setModel(modelName)
              .setDisplayName(deployedModelDisplayName)
              // `dedicated_resources` must be used for non-AutoML models
              .setDedicatedResources(dedicatedResources)
              .build();
      // 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);
      EndpointName endpoint = EndpointName.of(project, location, endpointId);
      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> response =
          client.deployModelAsync(endpoint, deployedModel, trafficSplit);

      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Operation name: %s\n", response.getInitialFuture().get().getName());

      // OperationFuture.get() will block until the operation is finished.
      DeployModelResponse deployModelResponse = response.get();
      System.out.format("deployModelResponse: %s\n", deployModelResponse);
    }
  }
}

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_dedicated_resources_sample(
    project,
    location,
    model_name: str,
    machine_type: 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,
    accelerator_type: Optional[str] = None,
    accelerator_count: Optional[int] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    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)

    # The explanation_metadata and explanation_parameters should only be
    # provided for a custom trained model and not an AutoML model.
    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        machine_type=machine_type,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

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

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

const automl = require('@google-cloud/automl');
const client = new automl.v1beta1.AutoMlClient();

/**
 * Demonstrates using the AutoML client to create a model.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const datasetId = '[DATASET_ID]' e.g., "TBL2246891593778855936";
// const tableId = '[TABLE_ID]' e.g., "1991013247762825216";
// const columnId = '[COLUMN_ID]' e.g., "773141392279994368";
// const modelName = '[MODEL_NAME]' e.g., "testModel";
// const trainBudget = '[TRAIN_BUDGET]' e.g., "1000",
// `Train budget in milli node hours`;

// A resource that represents Google Cloud Platform location.
const projectLocation = client.locationPath(projectId, computeRegion);

// Get the full path of the column.
const columnSpecId = client.columnSpecPath(
  projectId,
  computeRegion,
  datasetId,
  tableId,
  columnId
);

// Set target column to train the model.
const targetColumnSpec = {name: columnSpecId};

// Set tables model metadata.
const tablesModelMetadata = {
  targetColumnSpec: targetColumnSpec,
  trainBudgetMilliNodeHours: trainBudget,
};

// Set datasetId, model name and model metadata for the dataset.
const myModel = {
  datasetId: datasetId,
  displayName: modelName,
  tablesModelMetadata: tablesModelMetadata,
};

// Create a model with the model metadata in the region.
client
  .createModel({parent: projectLocation, model: myModel})
  .then(responses => {
    const initialApiResponse = responses[1];
    console.log(`Training operation name: ${initialApiResponse.name}`);
    console.log('Training started...');
  })
  .catch(err => {
    console.error(err);
  });

Pelajari cara mengubah setelan default untuk logging prediksi.

Mendapatkan status operasi

Beberapa permintaan memulai operasi yang berjalan lama dan memerlukan waktu beberapa saat untuk diselesaikan. 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.

Batasan

  • Jika Anda mengaktifkan Kontrol Layanan VPC, container model yang di-deploy tidak akan memiliki akses ke internet.

Mengonfigurasi deployment model

Selama deployment model, Anda membuat keputusan penting berikut terkait cara menjalankan prediksi online:

Resource yang dibuat Setelan yang ditentukan saat pembuatan resource
Endpoint Lokasi tempat menjalankan prediksi
Model Container yang akan digunakan (ModelContainerSpec)
DeployedModel Mesin yang akan digunakan untuk prediksi online

Anda tidak dapat memperbarui setelan yang tercantum di atas setelah pembuatan awal model atau endpoint, dan Anda tidak dapat menggantinya dalam permintaan prediksi online. Jika perlu mengubah setelan ini, Anda harus men-deploy ulang model.

Yang terjadi saat Anda men-deploy model

Saat men-deploy model ke endpoint, Anda harus menghubungkan resource fisik (mesin) dengan model tersebut agar dapat memberikan prediksi online. Prediksi online memiliki persyaratan latensi rendah. Menyediakan resource ke model terlebih dahulu akan mengurangi latensi.

Jenis pelatihan model (AutoML atau kustom) dan jenis data (AutoML) menentukan jenis resource fisik yang tersedia untuk model. Setelah deployment model, Anda dapat mutate beberapa resource tersebut tanpa harus membuat deployment baru.

Resource endpoint menyediakan endpoint layanan (URL) yang Anda gunakan untuk meminta prediksi. Contoh:

https://us-central1-aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/endpoints/{endpoint}:predict

Alasan untuk men-deploy lebih dari satu model ke endpoint yang sama

Dengan men-deploy dua model ke endpoint yang sama, Anda dapat mengganti satu model dengan model lainnya secara bertahap. Misalnya, Anda sedang menggunakan suatu model, dan menemukan cara untuk meningkatkan akurasi model tersebut dengan data pelatihan baru. Namun, Anda tidak ingin mengupdate aplikasi agar mengarah ke URL endpoint baru, dan tidak ingin membuat perubahan tiba-tiba dalam aplikasi. Anda dapat menambahkan model baru ke endpoint yang sama, menyalurkan sebagian kecil traffic, dan meningkatkan pemisahan traffic untuk model baru secara bertahap hingga model tersebut menyalurkan semua traffic.

Karena resource dikaitkan dengan model, bukan endpoint, Anda dapat men-deploy model dari berbagai jenis ke endpoint yang sama. Namun, praktik terbaiknya adalah men-deploy model dari jenis tertentu (misalnya, AutoML, Text AutoML Tabular, dilatih khusus) ke endpoint. Konfigurasi ini lebih mudah dikelola.

Alasan untuk men-deploy model ke lebih dari satu endpoint

Anda mungkin ingin men-deploy model dengan resource yang berbeda untuk lingkungan aplikasi yang berbeda, seperti pengujian dan produksi. Anda mungkin juga ingin mendukung SLO yang berbeda untuk permintaan prediksi Anda. Mungkin salah satu aplikasi Anda memiliki kebutuhan performa yang jauh lebih tinggi daripada yang lain. Dalam hal ini, Anda dapat men-deploy model tersebut ke endpoint berperforma lebih tinggi dengan lebih banyak resource mesin. Untuk mengoptimalkan biaya, Anda juga dapat men-deploy model ke endpoint berperforma lebih rendah dengan resource mesin yang lebih sedikit.

Perilaku penskalaan

Saat men-deploy Model untuk prediksi online sebagai DeployedModel, Anda dapat mengonfigurasi node prediksi agar diskalakan secara otomatis. Untuk melakukannya, tetapkan dedicatedResources.maxReplicaCount ke nilai yang lebih besar dari dedicatedResources.minReplicaCount.

Saat mengonfigurasi DeployedModel, Anda harus menetapkan dedicatedResources.minReplicaCount setidaknya ke nilai 1. Dengan kata lain, Anda tidak dapat mengonfigurasi DeployedModel untuk diskalakan ke node prediksi 0 jika tidak digunakan.

Target pemanfaatan dan konfigurasi

Secara default, jika Anda men-deploy model tanpa resource GPU khusus, Vertex AI akan otomatis meningkatkan atau memperkecil skala jumlah replika sehingga penggunaan CPU cocok dengan nilai target default 60%.

Secara default, jika Anda men-deploy model dengan resource GPU khusus (jika machineSpec.accelerator_count di atas 0), Vertex AI akan secara otomatis meningkatkan atau memperkecil skala jumlah replika sehingga penggunaan CPU atau GPU, mana yang lebih tinggi, cocok dengan nilai target default 60%. Oleh karena itu, jika throughput prediksi Anda menyebabkan penggunaan GPU yang tinggi, tetapi tidak menggunakan CPU yang tinggi, Vertex AI akan meningkatkan skala dan penggunaan CPU akan menjadi sangat rendah sehingga terlihat dalam pemantauan. Sebaliknya, jika container kustom Anda kurang memanfaatkan GPU, tetapi memiliki proses tidak terkait yang meningkatkan penggunaan CPU di atas 60%, Vertex AI akan meningkatkan skala meskipun hal ini mungkin tidak diperlukan untuk mencapai QPS dan target latensi.

Anda dapat mengganti metrik dan target nilai minimum default dengan menentukan autoscalingMetricSpecs. Perlu diperhatikan bahwa jika deployment Anda dikonfigurasi untuk diskalakan hanya berdasarkan penggunaan CPU, deployment tidak akan ditingkatkan skalanya meskipun penggunaan GPU tinggi.

Mengelola penggunaan resource

Anda dapat memantau endpoint untuk melacak metrik seperti penggunaan CPU dan Akselerator, jumlah permintaan, latensi, serta jumlah replika saat ini dan target. Informasi ini dapat membantu Anda memahami penggunaan resource dan perilaku penskalaan endpoint.

Perlu diingat bahwa setiap replika hanya menjalankan satu container. Artinya, jika container prediksi tidak dapat sepenuhnya memanfaatkan resource komputasi yang dipilih, seperti kode thread tunggal untuk mesin multi-core, atau model kustom yang memanggil layanan lain sebagai bagian dari pembuatan prediksi , node Anda mungkin tidak akan meningkat skalanya.

Misalnya, jika Anda menggunakan FastAPI, atau server model apa pun yang memiliki jumlah worker atau thread yang dapat dikonfigurasi, ada banyak kasus ketika memiliki lebih dari satu worker dapat meningkatkan pemanfaatan resource sehingga dapat meningkatkan kemampuan layanan untuk menskalakan jumlah replika secara otomatis.

Kami biasanya merekomendasikan untuk memulai dengan satu worker atau thread per core. Jika Anda melihat bahwa pemakaian CPU rendah, terutama saat beban tinggi, atau skala model Anda tidak ditingkatkan karena penggunaan CPU rendah, tingkatkan jumlah worker. Di sisi lain, jika Anda melihat bahwa pemakaian terlalu tinggi dan latensi meningkat lebih dari yang diharapkan berdasarkan beban, coba gunakan lebih sedikit worker. Jika Anda hanya menggunakan satu worker, coba gunakan jenis mesin yang lebih kecil.

Perilaku penskalaan dan jeda

Vertex AI menyesuaikan jumlah replika setiap 15 detik menggunakan data dari periode 5 menit sebelumnya. Untuk setiap siklus 15 detik, sistem akan mengukur penggunaan server dan menghasilkan jumlah target replika berdasarkan formula berikut:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

Misalnya, jika saat ini Anda memiliki dua replika yang digunakan hingga 100%, targetnya adalah 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

Contoh lain, jika saat ini Anda memiliki 10 replika dan pemakaian menurun menjadi 1%, targetnya adalah 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

Di akhir setiap siklus 15 detik, sistem akan menyesuaikan jumlah replika agar cocok dengan nilai target tertinggi dari periode 5 menit sebelumnya. Perhatikan bahwa karena nilai target tertinggi dipilih, endpoint Anda tidak akan diperkecil skalanya jika ada lonjakan penggunaan selama periode 5 menit tersebut meskipun pemanfaatan secara keseluruhan sangat rendah. Di sisi lain, jika sistem perlu ditingkatkan skalanya, sistem akan melakukannya dalam waktu 15 detik karena yang dipilih adalah nilai target tertinggi, bukan rata-rata.

Perlu diingat bahwa meskipun Vertex AI menyesuaikan jumlah replika, perlu waktu untuk memulai atau menonaktifkan replika. Dengan demikian, ada jeda tambahan sebelum endpoint dapat menyesuaikan dengan traffic. Faktor utama yang memengaruhi situasi ini mencakup:

  • waktu untuk menyediakan dan memulai VM Compute Engine
  • waktu untuk mendownload container dari registry
  • waktu untuk memuat model dari penyimpanan

Cara terbaik untuk memahami perilaku penskalaan yang sebenarnya dari model Anda adalah dengan menjalankan uji beban dan mengoptimalkan karakteristik yang penting bagi model dan kasus penggunaan Anda. Jika autoscaler tidak meningkatkan skala aplikasi Anda dengan cukup cepat, sediakan min_replicas yang cukup untuk menangani traffic dasar pengukuran yang Anda harapkan.

Memperbarui konfigurasi penskalaan

Jika Anda menentukanDedicatedResources atau AutomaticResources saat men-deploy model, Anda dapat memperbarui konfigurasi penskalaan tanpa harus men-deploy ulang model dengan memanggil mutateDeployedModel.

Misalnya, permintaan berikut memperbarui max_replica, autoscaling_metric_specs, dan menonaktifkan logging container.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

Catatan penggunaan:

  • Anda tidak dapat mengubah jenis mesin atau beralih dari DedicatedResources ke AutomaticResources atau sebaliknya. Satu-satunya kolom konfigurasi penskalaan yang dapat Anda ubah adalah: min_replica, max_replica, dan AutoscalingMetricSpec (khusus DedicatedResources).
  • Anda harus mencantumkan setiap kolom yang ingin diperbarui di updateMask. Kolom yang tidak tercantum akan diabaikan.
  • DeployedModel harus dalam status DEPLOYED. Hanya boleh ada maksimal satu operasi mutasi aktif per model yang di-deploy.
  • mutateDeployedModel juga memungkinkan Anda mengaktifkan atau menonaktifkan logging container. Untuk mengetahui informasi selengkapnya, lihat Logging prediksi online.

Langkah selanjutnya