Menganalisis log AI Platform Prediction di BigQuery

Last reviewed 2021-03-12 UTC

---

Dokumen ini adalah seri kedua yang menunjukkan cara memantau model machine learning (ML) yang di-deploy ke AI Platform Prediction untuk membantu Anda mendeteksi kecondongan data. Panduan ini menunjukkan cara mengurai data mentah di log respons permintaan AI Platform Prediction menjadi model data analisis. Kemudian, codelab akan menunjukkan cara menggunakan Looker Studio untuk menganalisis permintaan yang dicatat dalam log untuk diferesiansi dan penyimpangan data.

Seri ini ditujukan untuk data scientist dan engineer MLOps yang ingin mempertahankan performa model ML mereka dalam produksi dengan memantau perubahan data penayangan dari waktu ke waktu. Anda dianggap memiliki pengalaman dengan Google Cloud, BigQuery, dan notebook Jupyter.

Rangkaian ini terdiri dari panduan berikut:

• Logging permintaan penyaluran menggunakan AI Platform Prediction
• Menganalisis log di BigQuery (dokumen ini)
• Menganalisis diferensiasi server pelatihan dengan Validasi Data TensorFlow
• Mengotomatiskan deteksi diferensiasi performa server pelatihan
• Mengidentifikasi diferensiasi performa pelatihan dan penyajian dengan deteksi kebaruan

Tugas-tugas yang dibahas dalam dokumen ini dimasukkan ke dalam Jupyter notebooks. Notebook ini berada di repositori GitHub.

Ringkasan

Seperti yang dibahas di bagian satu dari seri ini, kode di notebook Jupyter melatih model klasifikasi Keras untuk set data Covertype untuk memprediksi jenis tutupan hutan dari variabel kartografi. SavedModel yang diekspor kemudian di-deploy ke AI Platform Prediction untuk penayangan online. Notebook ini juga memungkinkan logging permintaan respons untuk mencatat sampel permintaan (instance) dan respons prediksi online ke dalam log (probabilitas label yang diprediksi) ke tabel BigQuery .

Keseluruhan arsitektur ditampilkan dalam diagram berikut:

Dalam arsitektur ini, logging respons permintaan AI Platform Prediction mencatat sampel permintaan online ke dalam tabel BigQuery. Setelah instance mentah dan data prediksi disimpan di BigQuery, Anda dapat mengurai data ini, menghitung statistik deskriptif, dan memvisualisasikan kecondongan data serta penyimpangan data.

Tabel berikut merangkum skema tabel BigQuery.

Nama kolom	Jenis	Mode	Deskripsi
model	STRING	REQUIRED	Nama model
model_version	STRING	REQUIRED	Nama versi model
time	TIMESTAMP	REQUIRED	Tanggal dan waktu permintaan diambil
raw_data	STRING	REQUIRED	Isi permintaan dalam representasi JSON Prediksi AI Platform
raw_prediction	STRING	NULLABLE	Isi respons (prediksi) dalam representasi JSON prediksi AI Platform
groundtruth	STRING	NULLABLE	Kebenaran dasar jika tersedia

Tabel berikut menunjukkan contoh data yang tersimpan di kolom raw_data dan raw_prediction pada tabel BigQuery.

Kolom	Data sampel
raw_data	{ "signature_name":"serving_default", "instances":[ { "Elevation":[3158], "Aspect":[78], "Slope":[25], "Horizontal_Distance_To_Hydrology":[150], "Vertical_Distance_To_Hydrology":[53], "Horizontal_Distance_To_Roadways":[1080], "Hillshade_9am":[243], "Hillshade_Noon":[185], "Hillshade_3pm":[57], "Horizontal_Distance_To_Fire_Points":[2234], "Wilderness_Area":["Rawah"], "Soil_Type":["7745"], } ] }
raw_prediction	{ "predictions": [ { "probabilities": [ 0.03593460097908974, 0.9640452861785889, 1.2815438710234162e-9, 1.5712469103590365e-9, 0.000018715836631599814, 4.030006106603423e-9, 0.0000013792159734293818 ], "confidence": 0.9640452861785889, "predicted_label": "1" } ] }

