Versi lama AI Platform Training, AI Platform Prediction, AI Platform Pipelines, dan Layanan Pelabelan Data AI Platform tidak digunakan lagi dan tidak akan tersedia lagi di Google Cloud setelah tanggal penghentiannya. Semua fungsi AI Platform lama dan fitur baru tersedia di platform Vertex AI. Lihat Bermigrasi ke Vertex AI untuk mempelajari cara memigrasikan resource Anda.

Halaman ini diterjemahkan oleh Cloud Translation API.

Memprediksi Nilai Umur Pelanggan dengan AutoML Tables

Last reviewed 2019-04-10 UTC

Artikel ini adalah bagian keempat dari rangkaian empat bagian yang membahas cara memprediksi nilai umur pelanggan (CLV) menggunakan AI Platform (AI Platform) di Google Cloud. Artikel ini menunjukkan cara menggunakan Tabel AutoML untuk melakukan prediksi.

Artikel dalam seri ini mencakup hal berikut:

Bagian 1: Pengantar. Memperkenalkan CLV dan dua teknik pemodelan untuk memprediksi CLV.
Bagian 2: Melatih model Membahas cara menyiapkan data dan melatih model.
Bagian 3: Men-deploy ke produksi. Menjelaskan cara men-deploy model yang dibahas di Bagian 2 ke sistem produksi.
Bagian 4: Menggunakan AutoML Tables (artikel ini). Menunjukkan cara menggunakan AutoML Tables untuk membuat dan men-deploy model.

Proses yang dijelaskan dalam artikel ini bergantung pada langkah-langkah pemrosesan data yang sama di BigQuery yang dijelaskan dalam Bagian 2 dari seri ini. Artikel ini menunjukkan cara mengupload set data BigQuery tersebut ke AutoML Tables dan membuat model. Artikel ini juga menunjukkan cara mengintegrasikan model AutoML ke dalam sistem produksi yang dijelaskan di Bagian 3.

Kode untuk menerapkan sistem ini berada di repositori GitHub yang sama dengan seri asli. Artikel ini membahas cara menggunakan kode untuk AutoML Tables di repositori tersebut.

Keuntungan AutoML Tables

Di bagian sebelumnya dalam seri ini, Anda telah melihat cara memprediksi CLV menggunakan model statistik dan model DNN yang diterapkan di TensorFlow. AutoML Tables memiliki beberapa keunggulan dibandingkan dua metode lainnya:

Anda tidak perlu coding untuk membuat model. Ada UI konsol yang memungkinkan Anda membuat, melatih, mengelola, dan men-deploy set data dan model.
Menambahkan atau mengubah fitur itu mudah, dan dapat dilakukan langsung di antarmuka konsol.
Proses pelatihan otomatis, termasuk penyesuaian hyperparameter.
AutoML Tables menelusuri arsitektur terbaik untuk set data Anda, sehingga Anda tidak perlu memilih dari banyak opsi yang tersedia.
AutoML Tables memberikan analisis mendetail tentang performa model terlatih, termasuk nilai penting fitur.

Akibatnya, Anda dapat menghemat waktu dan biaya untuk mengembangkan dan melatih model yang sepenuhnya dioptimalkan menggunakan AutoML Tables.

Deployment produksi solusi AutoML Tables mengharuskan Anda menggunakan API klien Python untuk membuat dan men-deploy model serta menjalankan prediksi. Artikel ini menunjukkan cara membuat dan melatih model AutoML Tables menggunakan API klien. Untuk panduan tentang cara melakukan langkah-langkah ini menggunakan konsol AutoML Tables, lihat dokumentasi AutoML Tables.

Menginstal kode

Jika Anda belum menginstal kode untuk seri asli, ikuti langkah-langkah yang sama seperti yang dijelaskan di Bagian 2 seri asli untuk menginstal kode. File README di repositori GitHub menjelaskan semua langkah yang diperlukan untuk menyiapkan lingkungan, menginstal kode, dan menyiapkan AutoML Tables di project Anda.

Jika sebelumnya Anda telah menginstal kode, Anda perlu melakukan langkah-langkah tambahan berikut untuk menyelesaikan penginstalan artikel ini:

Aktifkan AutoML Tables API di project Anda.
Aktifkan lingkungan miniconda yang telah Anda instal sebelumnya.
Instal library klien Python seperti yang dijelaskan dalam dokumentasi AutoML Tables.
Buat dan download file kunci API lalu simpan di lokasi yang diketahui untuk digunakan nanti dengan library klien.

Menjalankan kode

Untuk banyak langkah dalam artikel ini, Anda akan menjalankan perintah Python. Setelah menyiapkan lingkungan dan menginstal kode, Anda memiliki opsi berikut untuk menjalankan kode:

Jalankan kode di notebook Jupyter. Dari jendela terminal di lingkungan miniconda yang diaktifkan, jalankan perintah berikut:
```
$ (clv) jupyter notebook
```
Kode untuk setiap langkah dalam artikel ini ada di notebook di repositori kode bernama notebooks/clv_automl.ipynb. Buka notebook ini di antarmuka Jupyter. Kemudian, Anda dapat menjalankan setiap langkah saat mengikuti tutorial.
Jalankan kode sebagai skrip Python. Langkah-langkah kode untuk tutorial ini ada di repositori kode dalam file clv_automl/clv_automl.py. Skrip ini mengambil argumen di command line untuk parameter yang dapat dikonfigurasi seperti project ID, lokasi file kunci API, region Google Cloud , dan nama set data BigQuery. Anda menjalankan skrip dari jendela terminal di lingkungan miniconda yang diaktifkan, mengganti Google Cloud nama project dengan [YOUR_PROJECT]:
```
$ (clv) cd clv_automl
$ (clv) python clv_automl.py --project_id [YOUR_PROJECT]
```
Untuk mengetahui daftar lengkap parameter dan nilai default, lihat metode create_parser dalam skrip, atau jalankan skrip tanpa argumen untuk melihat dokumentasi penggunaan.
Setelah Anda menginstal lingkungan Cloud Composer seperti yang dijelaskan dalam README, jalankan kode dengan mengeksekusi DAG, seperti yang dijelaskan nanti di bagian Menjalankan DAG.

Menyiapkan data

Artikel ini menggunakan set data dan langkah-langkah persiapan data yang sama di BigQuery yang dijelaskan dalam Bagian 2 dari seri asli. Setelah menyelesaikan agregasi data seperti yang dijelaskan dalam artikel tersebut, Anda siap membuat set data untuk digunakan dengan AutoML Tables.

Membuat set data AutoML Tables

Untuk memulai, upload data yang Anda siapkan di BigQuery ke Tabel AutoML.

Untuk melakukan inisialisasi klien, tetapkan nama file kunci ke nama file yang Anda download di langkah penginstalan:
```
keyfile_name = "mykey.json"
client = automl_v1beta1.AutoMlClient.from_service_account_file(keyfile_name)
```

Buat set data:

create_dataset_response = client.create_dataset(
    location_path,
    {'display_name': dataset_display_name,
     'tables_dataset_metadata': {}})
dataset_name = create_dataset_response.name

Mengimpor data dari BigQuery

Setelah membuat set data, Anda dapat mengimpor data dari BigQuery.

Impor data dari BigQuery ke set data AutoML Tables:

dataset_bq_input_uri = 'bq://{}.{}.{}'.format(args.project_id, args.bq_dataset, args.bq_table)
input_config = {
    'bigquery_source': {
        'input_uri': dataset_bq_input_uri}}
import_data_response = client.import_data(dataset_name, input_config)

Melatih model

Setelah membuat set data AutoML untuk data CLV, Anda dapat membuat model AutoML Tables.

Dapatkan spesifikasi kolom AutoML Tables untuk setiap kolom dalam set data:

list_table_specs_response = client.list_table_specs(dataset_name)
table_specs = [s for s in list_table_specs_response]
table_spec_name = table_specs[0].name
list_column_specs_response = client.list_column_specs(table_spec_name)
column_specs = {s.display_name: s for s in list_column_specs_response}

Spesifikasi kolom diperlukan di langkah berikutnya.

Tetapkan salah satu kolom sebagai label untuk model Tabel AutoML:

TARGET_LABEL = 'target_monetary'
...
label_column_name = TARGET_LABEL
label_column_spec = column_specs[label_column_name]
label_column_id = label_column_spec.name.rsplit('/', 1)[-1]
update_dataset_dict = {
    'name': dataset_name,
    'tables_dataset_metadata': {
        'target_column_spec_id': label_column_id
    }
}
update_dataset_response = client.update_dataset(update_dataset_dict)

Kode ini menggunakan kolom label yang sama (target_monetary) dengan model DNN TensorFlow di Bagian 2.

Tentukan fitur untuk melatih model:
```
feat_list = list(column_specs.keys())
feat_list.remove('target_monetary')
feat_list.remove('customer_id')
feat_list.remove('monetary_btyd')
feat_list.remove('frequency_btyd')
feat_list.remove('frequency_btyd_clipped')
feat_list.remove('monetary_btyd_clipped')
feat_list.remove('target_monetary_clipped')
```
Fitur yang digunakan untuk melatih model Tabel AutoML adalah sama dengan yang digunakan untuk melatih model DNN TensorFlow di Bagian 2 dari seri asli. Namun, menambahkan atau mengurangi fitur dari model jauh lebih mudah dengan AutoML Tables. Setelah dibuat di BigQuery, fitur akan otomatis disertakan dalam model, kecuali jika Anda menghapusnya secara eksplisit seperti yang ditunjukkan dalam cuplikan kode sebelumnya.

