Coba model Gemini 1.5, model multimodal terbaru di Vertex AI, dan lihat model yang dapat Anda bangun dengan jendela konteks hingga 2 juta token. Coba model Gemini 1.5, model multimodal terbaru di Vertex AI, dan lihat model yang dapat Anda bangun dengan jendela konteks hingga 2 juta token.

Mengekspor model tabular AutoML

Halaman ini menjelaskan cara menggunakan Vertex AI untuk mengekspor model tabular AutoML ke Cloud Storage, mendownload model ke server lokal atau server yang dihosting oleh penyedia cloud lain, lalu menggunakan Docker untuk membuat model tersedia untuk prediksi.

Untuk mengetahui informasi tentang cara mengekspor model Edge gambar dan video, lihat Mengekspor model AutoML Edge.

Setelah mengekspor model tabular, jika Anda ingin mengimpornya kembali ke Vertex AI, lihat Mengimpor model ke Vertex AI.

Batasan

Mengekspor model tabular AutoML memiliki batasan berikut:

Anda hanya dapat mengekspor model regresi dan klasifikasi tabular AutoML. Mengekspor model perkiraan tabular AutoML tidak didukung.
Vertex Explainable AI tidak tersedia menggunakan model tabular yang diekspor. Jika perlu menggunakan Vertex Explainable AI, Anda harus menyajikan prediksi dari model yang dihosting oleh Vertex AI.
Model tabular yang diekspor hanya dapat berjalan di CPU arsitektur x86 yang mendukung set petunjuk Advanced Vector Extensions (AVX).

Proses ekspor

Berikut langkah-langkah untuk mengekspor model:

Menyiapkan lingkungan Anda
Mengekspor model
Mengambil dan menjalankan server model.
Meminta prediksi.

Sebelum memulai

Sebelum dapat menyelesaikan tugas ini, Anda harus telah menyelesaikan tugas-tugas berikut:

Siapkan project Anda seperti yang dijelaskan dalam Menyiapkan lingkungan cloud.
Latih model yang ingin didownload.
Instal dan inisialisasi Google Cloud CLI di server yang akan Anda gunakan untuk menjalankan model yang diekspor.
Instal Docker di server Anda.

Mengekspor model

Konsol

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

Buka halaman Model
Klik model tabular yang ingin diekspor untuk membuka halaman detailnya.
Klik Ekspor di panel tombol untuk mengekspor model Anda.
Pilih atau buat folder Cloud Storage di lokasi yang diinginkan.

Bucket harus memenuhi persyaratan bucket.

Anda tidak dapat mengekspor model ke bucket tingkat teratas. Anda harus menggunakan minimal satu tingkat folder.

Untuk hasil terbaik, buat folder baru yang kosong. Anda akan menyalin seluruh isi folder di langkah berikutnya.
Klik Ekspor.

Anda akan mendownload model yang diekspor ke server Anda di bagian berikutnya.

REST

Anda dapat menggunakan metode models.export untuk mengekspor model ke Cloud Storage.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

LOCATION: Region Anda.
PROJECT: Project ID Anda.
MODEL_ID: ID model yang ingin Anda ekspor.
GCS_DESTINATION : folder tujuan Anda di Cloud Storage. Contoh, gs://export-bucket/exports.
Anda tidak dapat mengekspor model ke bucket tingkat teratas. Anda harus menggunakan minimal satu tingkat folder.

Folder harus sesuai dengan persyaratan bucket.

Untuk hasil terbaik, buat folder baru. Anda akan menyalin seluruh isi folder ini di langkah berikutnya.

Metode HTTP dan URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Isi JSON permintaan:

{
  "outputConfig": {
    "exportFormatId": "tf-saved-model",
    "artifactDestination": {
      "outputUriPrefix": "GCS_DESTINATION"
    }
  }
}

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Simpan isi permintaan dalam file bernama request.json, lalu 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export"

PowerShell

Simpan isi permintaan dalam file bernama request.json, lalu 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

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

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-12T20:53:40.130785Z",
      "updateTime": "2020-10-12T20:53:40.130785Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

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.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelTabularClassificationSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String gcsDestinationOutputUriPrefix = "gs://your-gcs-bucket/destination_path";
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    exportModelTableClassification(gcsDestinationOutputUriPrefix, project, modelId);
  }

  static void exportModelTableClassification(
      String gcsDestinationOutputUriPrefix, String project, String modelId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelName modelName = ModelName.of(project, location, modelId);

      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId("tf-saved-model")
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);
      System.out.format(
          "Export Model Tabular Classification Response: %s", exportModelResponse.toString());
    }
  }
}

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 gcsDestinationOutputUriPrefix ='YOUR_GCS_DESTINATION_\
// OUTPUT_URI_PREFIX'; eg. "gs://<your-gcs-bucket>/destination_path"
// const modelId = 'YOUR_MODEL_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

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

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

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function exportModelTabularClassification() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: 'tf-saved-model',
    artifactDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  console.log(`Export model response : ${JSON.stringify(response.result)}`);
}
exportModelTabularClassification();

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.

from google.cloud import aiplatform_v1beta1