Dalam dokumen ini, Anda mengurai kolom raw_data menjadi model analisis sehingga Anda dapat menganalisis konten setiap fitur secara terpisah dan mengidentifikasi setiap kecondongan data.

Tujuan

• Buat metadata untuk set data.
• Buat pernyataan CREATE VIEW SQL yang spesifik untuk set data.
• Menggunakan tampilan untuk mengkueri data log di BigQuery.
• Buat visualisasi data log.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

• Notebook yang Dikelola Pengguna Vertex AI Workbench
• BigQuery
• AI Platform Prediction
• Cloud Storage

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Sebelum memulai

Sebelum memulai, Anda harus menyelesaikan bagian satu dari seri ini.

Setelah menyelesaikan bagian pertama, Anda memiliki hal berikut:\

• Instance notebook yang dikelola pengguna Vertex AI Workbench yang menggunakan TensorFlow 2.3.
• Clone repositori GitHub yang di dalamnya terdapat notebook Jupyter yang Anda butuhkan untuk panduan ini.

Notebook Jupyter untuk skenario ini

Tugas untuk mengurai dan menganalisis data digabungkan ke dalam notebook Jupyter yang ada di repositori GitHub. Untuk melakukan tugas, Anda akan mendapatkan notebook lalu mengeksekusi sel kode di notebook secara berurutan.

Dalam dokumen ini, Anda menggunakan notebook Jupyter untuk melakukan tugas-tugas berikut:

• Buat tampilan BigQuery SQL untuk mengurai titik data permintaan mentah dan respons. Anda menghasilkan tampilan dengan menjalankan kode yang mengumpulkan informasi seperti metadata untuk set data dan nama yang Anda berikan.
• Simulasikan proses penayangan data selama beberapa hari dengan kemiringan buatan.
• Gunakan Looker Studio untuk memvisualisasikan data penayangan yang terurai seperti yang dicatat dalam BigQuery.

Mengonfigurasi setelan notebook

Dibagian notebook ini, Anda mempersiapkan sebuah Phyton untuk menjalankan kode skenario tersebut. Kode di notebook membuat tampilan berdasarkan spesifikasi fitur set data Anda. Untuk menghasilkan skrip SQL CREATE OR REPLACE VIEW Anda perlu menetapkan sejumlah variabel.

1. Jika Anda belum membuka instance notebook yang dikelola pengguna Vertex AI Workbench dari bagian satu lakukan langkah berikut:

   1. Di konsol Google Cloud, buka halaman Notebooks.

      Buka Notebooks

   2. Pada tab Notebook yang dikelola pengguna, pilih notebook, lalu klik Buka Jupyterlab. Lingkungan JupyterLab akan terbuka di browser Anda.

   3. Di file browser, buka mlops-on-gcp, lalu buka direktori skew-detection1.

2. Buka notebook 02-covertype-logs-parsing-analysis.ipynb.

3. Di notebook, bagian Setelan, jalankan sel Install paket dan dependensi untuk menginstal paket Python yang diperlukan dan mengonfigurasi variabel lingkungan.

4. Di bagian Konfigurasi setelan lingkungan Google Cloud, tetapkan variabel berikut:

   • PROJECT_ID: ID project Google Cloud tempat set data BigQuery untuk data permintaan-respons dicatat ke dalam log.
   • BQ_DATASET_NAME: Nama set data BigQuery untuk menyimpan login permintaan-respons.
   • BQ_TABLE_NAME: Nama tabel BigQuery untuk menyimpan login permintaan-respons.
   • MODEL_NAME: Nama model yang di-deploy ke AI Platform Prediction.
   • VERSION_NAME: Nama versi model yang di-deploy ke AI Platform Prediction. Versi menggunakan format vN; misalnya, v1.

5. Jalankan sel yang tersisa di bagian Setelan untuk menyelesaikan konfigurasi lingkungan:

   1. Mengautentikasi akun GCP Anda
   2. Mengimpor library

Menentukan metadata untuk set data

