Lewati ke konten utama

Snowflake Snowpark: Pengantar Komprehensif

Ambil langkah pertama untuk menguasai machine learning in-database menggunakan Snowflake Snowpark.
· 15 mnt Baca

Jelajahi bersama AI

Apa itu Snowflake Snowpark?

Machine learning tradisional melibatkan memindahkan data dari basis data ke tempat model berada. Dengan ledakan AI baru-baru ini dan besarnya dataset saat ini, pendekatan ini menjadi semakin tidak praktis.

Terabita data harus dipindahkan dari basis data ke aplikasi sisi klien untuk pembersihan, analisis, dan pelatihan model. Perjalanan dua arah yang tampaknya sepele ini menghabiskan sumber daya berharga. Karena itu, semakin banyak perusahaan memilih teknologi in-database untuk meminimalkan perpindahan data dan menjalankan operasi data dengan lancar.

Salah satu teknologi in-database terbaik di pasar adalah Snowpark, yang ditawarkan oleh Snowflake Cloud. Snowpark adalah kumpulan pustaka dan runtime yang memungkinkan Anda menjalankan bahasa pemrograman secara aman di Snowflake Cloud untuk mengembangkan pipeline data dan model machine learning dalam lingkungan yang sama dengan basis data Snowflake Anda.

Dalam tutorial ini, kita akan membahas dasar-dasar Snowpark dan cara Anda menggunakannya dalam proyek. Kami mengasumsikan Anda sudah familiar dengan SQL dan Snowflake—jika perlu mempelajari ini terlebih dahulu, Anda dapat mengikuti SQL Fundamental Skill Track kami atau membaca Tutorial Snowflake untuk Pemula.

Mari mulai!

Mengapa Snowflake Snowpark?

Snowflake Snowpark adalah sekumpulan pustaka dan runtime yang memungkinkan Anda menggunakan bahasa pemrograman seperti Python, Java, dan Scala secara aman untuk memproses data langsung di dalam platform cloud Snowflake.

Ini menghilangkan kebutuhan untuk memindahkan data ke luar Snowflake untuk diproses, sehingga meningkatkan efisiensi dan keamanan. Berikut beberapa manfaat utamanya:

  • Memproses data di Snowflake: Tulis kode dalam bahasa pilihan Anda untuk memanipulasi dan menganalisis basis data SQL Anda di Snowflake dan eksekusi di dalam lingkungan aman Snowflake. Ini menghilangkan kebutuhan memindahkan data ke lingkungan lain.
  • Kinerja lebih baik: Dengan memproses data langsung di Snowflake, Snowpark dapat memanfaatkan arsitektur elastis dan tanpa server dari platform untuk pemrosesan yang efisien.
  • Biaya dan overhead teknologi berkurang: Karena Snowflake sebagian besar menyediakan sumber daya, Anda tidak perlu mengelola platform terpisah untuk komputasi dan penyimpanan.
  • Bekerja dengan alat yang Anda kenal dan di mana pun Anda mau: API Snowpark memungkinkan Anda terhubung ke basis data SQL dari lingkungan apa pun, seperti Jupyter atau VSCode, dan membangun pipeline data serta aplikasi ML. Bagian terbaiknya, Anda dapat menggunakan pustaka favorit, seperti Pandas, Scikit-learn, XGBoost, dll., bersama kerangka kerja Snowpark.

Singkatnya, Snowpark adalah cara yang kuat namun sederhana bagi pengembang untuk membangun pipeline data, solusi machine learning, dan aplikasi berbasis data langsung di dalam Snowflake Cloud.

Mulai Menggunakan Snowpark

Tujuan akhir dalam tutorial ini adalah membangun model yang dituning hiperparameternya dan dilatih pada sebuah tabel di basis data Snowflake menggunakan Snowpark. Untuk melakukannya, kita akan mulai dengan:

  1. Membuat lingkungan virtual dengan pustaka relevan.
  2. Memasukkan data contoh ke Snowflake.
  3. Membuat sesi Snowpark untuk terhubung ke Snowflake.
  4. Memuat data yang telah diingest ke dalam sesi.

Membuat lingkungan virtual

Untuk tutorial ini, kita akan menggunakan lingkungan conda baru:

$ conda create -n snowpark python==3.10 -y
$ conda activate snowpark

Sebagai catatan, jika Anda menjalankan pada lingkungan conda yang baru diinstal, Anda perlu menjalankan $conda init sebelum mengaktifkan lingkungan snowpark.

Setelah aktivasi, kita perlu memasang pustaka berikut:

$ pip install snowflake-snowpark-python #The Snowpark API
$ pip install pandas pyarrow numpy matplotlib seaborn

Jika Anda akan menggunakan Jupyter, pasang juga ipykernel dan jalankan perintah berikut agar lingkungan yang kita gunakan ditambahkan sebagai kernel Jupyter:

$ pip install ipykernel
$ ipython kernel install --user --name=snowpark

Sekarang mari impor beberapa pustaka umum yang akan kita perlukan di sepanjang jalan:

import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
warnings.filterwarnings("ignore")

Mengingest data contoh ke Snowflake

Untuk tutorial ini, kita akan menggunakan dataset Diamonds dari Seaborn—Anda dapat mengunduh file CSV langsung dari GitHub saya.

Setelah Anda masuk ke aplikasi Snowflake, ikuti GIF di bawah untuk mengingest dataset ke tabel basis data baru (buat akun baru jika Anda belum punya):

snowflake_dashboard.gif

Dalam praktiknya, Anda jarang mengimpor file CSV sebagai tabel ke basis data Snowflake Anda. Sebagian besar waktu, Anda akan bekerja dengan basis data yang sudah ada dengan tingkat akses berbeda yang diberikan oleh administrator basis data perusahaan Anda.

Membuat sesi Snowpark

Sekarang, kita harus membuat koneksi antara API Snowpark dan cloud Snowflake untuk menanyakan basis data kita. Koneksi ini memerlukan kredensial Snowflake berikut: nama akun, nama pengguna, dan kata sandi.

Pada gambar di bawah, saya akan menunjukkan cara mengambil nama pengguna dan nama akun Anda dari dasbor Snowflake:

image.png

Buat file terpisah bernama config.py yang berisi satu kamus bernama credentials dengan format berikut:

credentials = (
   {
       "account": "3-4",  # Combine 3 and 4 with a hyphen
       "username": "bexgboost",  # Your username in lowercase
       "password": "your_password",  # Your Snowflake password
   },
)

Demi keamanan, kami menyimpan kredensial di file terpisah. Menambahkan file ini ke .gitignore memastikan kredensial Snowflake Anda tidak bocor secara tidak sengaja.

Sekarang, kita impor kamus credentials dan kelas Session dari Snowpark:

from config import credentials
from snowflake.snowpark import Session

Untuk membuat koneksi, kita akan menggunakan metode Session.builder.configs.create():

connection_parameters = {
   "account": credentials["account"],
   "user": credentials["username"],
   "password": credentials["password"],
}

new_session = Session.builder.configs(connection_parameters).create()
new_session.get_current_user()
'"bexgboost"'

Jika nama pengguna Anda tercetak, sesi pertama Anda berhasil dibuat!

Memuat data yang diingest ke dalam sesi

Objek new_session memiliki akses ke semua yang dimiliki akun Anda di Snowflake (dan yang Anda punya izin untuk diakses).

Langkah pertama sebelum mengimpor data adalah memberi tahu sesi bahwa kita menggunakan basis data test_db yang telah kita buat pada bagian sebelumnya:

new_session.sql("USE DATABASE test_db;").collect()
[Row(status='Statement executed successfully.')]

Kita melakukan ini menggunakan metode .sql, yang memungkinkan kita menjalankan kueri apa pun yang kompatibel dengan Snowflake SQL.

Sekarang, kita dapat memuat tabel diamonds dari test_db menggunakan metode table dari objek sesi:

diamonds_df = new_session.table("diamonds")
diamonds_df.show(5)

Lima baris teratas dari dataset diamonds yang dicetak dari Snowpark dataframes.

Metode .show() setara dengan DataFrame.describe() milik Pandas, dan menunjukkan bahwa kita telah berhasil terhubung ke tabel.

Benar sekali—kita hanya terhubung ke tabel diamonds. Objek diamonds_df tidak menampung data apa pun seperti dibuktikan oleh ukurannya:

import sys
sys.getsizeof(diamonds_df)
48

Ukurannya hanya 48 byte padahal seharusnya lebih dari 3 MB. Mari luangkan sedikit waktu untuk memahami mengapa ini terjadi.

Memahami Snowpark DataFrames

Sejauh ini, kita telah melakukan langkah-langkah berikut:

  1. Membuat lingkungan virtual dengan pustaka relevan.
  2. Mengimpor data contoh ke Snowflake.
  3. Membuat sesi Snowpark untuk terhubung ke Snowflake.

Sekarang mari bahas Snowpark DataFrames!

Snowpark DataFrames bersifat lazy