Tentukan opsi untuk membuat model. Tujuan pengoptimalan untuk meminimalkan error absolut rata-rata, yang diwakili oleh parameter MINIMIZE_MAE, direkomendasikan untuk set data ini.

model_display_name = args.automl_model
model_training_budget = args.training_budget * 1000
model_dict = {
  'display_name': model_display_name,
  'dataset_id': dataset_name.rsplit('/', 1)[-1],
  'tables_model_metadata': {
      'target_column_spec': column_specs['target_monetary'],
      'input_feature_column_specs': [
          column_specs[x] for x in feat_list],
      'train_budget_milli_node_hours': model_training_budget,
      'optimization_objective': 'MINIMIZE_MAE'
  }
}

Untuk informasi selengkapnya, lihat dokumentasi AutoML Tables tentang tujuan pengoptimalan.

Buat model dan mulai pelatihan:
```
create_model_response = client.create_model(location_path, model_dict)
create_model_result = create_model_response.result()
model_name = create_model_result.name
```
Nilai yang ditampilkan dari panggilan klien (create_model_response) akan segera ditampilkan. Nilai create_model_response.result() adalah promise, yang memblokir hingga pelatihan selesai. Nilai model_name adalah jalur resource yang diperlukan untuk panggilan klien lebih lanjut yang beroperasi pada model.

Mengevaluasi model

Setelah pelatihan model selesai, Anda dapat mengambil statistik evaluasi model. Anda dapat menggunakan Google Cloud console atau API klien.

Untuk menggunakan konsol, di konsol AutoML Tables, buka tab Evaluate:

Untuk menggunakan API klien, ambil statistik evaluasi model:

model_evaluations = [e for e in client.list_model_evaluations(model_name)]
model_evaluation = model_evaluations[0]

Anda akan melihat output yang mirip dengan ini:

name: "projects/595920091534/locations/us-central1/models/TBL3912308662231629824/modelEvaluations/9140437057533851929"
create_time {
  seconds: 1553108019
  nanos: 804478000
}
evaluated_example_count: 125
regression_evaluation_metrics: {
  mean_absolute_error: 591.091
  root_mean_squared_error: 853.481
  mean_absolute_percentage_error: 21.47
  r_squared: 0.907
}

Root mean squared error sebesar 853,481 dibandingkan dengan model probabilistik dan TensorFlow yang digunakan dalam seri asli. Namun, seperti yang telah dibahas dalam Bagian 2, sebaiknya coba setiap teknik yang disediakan dengan data Anda untuk melihat mana yang berperforma terbaik.

Men-deploy model AutoML

DAG Cloud Composer dari seri asli telah diperbarui untuk menyertakan model AutoML Tables untuk pelatihan dan prediksi. Untuk informasi umum tentang fungsi DAG Cloud Composer, lihat bagian tentang Mengotomatiskan Solusi di Bagian 3 artikel asli.

Anda dapat menginstal sistem orkestrasi Cloud Composer untuk solusi ini dengan mengikuti petunjuk dalam README.

DAG yang diperbarui memanggil metode dalam skrip clv_automl/clv_automl.py yang mereplikasi panggilan kode klien yang ditampilkan sebelumnya untuk membuat model dan menjalankan prediksi.

DAG pelatihan

DAG yang diperbarui untuk pelatihan mencakup tugas untuk membuat model AutoML Tables. Diagram berikut menunjukkan DAG baru untuk pelatihan.

DAG Pelatihan

DAG prediksi

DAG yang diperbarui untuk prediksi mencakup tugas untuk menjalankan prediksi batch dengan model AutoML Tables. Diagram berikut menunjukkan DAG baru untuk prediksi.

DAG Prediksi

Menjalankan DAG

Untuk memicu DAG secara manual, Anda dapat menjalankan perintah dari bagian Run Dags pada file README di Cloud Shell atau menggunakan Google Cloud CLI.

Untuk menjalankan DAG build_train_deploy:

gcloud composer environments run ${COMPOSER_NAME} \
    --project ${PROJECT} \
    --location ${REGION} \
    dags trigger \
    -- \
    build_train_deploy \
    --conf '{"model_type":"automl", "project":"'${PROJECT}'", "dataset":"'${DATASET_NAME}'", "threshold_date":"2011-08-08", "predict_end":"2011-12-12", "model_name":"automl_airflow", "model_version":"v1", "max_monetary":"15000"}'

Jalankan DAG predict_serve:

gcloud composer environments run ${COMPOSER_NAME} \
    --project ${PROJECT} \
    --location ${REGION} \
    dags trigger \
    -- \
    predict_serve \
    --conf '{"model_name":"automl_airflow", "model_version":"v1", "dataset":"'${DATASET_NAME}'"}'

Langkah selanjutnya

Tinjau set lengkap tutorial CLV.
Jalankan contoh lengkap di repositori GitHub.
Pelajari solusi perkiraan prediktif lainnya.
Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.