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:
Membuat lingkungan virtual dengan pustaka relevan.
Memasukkan data contoh ke Snowflake.
Membuat sesi Snowpark untuk terhubung ke Snowflake.
Memuat data yang telah diingest ke dalam sesi.
Membuat lingkungan virtual
Untuk tutorial ini, kita akan menggunakan lingkungan conda baru:
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 seabornDidukung oleh
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=snowparkDidukung oleh
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")Didukung oleh
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):
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:
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},)Didukung oleh
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 SessionDidukung oleh
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()Didukung oleh
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:
Membuat lingkungan virtual dengan pustaka relevan.
Mengimpor data contoh ke Snowflake.
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()Didukung oleh
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)Didukung oleh
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 Fimport snowflake.snowpark.functions as FDidukung oleh
Semua fungsi di bawah F (yang dapat Anda daftar dengan memanggil dir(F)) menentukan bagaimana sebuah DataFrame harus ditransformasikan. Mari lihat contoh:
Di sini, fungsi col membuat referensi ke kolom yang diberikan dan mengembalikan objek Column. Lalu, .upper() mengonversi nilai kolom CUT menjadi huruf besar:
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:
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))Didukung oleh
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()Didukung oleh
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.columnsDidukung oleh
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()Didukung oleh
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()Didukung oleh
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()Didukung oleh
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;
""")Didukung oleh
Sekarang, mari konversi dan unduh hasilnya sebagai Pandas DataFrame:
result_pd = result.to_pandas()
result_pdDidukung oleh
Kali ini, kita akan menggunakan fungsi plt.bar() untuk membuat grafik:
plt.bar(x=result_pd["CUT"], height=result_pd["COUNT"])
plt.show()Didukung oleh
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:
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.columnsDidukung oleh
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))Didukung oleh
[Column("CARAT"),
Column("X"),
Column("Y"),
Column("Z"),
Column("DEPTH"),
Column("TABLE_")]Didukung oleh
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
defremove_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)Didukung oleh
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")Didukung oleh
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()Didukung oleh
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 PipelineDidukung oleh
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"]),}Didukung oleh
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
),),])Didukung oleh
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 outputDidukung oleh
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 snowparkDidukung oleh
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)Didukung oleh
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)Didukung oleh
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 toofrom snowflake.ml.modeling.xgboost import XGBRegressor
# Initialize
regressor = XGBRegressor(
input_cols=cat_cols_encoded + numeric_features,
label_cols=label_cols,
output_cols=output_cols,)Didukung oleh
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)Didukung oleh
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)Didukung oleh
Mari lihat prediksinya:
train_preds.select("PRICE","PRICE_PREDICTED").show(5)Didukung oleh
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 MDidukung oleh
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}")Didukung oleh
Train RMSE score for XGBRegressor: 371.9664
Test RMSE score for XGBRegressor: 542.1566Didukung oleh
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.
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:
Train RMSE score for optimal model: 224.2405
Test RMSE score for optimal model: 572.0517Didukung oleh
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 Registryfrom 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)Didukung oleh
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,)Didukung oleh
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"Didukung oleh
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"Didukung oleh
Untuk memastikan model tersimpan, Anda dapat memanggil .show_models():
# Confirm the models are added
registry.show_models()Didukung oleh
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.columnsDidukung oleh
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:
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.
Kuasai pertanyaan wawancara basis data, dari konsep SQL dasar hingga skenario desain sistem tingkat lanjut. Panduan mendalam ini mencakup semua yang Anda perlukan untuk sukses di wawancara DBMS dan meraih peran berikutnya.
Temukan alasan mengapa Anda sebaiknya (tidak) menggunakan spaghetti plot untuk menyampaikan ketidakpastian jalur prediksi badai serta dampaknya terhadap interpretasi.
Dapatkan keterampilan yang sangat dicari untuk mengelola data dengan efisien, termasuk mengimpor, membersihkan, mengelola data, serta menjadwalkan dan memantau pipeline, sehingga Anda dapat menonjol di bidang data engineering.
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:
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:
Membuat lingkungan virtual
Untuk tutorial ini, kita akan menggunakan lingkungan
condabaru:Sebagai catatan, jika Anda menjalankan pada lingkungan
condayang baru diinstal, Anda perlu menjalankan$conda initsebelum mengaktifkan lingkungansnowpark.Setelah aktivasi, kita perlu memasang pustaka berikut:
Jika Anda akan menggunakan Jupyter, pasang juga
ipykerneldan jalankan perintah berikut agar lingkungan yang kita gunakan ditambahkan sebagai kernel Jupyter:Sekarang mari impor beberapa pustaka umum yang akan kita perlukan di sepanjang jalan:
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):
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:
Buat file terpisah bernama
config.pyyang berisi satu kamus bernamacredentialsdengan format berikut:Demi keamanan, kami menyimpan kredensial di file terpisah. Menambahkan file ini ke
.gitignorememastikan kredensial Snowflake Anda tidak bocor secara tidak sengaja.Sekarang, kita impor kamus
credentialsdan kelasSessiondari Snowpark:Untuk membuat koneksi, kita akan menggunakan metode
Session.builder.configs.create():Jika nama pengguna Anda tercetak, sesi pertama Anda berhasil dibuat!
Memuat data yang diingest ke dalam sesi
Objek
new_sessionmemiliki 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_dbyang telah kita buat pada bagian sebelumnya:Kita melakukan ini menggunakan metode .sql, yang memungkinkan kita menjalankan kueri apa pun yang kompatibel dengan Snowflake SQL.
Sekarang, kita dapat memuat tabel
diamondsdaritest_dbmenggunakan metode table dari objek sesi:Metode
.show()setara denganDataFrame.describe()milik Pandas, dan menunjukkan bahwa kita telah berhasil terhubung ke tabel.Benar sekali—kita hanya terhubung ke tabel diamonds. Objek
diamonds_dftidak menampung data apa pun seperti dibuktikan oleh ukurannya: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:
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:
Kapan menggunakan Snowpark DataFrames
Karena Snowpark dapat dikonversi ke Pandas DataFrames, kapan sebaiknya kita menggunakan salah satunya?
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.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:
Semua fungsi di bawah
F(yang dapat Anda daftar dengan memanggildir(F)) menentukan bagaimana sebuah DataFrame harus ditransformasikan. Mari lihat contoh:Di sini, fungsi col membuat referensi ke kolom yang diberikan dan mengembalikan objek
Column. Lalu,.upper()mengonversi nilai kolom CUT menjadi huruf besar:Namun jika kita melihat dataset diamonds, kita melihat nilai di kolom
CUTmasih memiliki huruf kecil. Mengapa demikian? Nah, ekspresiF.upper(F.col("CUT"))setara dengan kueri SQL berikut:Apa yang kurang di sini?
Tentu saja, klausa
FROMyang menentukan nama tabel tempat transformasi harus diterapkan!Jadi, kita harus menggabungkan ekspresi
F.upper(F.col("CUT"))dengan objekdiamonds_df. Ada tiga cara utama untuk melakukannya:.select().filter().with_column()Karena ekspresi kita mentransformasi kolom, kita akan memasukkannya ke
.select():Kita berhasil mengubah nilainya!
Sekarang mari tulis ekspresi yang memfilter baris:
Kita mendapati ada lebih dari 5.000 berlian dalam dataset yang harganya di atas $10.000. Mari coba membuat kolom juga:
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)ataudir(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:
Di atas, kita mengunduh 25% dari dataset sebagai Pandas DataFrame. Mari ubah nama kolom menjadi huruf kecil:
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:
Sekarang mari plot matriks korelasi untuk melihat korelasi antar setiap pasangan fitur numerik:
Kita juga dapat membuat bar plot untuk kategori 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:
Sekarang, mari konversi dan unduh hasilnya sebagai Pandas DataFrame:
Kali ini, kita akan menggunakan fungsi
plt.bar()untuk membuat grafik: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:
Kolom
tablememiliki nama yang aneh, jadi kita akan mengonversinya menjadi huruf besarTABLE_(dengan garis bawah di akhir agar tidak bentrok dengan kata kunci SQL bawaan):Kita perlu mengubah tipe data fitur numerik dari
DecimalTypekeDoubleTypekarena desimal belum didukung di Snowpark.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
CUTmelanggar ketentuan ini, jadi kita akan memperbaikinya dengan transformasi fungsi:Data kita sekarang bebas dari masalah pembersihan. Kita dapat menyimpannya kembali sebagai tabel baru ke Snowflake:
Pastikan menambahkan mode
overwritekarena 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:
Sangat baik!
Selanjutnya, kita akan mengimpor sub-modul
preprocessingdanpipelinedari namespacesnowflake.ml.Sementara API DataFrame Snowpark tersedia di bawah
snowflake.snowpark, modul ML Snowpark berada disnowflake.ml. Ini mungkin membingungkan pada awalnya, jadi luangkan waktu untuk membiasakan diri.Pada kode di bawah, kita:
Sekarang kita siap membangun pipeline yang mirip dengan pipeline Scikit-learn:
Kelas
Pipelinemenerima daftar langkah, masing-masing merupakan kelas pra-pemrosesan. Di sini, kita menggunakanOrdinalEncoderuntuk mengenkode kategorikal sebagai 0, 1, 3, dll. danStandardScaleruntuk menormalkan fitur numerik.Pada akhirnya, kita akan menyimpan pipeline secara lokal dengan
joblibdan mengujinya pada seluruh dataset: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:
Sekarang kita akan membagi data menggunakan
DataFrame.random_split()dan memberikan bobot untuk merepresentasikan fraksi set pelatihan dan pengujian:Lalu, kita akan memuat pipeline dan fit-transform kedua set train dan test.
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:Kelas
XGBRegressormemerlukan semua nama input, semua nama target, dan nama kolom keluaran. Setelah kita memasukkannya, kita panggil.fit()untuk memulai proses pelatihan: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
Mari lihat prediksinya:
Sekarang kita harus mengukur sebaik apa performa model awal kita. Snowpark menyertakan puluhan metrik dari Scikit-learn di bawah submodul
ml.modeling.metricsyang kita impor sebagaiM:Lalu, kita jalankan
mean_squared_errordua kali untuk mengukur root mean squared error (RMSE) pada set pelatihan dan pengujian (di bawah ini,squared=Falsemengembalikan RMSE alih-alih MSE):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:
Kita menetapkan jumlah estimator ke 2000 dan hanya men-tuning parameter
max_depthdanlearning_rate.rscvmemiliki parameter defaultn_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 objekrscv: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:Kita akan menggunakan metode
Registry.log_model()untuk menyimpan model kita: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:Kita lakukan hal yang sama untuk model terbaik yang ditemukan dengan pencarian acak. Saat mencatat metrik, jangan lupa ubah nilainya menjadi
optimal_rmse_test.Untuk memastikan model tersimpan, Anda dapat memanggil
.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:Metode
get_model()mengembalikan objekmodelgenerik, yang berbeda dariXGBRegressor. 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!