Pandas DataFrames menggunakan RAM Anda, artinya mereka berada di mesin Anda. Sebaliknya, Snowpark DataFrames berada di dalam platform cloud Snowflake, meskipun Anda dapat melihat representasinya di lingkungan pemrograman Anda. Datanya tetap berada di cloud dan tidak perlu diunduh ke mesin lokal untuk melakukan operasi.

Aspek penting lainnya dari Snowpark DataFrames adalah mereka bekerja secara lazy. Artinya, mereka tidak mengeksekusi operasi apa pun pada data sampai Anda secara khusus memintanya.

Sebagai gantinya, mereka membangun representasi logis dari operasi yang diinginkan yang kemudian diterjemahkan menjadi kueri SQL teroptimasi untuk dieksekusi oleh Snowflake.

Sebaliknya, Pandas mengeksekusi operasi secara langsung—dengan kata lain, melakukan eager execution.

Dari sisi kinerja, evaluasi lazy hampir selalu jauh lebih cepat daripada eksekusi eager. Karena DataFrame lazy menggunakan sumber daya komputasi elastis Snowflake yang kuat, mereka dapat mendorong operasi ke tingkat basis data dan berjalan jauh lebih cepat.

Untuk lebih memahami perbedaan antara evaluasi lazy dan eksekusi eager, bayangkan data kita di Snowflake adalah perpustakaan raksasa. Kita punya dua skenario berikut:

  • Eager execution (Pandas DataFrames): Kita mengumpulkan semua buku yang kita perlukan ke meja kita (mesin lokal) lalu menganalisisnya satu per satu.
  • Lazy evaluation (Snowpark DataFrames): Kita memberi tahu pustakawan (Snowpark) buku apa yang kita perlukan dan analisis apa yang ingin dilakukan, lalu pustakawan mengambil dan menganalisis informasi relevan secara efisien.

Kapan menggunakan Snowpark DataFrames

Karena Snowpark dapat dikonversi ke Pandas DataFrames, kapan sebaiknya kita menggunakan salah satunya?

pandas_diamonds = diamonds_df.to_pandas()
pandas_diamonds.head()

Screenshot 2024-05-03 at 14.18.05.png

Jawabannya sangat bergantung pada ukuran dataset.

Jika dataset Anda kecil (seperti dataset Diamonds), Anda dapat mengunduhnya secara lokal dan memasukkannya ke Pandas tanpa masalah (inilah yang dilakukan metode DataFrame.to_pandas()).

Namun dengan dataset masa kini, semuanya dapat dengan cepat tidak terkendali dan kita mungkin harus menunggu berjam-jam untuk mengunduh basis data. Dan ingat, ini tiket dua arah—setiap data baru yang ingin kita simpan juga harus dikirim kembali. Itulah yang membuat mempelajari API Snowpark DataFrame begitu berharga.

Sebagai alternatif, metode Session.sql() memungkinkan kita mengeksekusi ekspresi SQL apa pun yang kompatibel dengan Snowflake (lihat contoh di bawah). Namun, saya sangat menyarankan menguasai API Snowpark DataFrame karena ia memiliki banyak fungsi bawaan untuk lebih dari 100 fungsi dan ekspresi SQL.

result = new_session.sql(
   """
   SELECT PRICE, CUT FROM DIAMONDS LIMIT 10
"""
)

type(result)
snowflake.snowpark.dataframe.DataFrame
result.show()

Hasil dari sebuah ekspresi sql di Snowpark

Fungsi transformasi Snowpark DataFrame

Sebagian besar waktu Anda di Snowpark akan dihabiskan untuk menggunakan fungsi transformasinya. Fungsi-fungsi tersebut tersedia di bawah sub-modul berikut:

# The convention is to import it as F
import snowflake.snowpark.functions as F

Semua fungsi di bawah F (yang dapat Anda daftar dengan memanggil dir(F)) menentukan bagaimana sebuah DataFrame harus ditransformasikan. Mari lihat contoh:

F.upper(F.col("CUT"))

Di sini, fungsi col membuat referensi ke kolom yang diberikan dan mengembalikan objek Column. Lalu, .upper() mengonversi nilai kolom CUT menjadi huruf besar:

diamonds_df.show(5)

Lima baris teratas dari dataset diamonds setelah transformasi Snowpark yang gagal.

Namun jika kita melihat dataset diamonds, kita melihat nilai di kolom CUT masih memiliki huruf kecil. Mengapa demikian? Nah, ekspresi F.upper(F.col("CUT")) setara dengan kueri SQL berikut:

SELECT UPPER(CUT);

Apa yang kurang di sini?

Tentu saja, klausa FROM yang menentukan nama tabel tempat transformasi harus diterapkan!