Anda menjalankan bagian 1 pada notebook ini, Menentukan metadata set data, untuk menetapkan variabel yang digunakan nanti dalam kode yang menghasilkan skrip SQL. Misalnya, kode di bagian ini membuat dua variabel bernama NUMERIC_FEATURE_NAMES dan CATEGORICAL_FEATURES_WITH_VOCABULARY, seperti yang ditunjukkan dalam cuplikan kode berikut:

NUMERIC_FEATURE_NAMES = ['Aspect', 'Elevation', 'Hillshade_3pm',
                         'Hillshade_9am', 'Hillshade_Noon',
                         'Horizontal_Distance_To_Fire_Points',
                         'Horizontal_Distance_To_Hydrology',
                         'Horizontal_Distance_To_Roadways','Slope',
                         'Vertical_Distance_To_Hydrology']

CATEGORICAL_FEATURES_WITH_VOCABULARY = {
    'Soil_Type': ['2702', '2703', '2704', '2705', '2706', '2717', '3501', '3502',
                  '4201', '4703', '4704', '4744', '4758', '5101', '6101', '6102',
                  '6731', '7101', '7102', '7103', '7201', '7202', '7700', '7701',
                  '7702', '7709', '7710', '7745', '7746', '7755', '7756', '7757',
                  '7790', '8703', '8707', '8708', '8771', '8772', '8776'],
    'Wilderness_Area': ['Cache', 'Commanche', 'Neota', 'Rawah']
}

Kode kemudian membuat variabel bernama FEATURE_NAMES untuk menggabungkan nilai-nilai ini, seperti pada baris berikut:

FEATURE_NAMES = list(CATEGORICAL_FEATURES_WITH_VOCABULARY.keys()) + NUMERIC_FEATURE_NAMES

Catatan: Nilai yang ada di notebook ini khusus untuk set data sampel. Untuk menggunakan notebook ini dengan set data lain, Anda harus mengubah metadata agar cocok dengan fitur di set data tersebut.

Membuat skrip SQL CREATE VIEW

Anda menjalankan tugas di bagian 2 notebook untuk menghasilkan pernyataan CREATE VIEW yang Anda jalankan nanti untuk mengurai log.

Tugas pertama menjalankan kode untuk membuat nilai dari metadata data untuk variabel json_features_extraction danjson_prediction_extraction. Variabel ini berisi fitur dan nilai prediksi dalam format yang dapat disisipkan ke dalam pernyataan SQL.

Kode ini bergantung pada variabel yang Anda tetapkan sebelumnya saat mengonfigurasi setelan notebook dan saat menentukan metadata untuk set data. Cuplikan berikut menunjukkan kode ini.

LABEL_KEY = 'predicted_label'
SCORE_KEY = 'confidence'
SIGNATURE_NAME = 'serving_default'

def _extract_json(column, feature_name):
  return "JSON_EXTRACT({}, '$.{}')".format(column, feature_name)

def _replace_brackets(field):
  return "REPLACE(REPLACE({}, ']', ''), '[','')".format(field)

def _replace_quotes(field):
  return 'REPLACE({}, "\\"","")'.format(field)

def _cast_to_numeric(field):
  return "CAST({} AS NUMERIC)".format(field)

def _add_alias(field, feature_name):
  return "{} AS {}".format(field, feature_name)

view_name = "vw_"+BQ_TABLE_NAME+"_"+VERSION_NAME

column_names = FEATURE_NAMES
input_features = ', \r\n  '.join(column_names)

json_features_extraction = []
for feature_name in column_names:
  field = _extract_json('instance', feature_name)
  field = _replace_brackets(field)
  if feature_name in NUMERIC_FEATURE_NAMES:
    field = _cast_to_numeric(field)
  else:
    field = _replace_quotes(field)
  field = _add_alias(field, feature_name)
  json_features_extraction.append(field)

json_features_extraction = ', \r\n    '.join(json_features_extraction)

json_prediction_extraction = []
for feature_name in [LABEL_KEY, SCORE_KEY]:
  field = _extract_json('prediction', feature_name)
  field = _replace_brackets(field)
  if feature_name == SCORE_KEY:
    field = _cast_to_numeric(field)
  else:
    field = _replace_quotes(field)
  field = _add_alias(field, feature_name)
  json_prediction_extraction.append(field)