def export_model_tabular_classification_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # 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_v1beta1.ModelServiceClient(client_options=client_options)
    gcs_destination = {"output_uri_prefix": gcs_destination_output_uri_prefix}
    output_config = {
        "artifact_destination": gcs_destination,
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Mendapatkan status operasi ekspor

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 Menangani operasi yang berjalan lama.

Mengambil dan menjalankan server model

Dalam tugas ini, Anda akan mendownload model yang diekspor dari Cloud Storage dan memulai container Docker sehingga model Anda siap menerima permintaan prediksi.

Untuk mengambil dan menjalankan server model:

Di mesin tempat Anda akan menjalankan model, ubah ke direktori tempat Anda ingin menyimpan model yang diekspor.
Download model yang diekspor:
```
gsutil cp -r <var>gcs-destination</var> .
```
Dengan gcs-destination adalah jalur ke lokasi model yang diekspor di Cloud Storage.

Model disalin ke direktori Anda saat ini, di jalur berikut:

./model-<model-id>/tf-saved-model/<export-timestamp>

Jalur dapat berisi tf-saved-model atau custom-trained.
Ganti nama direktori agar stempel waktu dihapus.
```
mv model-<model-id>/tf-saved-model/<export-timestamp> model-<model-id>/tf-saved-model/<new-dir-name>
```
Stempel waktu membuat direktori tidak valid untuk Docker.
Ambil image Docker server model.
```
sudo docker pull MODEL_SERVER_IMAGE
```
Image server model yang akan diambil berada di file environment.json dalam direktori model yang diekspor. Class harus memiliki jalur berikut:

./model-<model-id>/tf-saved-model/<new-dir-name>/environment.json

Jika file environment.json tidak ada, gunakan:

MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1

Ganti MULTI_REGION dengan us, europe, atau asia untuk memilih repositori Docker yang ingin Anda ambil image Dockernya. Setiap repositori menyediakan image Docker yang sama, tetapi memilih multi-region Artifact Registry yang terdekat dengan mesin tempat Anda menjalankan Docker dapat mengurangi latensi.

Mulai container Docker menggunakan nama direktori yang baru saja Anda buat:

docker run -v `pwd`/model-<model-id>/tf-saved-model/<new-dir-name>:/models/default -p 8080:8080 -it MODEL_SERVER_IMAGE

Anda dapat menghentikan server model kapan saja menggunakan Ctrl-C.

Mengupdate container Docker server model

Karena mendownload penampung Docker server model saat mengekspor model, Anda harus secara eksplisit mengupdate server model agar mendapatkan update dan perbaikan bug. Anda harus mengupdate server model secara berkala menggunakan perintah berikut:

docker pull MODEL_SERVER_IMAGE

Pastikan URI image Docker cocok dengan URI image Docker yang Anda ambil sebelumnya.

Mendapatkan prediksi dari model yang diekspor

Server model dalam container gambar Vertex AI menangani permintaan prediksi dan menampilkan hasil prediksi.

Prediksi batch tidak tersedia untuk model yang diekspor.

Format data prediksi

Anda memberikan data (kolom payload) untuk permintaan prediksi dengan format JSON berikut:

{ "instances": [ { "column_name_1": value, "column_name_2": value, … } , … ] }

Contoh berikut menunjukkan permintaan dengan tiga kolom: kolom kategori, array numerik, dan struct. Permintaan berisi dua baris.

{
  "instances": [
    {
      "categorical_col": "mouse",
      "num_array_col": [
        1,
        2,
        3
      ],
      "struct_col": {
        "foo": "piano",
        "bar": "2019-05-17T23:56:09.05Z"
      }
    },
    {
      "categorical_col": "dog",
      "num_array_col": [
        5,
        6,
        7
      ],
      "struct_col": {
        "foo": "guitar",
        "bar": "2019-06-17T23:56:09.05Z"
      }
    }
  ]
}

Membuat permintaan prediksi

Masukkan data permintaan Anda ke dalam file teks, misalnya, tmp/request.json.

Jumlah baris data dalam permintaan prediksi, yang disebut ukuran tumpukan mini, dapat memengaruhi latensi dan throughput prediksi. Makin besar ukuran tumpukan mini, makin tinggi latensi dan throughput-nya. Untuk mengurangi latensi, gunakan ukuran tumpukan mini yang lebih kecil. Untuk meningkatkan throughput, tingkatkan ukuran tumpukan mini. Ukuran tumpukan mini yang paling umum digunakan adalah 1, 32, 64, 128, 256, 512, dan 1024.

Minta prediksi:

curl -X POST --data @/tmp/request.json http://localhost:8080/predict

Format hasil prediksi

Format hasil bergantung pada tujuan model.

Hasil model klasifikasi

Hasil prediksi untuk model klasifikasi (biner dan multi-class) akan menampilkan skor probabilitas untuk setiap nilai potensial kolom target. Anda harus menentukan cara menggunakan skor. Misalnya, untuk mendapatkan klasifikasi biner dari skor yang diberikan, tentukan nilai minimum nilai minimum data. Jika ada dua class, "A" dan "B", Anda harus mengklasifikasikan contoh sebagai "A" jika skor untuk "A" lebih besar dari nilai minimum yang dipilih, dan "B" jika tidak. Untuk set data tak seimbang, nilai minimumnya mungkin mendekati 100% atau 0%.

Payload hasil untuk model klasifikasi terlihat mirip dengan contoh ini:

{
  "predictions": [
    {
      "scores": [
        0.539999994635582,
        0.2599999845027924,
        0.2000000208627896
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    },
    {
      "scores": [
        0.23999999463558197,
        0.35999998450279236,
        0.40000002086278963
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    }
  ]
}

Hasil model regresi

Prediksi nilai ditampilkan untuk setiap baris yang valid dari permintaan prediksi. Interval prediksi tidak ditampilkan untuk model yang diekspor.

Payload hasil untuk model regresi terlihat mirip dengan contoh ini:

{
  "predictions": [
    {
      "value": -304.3663330078125,
      "lower_bound": -56.32196807861328,
      "upper_bound": 126.51904296875
    },
    {
      "value": -112.3663330078125,
      "lower_bound": 16.32196807861328,
      "upper_bound": 255.51904296875
    }
  ]
}

Langkah selanjutnya

Pelajari cara mengimpor kembali model tabular yang telah diekspor ke Vertex AI.