Jadi, kita harus menggabungkan ekspresi F.upper(F.col("CUT")) dengan objek diamonds_df. Ada tiga cara utama untuk melakukannya:

  • Untuk ekspresi yang mentransformasi atau memilih kolom, masukkan ke dalam .select()
  • Untuk ekspresi yang memilih baris, masukkan ke dalam .filter()
  • Untuk ekspresi yang membuat kolom, masukkan ke dalam .with_column()

Karena ekspresi kita mentransformasi kolom, kita akan memasukkannya ke .select():

our_expression = F.upper(F.col("CUT"))
diamonds_df.select(our_expression).show()

Lima baris teratas dari dataset diamonds setelah transformasi Snowpark yang gagal.

Kita berhasil mengubah nilainya!

Sekarang mari tulis ekspresi yang memfilter baris:

diamonds_df.filter(F.col("PRICE") > 10000).count()
5222

Kita mendapati ada lebih dari 5.000 berlian dalam dataset yang harganya di atas $10.000. Mari coba membuat kolom juga:

(
diamonds_df.with_column("PRICE_SQUARED", F.col("PRICE") ** 2)
.select("PRICE", "PRICE_SQUARED")
.show(5)
)

Hasil transformasi Snowpark yang menggunakan fungsi `.with_column`

Di atas, kita juga menunjukkan bahwa chaining method diperbolehkan—kita memiliki kolom baru bernama “PRICE_SQUARED.” Kita melihat fungsi Snowpark DataFrame mirip dengan milik Pandas.

Singkatnya, jika Anda mencari alternatif Snowpark untuk fungsi Pandas, itu ada di bawah F atau merupakan bagian dari metode Snowpark DataFrames. Anda dapat memeriksa dengan memanggil dir(F) atau dir(diamonds_df) atau membaca referensi Snowpark Python.

Melakukan EDA pada Snowpark DataFrames

Bagian signifikan dari exploratory data analysis (EDA) adalah membuat visual. Untungnya, kita tidak memerlukan Snowpark untuk ini karena kita bisa terus menggunakan modern data stack.

Berikut idenya: Karena EDA bertujuan menemukan tren dan wawasan umum, kita sering kali dapat menggunakan sampel alih-alih seluruh dataset. Setelah mengunduh sampel yang representatif, kita dapat mengonversinya ke Pandas DataFrame dan menggunakan Matplotlib atau Seaborn.

Mari mulai dengan konversinya:

sample = diamonds_df.sample(0.25).to_pandas()
sample.head()

Screenshot 2024-05-03 at 14.19.58.png

Di atas, kita mengunduh 25% dari dataset sebagai Pandas DataFrame. Mari ubah nama kolom menjadi huruf kecil:

sample.columns = [col.lower() for col in sample.columns]
sample.columns
Index(['carat', 'cut', 'color', 'clarity', 'depth', 'table', 'price', 'x', 'y', 'z'], dtype='object')

Sekarang, Anda dapat melakukan EDA seperti pada dataset mana pun. Di bawah ini, kita mengeksplorasi beberapa ide dan mulai dengan membuat scatter plot untuk memvisualisasikan hubungan antara harga dan karat:

#Remember we imported seaborn as sns
sns.scatterplot(data=sample, x="price", y="carat", s=1)
plt.title("Diamond prices vs. carat")
plt.show()

Sebuah scatterplot berlian vs karat

Sekarang mari plot matriks korelasi untuk melihat korelasi antar setiap pasangan fitur numerik:

corr_matrix = sample.corr(numeric_only=True)
sns.heatmap(corr_matrix, center=0, square=True, annot=True
plt.title("The correlation matrix of Diamond numeric features")
plt.show()

Heatmap matriks korelasi dari dataset diamonds

Kita juga dapat membuat bar plot untuk kategori potongan berlian:

cut_counts = sample.groupby("cut")["cut"].count()
cut_counts.plot(kind="bar")
plt.title("Category counts of diamond cuts")
plt.xlabel("Diamond cut")
plt.show()

Sebuah countplot dari potongan berlian.

Untuk mengonfirmasi bahwa plot ini akan kurang lebih sama pada seluruh dataset, kita akan menjalankan versi SQL dari bar plot di atas.

Pertama, kita akan menulis ekspresi SQL untuk mengelompokkan dataset diamonds berdasarkan CUT:

result = new_session.sql(
   """
   SELECT cut, COUNT(*) AS count
     FROM diamonds
    GROUP BY cut;
"""
)

Sekarang, mari konversi dan unduh hasilnya sebagai Pandas DataFrame:

result_pd = result.to_pandas()
result_pd

Bagian dari dataset diamonds

Kali ini, kita akan menggunakan fungsi plt.bar() untuk membuat grafik:

plt.bar(x=result_pd["CUT"], height=result_pd["COUNT"])
plt.show()

Sebuah countplot potongan berlian lagi

Urutan batangnya berbeda tetapi jika dilihat berdampingan, keduanya menyampaikan informasi yang sama.

Melatih Model Machine Learning di Snowpark

Sekarang kita siap mempelajari cara melatih model machine learning di Snowpark!

Kita akan mulai dengan membersihkan dataset.

Membersihkan data di Snowpark

Pertama, mari pastikan semua kolom memiliki tipe data yang benar:

list(diamonds_df.schema)
[StructField('CARAT', DecimalType(38, 2), nullable=True),
StructField('CUT', StringType(16777216), nullable=True),
StructField('COLOR', StringType(16777216), nullable=True),
StructField('CLARITY', StringType(16777216), nullable=True),
StructField('DEPTH', DecimalType(38, 1), nullable=True),
StructField('"table"', DecimalType(38, 1), nullable=True),
StructField('PRICE', LongType(), nullable=True),
StructField('X', DecimalType(38, 2), nullable=True),
StructField('Y', DecimalType(38, 2), nullable=True),
StructField('Z', DecimalType(38, 2), nullable=True)]

Kolom table memiliki nama yang aneh, jadi kita akan mengonversinya menjadi huruf besar TABLE_ (dengan garis bawah di akhir agar tidak bentrok dengan kata kunci SQL bawaan):

diamonds_df = diamonds_df.with_column_renamed('"table"', "TABLE_")
diamonds_df.columns
['CARAT', 'CUT', 'COLOR', 'CLARITY', 'DEPTH', 'TABLE_', 'PRICE', 'X', 'Y', 'Z']

Kita perlu mengubah tipe data fitur numerik dari DecimalType ke DoubleType karena desimal belum didukung di Snowpark.

from snowflake.snowpark.types import DoubleType

numeric_features = ["CARAT", "X", "Y", "Z", "DEPTH", "TABLE_"]
for col in numeric_features:
   diamonds_df = diamonds_df.with_column(col, diamonds_df[col].cast(DoubleType()))

list(diamonds_df.select(*numeric_features))
[Column("CARAT"),
Column("X"),
Column("Y"),
Column("Z"),
Column("DEPTH"),
Column("TABLE_")]

Pada cuplikan di atas, kita kembali menggunakan metode .with_column(). Metode baru lainnya adalah .cast(), yang merupakan bagian dari metode Snowpark DataFrames.

Snowpark juga mengharuskan semua fitur teks berupa huruf besar dan tidak memiliki spasi antar kata sebelum dienkode. Saat ini, nilai fitur CUT melanggar ketentuan ini, jadi kita akan memperbaikinya dengan transformasi fungsi:

import snowflake.snowpark.functions as F

def remove_space_and_upper(df):
   df = df.with_column("CUT", F.upper(F.replace(F.col("CUT"), " ", "_")))

   return df

diamonds_df = remove_space_and_upper(diamonds_df)

Data kita sekarang bebas dari masalah pembersihan. Kita dapat menyimpannya kembali sebagai tabel baru ke Snowflake:

diamonds_df.write.mode("overwrite").save_as_table("diamonds_cleaned")

Pastikan menambahkan mode overwrite karena Anda mungkin harus kembali dan mengubah beberapa operasi pembersihan lalu menyimpan lagi.

Menyiapkan data untuk pemodelan di Snowpark

Di bagian ini, kita akan menangani masalah pra-pemrosesan yang tersisa yang dapat mencegah model dilatih. Mari muat tabel yang sudah dibersihkan dari bagian sebelumnya:

clean_df = new_session.table("diamonds_cleaned")
clean_df.show()

Lima baris teratas dari dataset diamonds yang dibersihkan

Sangat baik!

Selanjutnya, kita akan mengimpor sub-modul preprocessing dan pipeline dari namespace snowflake.ml.

import snowflake.ml.modeling.preprocessing as snowml
from snowflake.ml.modeling.pipeline import Pipeline

Sementara API DataFrame Snowpark tersedia di bawah snowflake.snowpark, modul ML Snowpark berada di snowflake.ml. Ini mungkin membingungkan pada awalnya, jadi luangkan waktu untuk membiasakan diri.

Pada kode di bawah, kita:

  • Mendaftar nama fitur kategorikal yang perlu dienkode.
  • Mendefinisikan nama untuk fitur keluaran karena Snowpark menambahkan fitur yang dienkode sebagai kolom baru alih-alih mengganti yang lama.
  • Menentukan urutan yang benar dari kategori ordinal; pada dataset diamonds, semua kategori memiliki urutan bawaan, menjadi lebih mahal saat bergerak dari kiri ke kanan.
# List all the features for processing
cat_cols = ["CUT", "COLOR", "CLARITY"]
cat_cols_encoded = ["CUT_OE", "COLOR_OE", "CLARITY_OE"]

# We already have numeric_features

# List the correct ordering of categorical features
categories = {
   "CUT": np.array(["IDEAL", "PREMIUM", "VERY_GOOD", "GOOD", "FAIR"]),
   "CLARITY": np.array(
       ["IF", "VVS1", "VVS2", "VS1", "VS2", "SI1", "SI2", "I1", "I2", "I3"]
   ),
   "COLOR": np.array(["D", "E", "F", "G", "H", "I", "J"]),
}

Sekarang kita siap membangun pipeline yang mirip dengan pipeline Scikit-learn:

# Build the pipeline
preprocessing_pipeline = Pipeline(
   steps=[
       (
           "OE",
           snowml.OrdinalEncoder(
               input_cols=cat_cols, output_cols=cat_cols_encoded, categories=categories
           ),
       ),
       (
           "SS",
           snowml.StandardScaler(
               input_cols=numeric_features, output_cols=numeric_features
           ),
       ),
   ]
)

Kelas Pipeline menerima daftar langkah, masing-masing merupakan kelas pra-pemrosesan. Di sini, kita menggunakan OrdinalEncoder untuk mengenkode kategorikal sebagai 0, 1, 3, dll. dan StandardScaler untuk menormalkan fitur numerik.

Pada akhirnya, kita akan menyimpan pipeline secara lokal dengan joblib dan mengujinya pada seluruh dataset:

import joblib
PIPELINE_FILE = "pipeline.joblib"

# Pickle locally first
joblib.dump(preprocessing_pipeline, PIPELINE_FILE)

transformed_diamonds_df = preprocessing_pipeline.fit(clean_df).transform(clean_df)

# transformed_diamonds_df.show() - commented because of long output

Cuplikan berjalan tanpa error, jadi pipeline kita berfungsi, menandakan kita akhirnya dapat melatih model.

Melatih model XGBoost di Snowpark

Untuk melatih model, kita akan mendaftar lagi nama fitur dan target:

# Define the columns again
cat_cols_encoded = ["CUT_OE", "COLOR_OE", "CLARITY_OE"]
numeric_features = ["CARAT", "X", "Y", "Z", "DEPTH", "TABLE_"]

label_cols = ["PRICE"]  # Must be a list
output_cols = ["PRICE_PREDICTED"]  # Required in snowpark

Sekarang kita akan membagi data menggunakan DataFrame.random_split() dan memberikan bobot untuk merepresentasikan fraksi set pelatihan dan pengujian:

# Split the data
train_df, test_df = diamonds_df.random_split(weights=[0.8, 0.2], seed=42)

Lalu, kita akan memuat pipeline dan fit-transform kedua set train dan test.

# Load the pre-processing pipeline locally
pipeline = joblib.load("pipeline.joblib")

# Apply it to both dataframes
train_df_transformed = pipeline.fit(train_df).transform(train_df)
test_df_transformed = pipeline.transform(test_df)

Di atas, pastikan Anda hanya memanggil .transform() pada set test untuk menghindari kebocoran data.

Berikutnya, kita inisialisasi model regressor XGBoost dari ml.modeling.xgboost sub-module:

# Snowpark has models from scikit-learn and lightgbm too
from snowflake.ml.modeling.xgboost import XGBRegressor

# Initialize
regressor = XGBRegressor(
   input_cols=cat_cols_encoded + numeric_features,
   label_cols=label_cols,
   output_cols=output_cols,
)

Kelas XGBRegressor memerlukan semua nama input, semua nama target, dan nama kolom keluaran. Setelah kita memasukkannya, kita panggil .fit() untuk memulai proses pelatihan:

# Train
regressor.fit(train_df_transformed)

Pelatihan mungkin berjalan lambat jika Anda memiliki akun Snowflake gratis yang sumber daya komputasinya terbatas dan tanpa GPU.

Setelah pelatihan selesai, kita dapat menghasilkan prediksi:

# Prediksi

train_preds = regressor.predict(train_df_transformed)
test_preds = regressor.predict(test_df_transformed)

Mari lihat prediksinya:

train_preds.select("PRICE", "PRICE_PREDICTED").show(5)

Prediksi yang dihasilkan dari XGBoost di Snowpark

Sekarang kita harus mengukur sebaik apa performa model awal kita. Snowpark menyertakan puluhan metrik dari Scikit-learn di bawah submodul ml.modeling.metrics yang kita impor sebagai M:

import snowflake.ml.modeling.metrics as M

Lalu, kita jalankan mean_squared_error dua kali untuk mengukur root mean squared error (RMSE) pada set pelatihan dan pengujian (di bawah ini, squared=False mengembalikan RMSE alih-alih MSE):

rmse_train = M.mean_squared_error(
   df=train_preds,
   y_true_col_names=label_cols,
   y_pred_col_names=output_cols,
   squared=False,
)

rmse_test = M.mean_squared_error(
   df=test_preds,
   y_true_col_names=label_cols,
   y_pred_col_names=output_cols,
   squared=False,
)

print(f"Train RMSE score for XGBRegressor: {rmse_train:.4f}")
print(f"Test RMSE score for XGBRegressor: {rmse_test:.4f}")
Train RMSE score for XGBRegressor: 371.9664
Test RMSE score for XGBRegressor: 542.1566

Model kita meleset rata-rata $542 dan mungkin juga overfitting karena perbedaan antara RMSE pelatihan dan pengujian cukup besar.

Mari kita tuning hiperparameter model untuk mengatasi masalah ini.

Tuning hiperparameter di Snowpark

Saat ini, Snowpark menawarkan dua kelas tuning hiperparameter:

  • GridSearchCV: pencarian menyeluruh semua kombinasi hiperparameter dengan cross-validation.
  • RandomizedSearchCV: pencarian acak pada distribusi hiperparameter yang diberikan dengan cross-validation.

XGBoost memiliki sekitar selusin hiperparameter yang dapat meningkatkan performanya (Anda dapat mempelajari lebih lanjut di tutorial ini tentang menggunakan XGBoost di Python). Ini mendorong kita untuk melakukan pencarian acak. Secara pribadi, saya lebih suka menggunakan Optuna yang menggunakan pencarian Bayesian, tetapi kita belum memiliki kemewahan itu di Snowpark.

Sekarang mari definisikan pencariannya:

from snowflake.ml.modeling.model_selection import RandomizedSearchCV

rscv = RandomizedSearchCV(
   estimator=XGBRegressor(),
   param_distributions={
       "n_estimators": [2000],
       "max_depth": list(range(3, 13)),
       "learning_rate": np.linspace(0.1, 0.5, num=10),
   },
   n_jobs=-1,
   scoring="neg_mean_squared_error",
   input_cols=numeric_features + cat_cols_encoded,
   label_cols=label_cols,
   output_cols=output_cols,
   n_iter=10,
)

rscv.fit(train_df_transformed)

Kita menetapkan jumlah estimator ke 2000 dan hanya men-tuning parameter max_depth dan learning_rate. rscv memiliki parameter default n_iter=10, yang berarti pencarian akan dilakukan 10 kali, setiap kali memilih kombinasi parameter acak. Untuk hasil yang lebih akurat, sebaiknya pilih angka yang lebih besar untuk parameter ini.

Sekarang, mari ukur performa model terbaik yang ditemukan. Kodenya sama seperti sebelumnya tetapi alih-alih regressor, kita akan menggunakan objek rscv:

# Predict
train_preds = rscv.predict(train_df_transformed)
test_preds = rscv.predict(test_df_transformed)
rmse_train = M.mean_squared_error(
   df=train_preds,
   y_true_col_names=label_cols,
   y_pred_col_names=output_cols,
   squared=False,
)

optimal_rmse_test = M.mean_squared_error(
   df=test_preds,
   y_true_col_names=label_cols,
   y_pred_col_names=output_cols,
   squared=False,
)

print(f"Train RMSE score for optimal model: {rmse_train:.4f}")
print(f"Test RMSE score for optimal model: {rmse_test:.4f}")
Train RMSE score for optimal model: 224.2405
Test RMSE score for optimal model: 572.0517

RMSE pelatihan turun tetapi RMSE pengujian justru lebih besar. Ini menunjukkan kita masih overfitting dan perlu memperluas pencarian serta menyertakan parameter lain untuk memangkas pohon keputusan yang digunakan XGBoost di balik layar.

Bagian itu saya serahkan kepada Anda.

Menyimpan model terbaik di Snowpark

Jika kita menutup sesi sekarang, kita akan kehilangan model yang telah dituning. Untuk menyimpannya, kita akan menggunakan model registry bawaan Snowpark, yaitu penyimpanan virtual yang dapat Anda gunakan untuk menyimpan model apa pun dan metadata-nya.

Registry tersedia sebagai kelas Registry, dan memerlukan nama database dan skema sesi saat ini. Ini juga mengharuskan kita memberi nama proyek agar tidak terjadi konflik dengan model dari proyek lain:

# Set up for Registry
from snowflake.ml.registry import Registry

# Get the current db and schema name
db_name = new_session.get_current_database()
schema_name = new_session.get_current_schema()

# Define global model name for the project
model_name = "diamond_prices_regression"

# Initialize a registry to log models
registry = Registry(session=new_session, database_name=db_name, schema_name=schema_name)

Kita akan menggunakan metode Registry.log_model() untuk menyimpan model kita:

# Get sample data to pass into registry for schema
sample = train_df.select(cat_cols_encoded + numeric_features).limit(50)

# Log the first model
v0 = registry.log_model(
   model_name=model_name,
   version_name="v0",
   model=regressor,
   sample_input_data=sample,
)

Kita dapat mencatat metrik untuk model dengan metode .set_metric() (kita bisa mencatat sebanyak metrik yang kita mau). Kita juga akan menambahkan komentar untuk mendeskripsikan model:

# Add the models RMSE score
v0.set_metric(metric_name="RMSE", value=rmse_test)

# Add a description
v0.comment = "The first model to predict diamond prices"

Kita lakukan hal yang sama untuk model terbaik yang ditemukan dengan pencarian acak. Saat mencatat metrik, jangan lupa ubah nilainya menjadi optimal_rmse_test.

# Log the optimal model
v1 = registry.log_model(
   model_name=model_name,
   version_name="v1",
   model=regressor,
   sample_input_data=sample,
)

# Add the models RMSE score
v1.set_metric(metric_name="RMSE", value=optimal_rmse_test)

# Add a description
v1.comment = "Optimal model found with RandomizedSearchCV"

Untuk memastikan model tersimpan, Anda dapat memanggil .show_models():

# Confirm the models are added
registry.show_models()

Pelajari lebih lanjut cara mengelola registry dari halaman ini pada dokumentasi pengembang Snowpark.

Melakukan inferensi di Snowpark

Inferensi biasanya dilakukan dengan memilih model terbaik dari registry Anda. Kita dapat melakukannya dengan memfilter hasil .show_models() atau dengan mengambil model langsung dengan tag versinya seperti yang kita lakukan di bawah ini:

# Doing inference with the optimal model
optimal_version = registry.get_model(model_name).version("v1")
results = optimal_version.run(test_df, function_name="predict")

results.columns

Metode get_model() mengembalikan objek model generik, yang berbeda dari XGBRegressor. Itulah mengapa Anda harus memanggil .run() dengan menentukan nama fungsi untuk melakukan inferensi.

Kesimpulan

Dalam tutorial ini, kita membahas kerangka end-to-end untuk melatih model machine learning di Snowflake Snowpark. Kerja bagus!

Kita memulai dengan dataset mentah yang belum dibersihkan dan berakhir dengan model regressor XGBoost yang telah dituning. Kita melakukan semua tindakan di Snowflake Cloud, yang berarti kita tidak perlu menggunakan sumber daya sistem sama sekali.

Kita telah mempelajari betapa efektifnya jenis operasi in-database ini ketika kita memiliki dataset besar—dan bahwa Snowflake Snowpark adalah salah satu alat terbaik di pasar untuk memfasilitasi proses ini.

Jika Anda ingin mempelajari lebih lanjut tentang Snowpark atau Snowflake, lihat sumber daya berikut:

Terima kasih sudah membaca!

Bexruz (Bex) Tuychiev

Penulis

Bexruz (Bex) Tuychiev

Saya adalah kreator konten data science dengan pengalaman lebih dari 2 tahun dan salah satu dengan jumlah pengikut terbesar di Medium. Saya suka menulis artikel mendalam tentang AI dan ML dengan sedikit gaya sarkastik—karena harus ada sesuatu untuk membuatnya tidak terlalu membosankan. Saya telah menghasilkan lebih dari 130 artikel dan satu kursus di DataCamp, dengan satu lagi sedang dalam proses. Konten saya telah dilihat oleh lebih dari 5 juta pasang mata, dan 20 ribu di antaranya menjadi pengikut di Medium dan LinkedIn. 

Topik

Terkait

blogs

40 Pertanyaan Wawancara DBMS Teratas di 2026

blogs

Spaghetti Plot dan Jalur Badai

blogs

Tutorial Korelasi di R