json_prediction_extraction = ', \r\n    '.join(json_prediction_extraction)

Tugas kedua menetapkan variabel bernama sql_script ke string panjang yang berisi pernyataan CREATE OR REPLACE VIEW. Pernyataan tersebut berisi beberapa placeholder yang ditandai dalam string menggunakan @ sebagai awalan. Misalnya, example, ada placeholder untuk nama set data dan tampilan:

CREATE OR REPLACE VIEW @dataset_name.@view_name

Ada juga placeholder untuk nama project, tabel, model, dan versi:

FROM
  `@project.@dataset_name.@table_name`
  WHERE
    model = '@model_name' AND
    model_version = '@version'
)

Akhir pernyataan mencakup placeholder yang menggunakan json_features_extraction dan json_prediction_extraction yang Anda buat dengan menjalankan kode di tugas sebelumnya:

step3 AS
(SELECT
    model,
    model_version,
    time,
    @json_features_extraction,
    @json_prediction_extraction
FROM step2
)

Terakhir, jalankan sel berikutnya untuk mengganti placeholder dalam pernyataan SQL dengan nilai yang Anda tetapkan sebelumnya, seperti yang ditunjukkan dalam cuplikan berikut:

sql_script = sql_script.replace("@project", PROJECT_ID)
sql_script = sql_script.replace("@dataset_name", BQ_DATASET_NAME)
sql_script = sql_script.replace("@table_name", BQ_TABLE_NAME)
sql_script = sql_script.replace("@view_name", view_name)
sql_script = sql_script.replace("@model_name", MODEL_NAME)
sql_script = sql_script.replace("@version", VERSION_NAME)
sql_script = sql_script.replace("@input_features", input_features)
sql_script = sql_script.replace("@json_features_extraction", json_features_extraction)
sql_script = sql_script.replace("@json_prediction_extraction", json_prediction_extraction)

Langkah ini menyelesaikan pembuatan pernyataan SQL yang membuat tampilan untuk mengurai titik data permintaan dan respons mentah.

Jika ingin melihat skrip yang Anda buat, jalankan sel yang mencetak tampilan. Sel berisi kode berikut:

print(sql_script)

Menjalankan skrip SQL CREATE VIEW

Untuk menjalankan pernyataan CREATE VIEW, jalankan kode di bagian 3 notebook. Setelah selesai, kode akan menampilkan pesan View created or replaced. Saat Anda melihat pesan ini, tampilan untuk penguraian data sudah siap.

Cuplikan berikut menunjukkan pernyataan yang dihasilkan.

CREATE OR REPLACE VIEW prediction_logs.vw_covertype_classifier_logs_v1
AS

WITH step1 AS
(
  SELECT
    model,
    model_version,
    time,
    SPLIT(JSON_EXTRACT(raw_data, '$.instances'), '}],[{') instance_list,
    SPLIT(JSON_EXTRACT(raw_prediction, '$.predictions'), '}],[{') as prediction_list
  FROM
  `sa-data-validation.prediction_logs.covertype_classifier_logs`
  WHERE
    model = 'covertype_classifier' AND
    model_version = 'v1'
),

step2 AS
(
  SELECT
    model,
    model_version,
    time,
    REPLACE(REPLACE(instance, '[{', '{'),'}]', '}') AS instance,
    REPLACE(REPLACE(prediction, '[{', '{'),'}]', '}') AS prediction,
  FROM step1
  JOIN UNNEST(step1.instance_list) AS instance
  WITH OFFSET AS f1
  JOIN UNNEST(step1.prediction_list) AS prediction
  WITH OFFSET AS f2
  ON f1=f2
),

step3 AS
(
  SELECT
    model,
    model_version,
    time,
    REPLACE(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Soil_Type'), ']', ''), '[',''), "\"","") AS Soil_Type,
    REPLACE(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Wilderness_Area'), ']', ''), '[',''), "\"","") AS Wilderness_Area,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Aspect'), ']', ''), '[','') AS NUMERIC) AS Aspect,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Elevation'), ']', ''), '[','') AS NUMERIC) AS Elevation,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Hillshade_3pm'), ']', ''), '[','') AS NUMERIC) AS Hillshade_3pm,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Hillshade_9am'), ']', ''), '[','') AS NUMERIC) AS Hillshade_9am,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Hillshade_Noon'), ']', ''), '[','') AS NUMERIC) AS Hillshade_Noon,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Horizontal_Distance_To_Fire_Points'), ']', ''), '[','') AS NUMERIC) AS Horizontal_Distance_To_Fire_Points,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Horizontal_Distance_To_Hydrology'), ']', ''), '[','') AS NUMERIC) AS Horizontal_Distance_To_Hydrology,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Horizontal_Distance_To_Roadways'), ']', ''), '[','') AS NUMERIC) AS Horizontal_Distance_To_Roadways,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Slope'), ']', ''), '[','') AS NUMERIC) AS Slope,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(instance, '$.Vertical_Distance_To_Hydrology'), ']', ''), '[','') AS NUMERIC) AS Vertical_Distance_To_Hydrology,
    REPLACE(REPLACE(REPLACE(JSON_EXTRACT(prediction, '$.predicted_label'), ']', ''), '[',''), "\"","") AS predicted_label,
    CAST(REPLACE(REPLACE(JSON_EXTRACT(prediction, '$.confidence'), ']', ''), '[','') AS NUMERIC) AS confidence
  FROM step2
)

SELECT*
FROM step3

Membuat kueri tampilan

Setelah tampilan dibuat, Anda dapat mengkuerinya. Untuk membuat kueri tampilan, jalankan kode di bagian 4, Membuat kueri tampilan. Kode tersebut menggunakan metode pandas.io.gbq.read_gbq di notebook, seperti ditunjukkan dalam cuplikan kode berikut:

query = '''
 SELECT * FROM
 `{}.{}`
 LIMIT {}
'''.format(BQ_DATASET_NAME, view_name, 3)

pd.io.gbq.read_gbq(
   query, project_id=PROJECT_ID).T

Kode tersebut menghasilkan output yang mirip dengan kode berikut:

Hasil tampilan kueri menunjukkan hal berikut:

• Setiap fitur memiliki entri tersendiri.
• Kutipan dihilangkan dari fitur kategoris.
• Label class yang diprediksi ditampilkan di entri predicted_label.
• Probabilitas label class yang diprediksi ditampilkan dalam entri confidence.

Menggunakan konsol BigQuery

Sebagai alternatif untuk membuat kueri tampilan dengan menggunakan pandas API, Anda dapat membuat kueri tampilan di konsol BigQuery.

1. Membuka konsol BigQuery.

   Buka konsol BigQuery

2. Di panel Query editor, masukkan kueri seperti berikut:

   Select*
   FROM PROJECT_ID.prediction_logs.vw_covertype_classifier_logs_v1
   Limit 10
   

   Ganti PROJECT_ID dengan ID project Google Cloud yang Anda tetapkan sebelumnya.

   Outputnya mirip dengan yang berikut ini:

   

(Opsional) Menyimulasikan data penayangan

Jika Anda menggunakan model dan data sendiri, lewati bagian ini dan lanjutkan ke next section, yang menjelaskan cara mengisi tabel log permintaan-respons dengan data contoh.

Anda mungkin menggunakan data sampel untuk menghasilkan titik data yang condong, lalu menyimulasikan permintaan prediksi ke versi model yang di-deploy ke AI Platform Prediction. Model ini menghasilkan prediksi ke instance permintaan. Instance dan prediksi disimpan di BigQuery.

Anda dapat menghasilkan titik data sampel (normal dan miring) untuk permintaan prediksi, lalu memanggil model klasifikasi covertype yang di-deploy ke AI Platform Prediction dengan menggunakan titik data yang dihasilkan. Repositori yang Anda clone berisi notebook yang menyertakan kode untuk tugas ini, atau Anda dapat memuat file CSV yang berisi data log dengan kemiringan.

Untuk menghasilkan data sampel dari notebook, lakukan hal berikut:

1. Di notebook, buka file browser, buka mlops-on-gcp, lalu arahkan ke direktori skew-detection/workload_simulator.
2. Buka notebook covertype-data-generation.ipynb.
3. Di bagian Setup, tetapkan nilai untuk project ID, nama bucket, dan region Anda.
4. Jalankan semua sel di notebook secara berurutan.

Anda dapat mengubah ukuran data yang akan dihasilkan serta cara data diubah. Kemiringan default yang diperkenalkan dalam data adalah sebagai berikut:

• Kemiringan fitur numerik. Untuk fitur Elevation, kode akan mengonversi satuan ukuran dari meter ke kilometer dalam 10% data.
• Kemiringan distribusi fitur numerik. Untuk fitur Aspect, kode mengurangi nilai ini sebesar 25%.
• Kemiringan fitur kategoris. Untuk fitur Wilderness_Area, kode akan mengonversi nilai 1% data acak ke kategori baru bernama Others.
• Kemiringan distribusi fitur kategoris. Untuk fitur Wilderness_Area, kode akan meningkatkan frekuensi nilai Neota dan Cache . Kode melakukannya dengan mengonversi 25% titik data yang dipilih secara acak dari nilai aslinya ke nilai Neota dan Cache.

Atau, Anda dapat memuat file data workload_simulator/bq_prediction_logs.csv ke dalam tabel log respons permintaan BigQuery. File CSV menyertakan contoh log respons permintaan, dengan 2000 titik data normal dan 1000 titik data yang miring. Untuk informasi lebih lanjut, lihat memuat data ke BigQuery dari data lokal.

Memvisualisasikan data penayangan yang dicatat dalam log

Anda dapat menggunakan alat visualisasi untuk terhubung ke tampilan BigQuery dan memvisualisasikan data penayangan yang dicatat ke dalam log. Dalam contoh berikut, visualisasi dibuat menggunakan Looker Studio.

Screenshot berikut menunjukkan contoh dasbor yang dibuat untuk memvisualisasikan log respons permintaan prediksi dari panduan ini.

Dasbor akan menampilkan informasi berikut:

• Jumlah instance yang diterima oleh layanan prediksi sama (500) setiap hari mulai 1 Juni hingga 6 Juni.
• Untuk distribusi class, frekuensi label class yang diprediksi 3 telah meningkat dalam dua hari terakhir (5 Juni dan 6 Juni).
• Untuk distribusi nilai Wilderness Area, Neota and Cache telah meningkat dalam dua hari terakhir.
• Untuk statistik deskriptif fitur Elevation, nilai minimum dua hari terakhir memiliki nilai yang jauh lebih rendah daripada empat hari sebelumnya. Nilai standar deviasi memiliki nilai yang secara signifikan lebih tinggi daripada empat hari sebelumnya.

Selain itu, seperti yang ditunjukkan pada screenshot berikut, distribusi nilai fitur Aspect selama dua hari terakhir mengalami penurunan yang signifikan dalam frekuensi nilai antara 300 dan 350.

Pembersihan

Jika Anda berencana untuk melanjutkan sisa seri ini, pertahankan resource yang telah Anda buat. Jika tidak, hapus project yang berisi resource, atau simpan project dan hapus resource individual.

Menghapus project

Perhatian: Menghapus project memiliki efek berikut:

• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

1. Di konsol Google Cloud, buka halaman Manage resource.

   Buka Manage resource

2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Langkah berikutnya

• Baca panduan Menganalisis kecenderungan penayangan pelatihan di AI Platform Prediction dengan Validasi Data TensorFlow.
• Baca panduan Mengotomatiskan deteksi diferensiasi performa pelatihan dan penayangan di AI Platform Prediction.
• Baca panduan Mengidentifikasi diferensiasi performa server pelatihan dengan deteksi kebaruan.
• Pelajari MLOps, continuous delivery, dan pipeline otomatisasi di machine learning.
• Pelajari arsitektur untuk MLOps menggunakan TFX, Kubeflow Pipelines, dan Cloud Build.
• Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.