Snowflake Snowpark: Kapsamlı Bir Giriş

Snowflake Snowpark nedir?

Geleneksel makine öğrenimi, verileri veritabanlarından modellerin bulunduğu yere taşımayı içerir. Yapay zekâdaki son patlama ve günümüz veri kümelerinin boyutu göz önüne alındığında, bu yaklaşım giderek daha uygulanamaz hale geliyor.

Temizlik, analiz ve model eğitimi için terabaytlarca verinin veritabanından istemci tarafı uygulamalara aktarılması gerekir. Görünüşte masum olan bu gidiş-dönüş yolculuk, değerli kaynakları boşa harcar. Bu nedenle, giderek daha fazla şirket, veri hareketini en aza indirmek ve veri işlemlerini sorunsuz yürütmek için veritabanı içi teknolojileri tercih ediyor.

Pazardaki en iyi veritabanı içi teknolojilerden biri, Snowflake Cloud tarafından sunulan Snowpark'tır. Snowpark, Snowflake veritabanlarınızla aynı ortamda veri işlem hatları ve makine öğrenimi modelleri geliştirmek için programlama dillerini Snowflake Cloud içinde güvenli bir şekilde çalıştırmanıza olanak tanıyan kütüphane ve çalışma zamanı kümeleridir.

Bu eğitimde, Snowpark'ın temellerini ve bunu projelerinizde nasıl kullanabileceğinizi ele alacağız. SQL ve Snowflake'e zaten aşina olduğunuzu varsayıyoruz—önce bunları öğrenmeniz gerekiyorsa, SQL Temel Yetenek Yolumuzu alabilir veya şu Yeni Başlayanlar için Snowflake Eğitimi'ni okuyabilirsiniz.

Hadi başlayalım!

Neden Snowflake Snowpark?

Snowflake Snowpark, Python, Java ve Scala gibi programlama dillerini Snowflake'in bulut platformu içinde doğrudan veri işlemek için güvenli biçimde kullanmanıza olanak tanıyan kütüphane ve çalışma zamanlarından oluşur.

Bu da veriyi işlemek için Snowflake dışına taşıma ihtiyacını ortadan kaldırarak verimliliği ve güvenliği artırır. Başlıca avantajları şunlardır:

• Veriyi Snowflake içinde işleyin: Snowflake'teki SQL veritabanlarınızı tercih ettiğiniz dilde manipüle edip analiz etmek için kod yazın ve bunu Snowflake'in güvenli ortamlarında yürütün. Böylece veriyi başka bir ortama taşımanız gerekmez.
• Geliştirilmiş performans: Veriyi doğrudan Snowflake içinde işleyerek, Snowpark platformun esnek ve sunucusuz mimarisinden verimli işlem için yararlanabilir.
• Azaltılmış maliyet ve teknoloji yükü: Kaynakların çoğunu Snowflake sağladığından, hesaplama ve depolama için ayrı platformları yönetmek zorunda değilsiniz.
• Bildik araçlarla, istediğiniz yerde çalışın: Snowpark'ın API'leri Jupyter veya VSCode gibi herhangi bir ortamdan SQL veritabanlarınıza bağlanmanıza ve veri işlem hatları ile ML uygulamaları oluşturmanıza olanak tanır. En iyi yanıysa, Pandas, Scikit-learn, XGBoost vb. favori kütüphanelerinizi Snowpark çerçeveleriyle birlikte kullanabilmenizdir.

Kısacası, Snowpark geliştiricilerin Snowflake Cloud içinde doğrudan veri işlem hatları, makine öğrenimi çözümleri ve veri odaklı uygulamalar geliştirmesi için güçlü ama basit bir yoldur.

Snowpark ile Başlarken

Bu eğitimdeki nihai hedefimiz, Snowpark kullanarak bir Snowflake veritabanı tablosu üzerinde eğitilmiş, hiperparametre ayarlı bir model oluşturmaktır. Bunu yapmak için şu adımlarla başlayacağız:

1. İlgili kütüphanelerle bir sanal ortam oluşturma.
2. Örnek verileri Snowflake'e alma.
3. Snowflake'e bağlanmak için bir Snowpark oturumu oluşturma.
4. Alınan verileri oturuma yükleme.

Sanal ortam oluşturma

Bu eğitim için yeni bir conda ortamı kullanacağız:

$ conda create -n snowpark python==3.10 -y
$ conda activate snowparkAltyapı:

Not: Yeni kurulmuş bir conda ortamında çalışıyorsanız, $conda init komutunu snowpark ortamını etkinleştirmeden önce çalıştırmanız gerekir.

Etkinleştirdikten sonra aşağıdaki kütüphaneleri kurmamız gerekiyor:

$ pip install snowflake-snowpark-python #The Snowpark API
$ pip install pandas pyarrow numpy matplotlib seabornAltyapı:

Jupyter kullanacaksanız, ayrıca ipykernel kurun ve kullandığımız ortamın bir Jupyter çekirdeği olarak eklenmesi için aşağıdaki komutu çalıştırın:

$ pip install ipykernel
$ ipython kernel install --user --name=snowparkAltyapı:

Şimdi yol boyunca ihtiyaç duyacağımız bazı genel kütüphaneleri içe aktaralım:

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

Örnek verileri Snowflake'e alma

Bu eğitim için Seaborn'un Diamonds veri setini kullanacağız—CSV dosyasını doğrudan GitHub'ımdan indirebilirsiniz.

Snowflake uygulamasına giriş yaptıktan sonra, veri setini yeni bir veritabanı tablosuna almak için aşağıdaki GIF'i izleyin (henüz hesabınız yoksa yeni bir hesap oluşturun):

Pratikte, CSV dosyalarını Snowflake veritabanlarınıza tablo olarak içe aktarmanız nadirdir. Çoğu zaman, şirketinizin veritabanı yöneticileri tarafından size verilen farklı erişim düzeylerine sahip mevcut veritabanlarıyla çalışırsınız.

Bir Snowpark oturumu oluşturma

Artık veritabanımızı sorgulamak için Snowpark API'si ile Snowflake bulutu arasında bir bağlantı kurmalıyız. Bu bağlantı, şu Snowflake kimlik bilgilerini gerektirir: hesap adı, kullanıcı adı ve parola.

Aşağıdaki görselde, kullanıcı adınızı ve hesap adınızı Snowflake panosundan nasıl alabileceğinizi gösteriyorum:

credentials adlı tek bir sözlük içeren config.py adlı ayrı bir dosya oluşturun ve şu biçimi kullanın:

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

Güvenlik nedeniyle kimlik bilgilerini ayrı bir dosyada saklıyoruz. Bu dosyayı .gitignore'a eklemek, Snowflake kimlik bilgilerinizin yanlışlıkla sızmasını önler.

Şimdi credentials sözlüğünü ve Snowpark'ın Session sınıfını içe aktaralım:

from config import credentials
from snowflake.snowpark import SessionAltyapı:

Bağlantı kurmak için Session.builder.configs.create() yöntemini kullanacağız:

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

new_session = Session.builder.configs(connection_parameters).create()
new_session.get_current_user()Altyapı:

'"bexgboost"'Altyapı:

Kullanıcı adınız yazdırıldıysa, ilk oturumunuz başarıyla oluşturulmuş demektir!

Alınan verileri bir oturuma yükleme

new_session nesnesi, hesabınızın Snowflake'te sahip olduğu (ve erişim izniniz olan) her şeye erişebilir.

Verileri içe aktarmadan önce yapacağımız ilk adım, önceki bölümde oluşturduğumuz test_db veritabanını kullandığımızı oturuma söylemektir:

new_session.sql("USE DATABASE test_db;").collect()Altyapı:

[Row(status='Statement executed successfully.')]Altyapı:

Bunu, Snowflake ile uyumlu herhangi bir SQL sorgusunu çalıştırmamıza olanak tanıyan .sql yöntemiyle yapıyoruz.

Artık oturum nesnesinin table yöntemini kullanarak test_db'nin diamonds tablosunu yükleyebiliriz:

diamonds_df = new_session.table("diamonds")
diamonds_df.show(5)Altyapı:

.show() yöntemi, Pandas'ın DataFrame.describe() yönteminin karşılığıdır ve tabloya başarıyla bağlandığımızı gösterir.

Doğru—yalnızca diamonds tablosuna bağlandık. Boyutundan da anlaşılacağı üzere diamonds_df nesnesi herhangi bir veri tutmuyor:

import sys
sys.getsizeof(diamonds_df)Altyapı:

48Altyapı:

Sadece 48 bayt, oysa 3 MB'ın üzerinde olmalıydı. Bunun neden olduğunu anlamak için biraz daha zaman harcayalım.

Snowpark DataFrame'lerini Anlamak

Şimdiye kadar şu adımları ele aldık:

1. İlgili kütüphanelerle bir sanal ortam oluşturduk.
2. Örnek verileri Snowflake'e aldık.
3. Bağlanmak için bir Snowpark oturumu oluşturduk.

Şimdi Snowpark DataFrame'lerini tartışalım!

Snowpark DataFrame'leri tembeldir (lazy)

Pandas DataFrame'leri RAM'inizi kullanır, yani makinenizde yaşarlar. Buna karşılık, Snowpark DataFrame'leri kodlama ortamınızda temsillerini görebilseniz de Snowflake'in bulut platformunda yaşar. Veriler bulutta kalır ve üzerinde işlem yapmak için yerel makinenize indirilmesi gerekmez.

Snowpark DataFrame'lerinin bir diğer önemli yönü, tembel (lazy) çalışmalarıdır. Bu, siz özellikle söylemedikçe veri üzerinde herhangi bir işlemi yürütmedikleri anlamına gelir.

Bunun yerine, istenen işlemlerin mantıksal bir temsilini oluştururlar ve bu daha sonra Snowflake'in yürüteceği optimize edilmiş SQL sorgularına çevrilir.

Karşılaştırma yapmak gerekirse, Pandas işlemleri anında yürütür—diğer bir deyişle, hevesli (eager) yürütme yapar.

Performans açısından, tembel değerlendirme her zaman hevesli yürütmeden önemli ölçüde daha hızlıdır. Tembel DataFrame'ler Snowflake'in güçlü esnek hesaplama kaynaklarını kullandığından, işlemleri veritabanı seviyesine kadar itebilir ve çok daha hızlı çalıştırabilir.

Tembel değerlendirme ile hevesli yürütme arasındaki farkı daha iyi anlamak için, Snowflake'teki verilerimizin dev bir kütüphane olduğunu hayal edin. İki senaryomuz var:

• Hevesli yürütme (Pandas DataFrame'leri): İhtiyacımız olan tüm kitapları masamıza (yerel makine) toplar ve sonra tek tek analiz ederiz.
• Tembel değerlendirme (Snowpark DataFrame'leri): Kütüphaneciye (Snowpark) hangi kitaplara ihtiyaç duyduğumuzu ve hangi analizi yapmak istediğimizi söyleriz; kütüphaneci ilgili bilgileri verimli bir şekilde alır ve analiz eder.

Snowpark DataFrame'leri ne zaman kullanılmalı

Snowpark, Pandas DataFrame'lerine dönüştürebildiğine göre, hangisini ne zaman kullanmalıyız?

pandas_diamonds = diamonds_df.to_pandas()
pandas_diamonds.head()Altyapı:

Yanıt büyük ölçüde veri setinin boyutuna bağlıdır.

Veri setiniz küçükse (Diamonds veri seti gibi), onu yerel olarak indirip sorun yaşamadan Pandas'a besleyebilirsiniz (DataFrame.to_pandas() yöntemi tam olarak bunu yapar).

Ancak günümüz veri setlerinde işler hızla kontrolden çıkabilir ve veritabanımızın indirilmesi için saatlerce beklemek zorunda kalabiliriz. Ve unutmayın, bu gidiş-dönüş bir bilettir—korumak istediğimiz yeni verilerin de geri gönderilmesi gerekir. İşte bu nedenle Snowpark DataFrame API'sini öğrenmek çok değerlidir.

Alternatif olarak, Session.sql() yöntemi Snowflake ile uyumlu herhangi bir SQL ifadesini yürütmemize olanak tanır (aşağıdaki örneğe bakın). Ancak, 100'ün üzerinde SQL fonksiyonu ve ifadesi için birçok yerleşik işleve sahip olduğundan Snowpark DataFrame API'sine hâkim olmanızı şiddetle tavsiye ederim.

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

type(result)
Altyapı:

snowflake.snowpark.dataframe.DataFrameAltyapı:

result.show()Altyapı:

Snowpark DataFrame dönüşüm fonksiyonları

Snowpark'ta zamanınızın büyük kısmını dönüşüm fonksiyonlarını kullanarak geçireceksiniz. Bunlar aşağıdaki alt modül altında mevcuttur:

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

F altındaki tüm fonksiyonlar (bunları dir(F) çağırarak listeleyebilirsiniz) bir DataFrame'in nasıl dönüştürülmesi gerektiğini belirtir. Bir örneğe bakalım:

F.upper(F.col("CUT"))Altyapı:

Burada, col fonksiyonu verilen sütuna bir referans oluşturur ve bir Column nesnesi döndürür. Ardından, .upper() CUT sütunundaki değerleri büyük harfe çevirir:

diamonds_df.show(5)Altyapı:

Ancak diamonds veri setine baktığımızda, CUT sütunundaki değerlerin hâlâ küçük harf içerdiğini görüyoruz. Neden? Çünkü F.upper(F.col("CUT")) ifadesi aşağıdaki SQL sorgusuna denktir:

SELECT UPPER(CUT);Altyapı:

Burada ne eksik?

Elbette, dönüşümün uygulanacağı tablo adını belirten FROM ifadesi!

Dolayısıyla, F.upper(F.col("CUT")) ifadesini diamonds_df nesnesiyle birleştirmeliyiz. Bunu yapmanın üç ana yolu vardır:

• Sütunları dönüştüren veya seçen ifadeler için, .select() içine geçirin
• Satır seçen ifadeler için, .filter() içine geçirin
• Sütun oluşturan ifadeler için, .with_column() içine geçirin

İfademiz bir sütunu dönüştürdüğünden, onu .select()'e vereceğiz:

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

Değerleri başarıyla değiştirdik!

Şimdi satırları filtreleyen bir ifade yazalım:

diamonds_df.filter(F.col("PRICE") > 10000).count()Altyapı:

5222Altyapı:

Veri setimizde 10.000 $'ın üzerinde maliyete sahip 5000'den fazla pırlanta olduğunu görüyoruz. Bir sütun da oluşturalım:

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

Yukarıda, yöntem zincirlemenin de mümkün olduğunu gösteriyoruz—“PRICE_SQUARED” adlı yeni bir sütunumuz var. Snowpark DataFrame işlevlerinin Pandas'a benzer olduğunu görüyoruz.

Özetle, bir Pandas fonksiyonunun Snowpark karşılığını arıyorsanız, ya F altında ya da Snowpark DataFrame yöntemlerinin bir parçasıdır. dir(F) veya dir(diamonds_df) çağırarak ya da Snowpark Python referansını okuyarak kontrol edebilirsiniz.

Snowpark DataFrame'lerinde EDA (Keşifsel Veri Analizi) Yapma

Keşifsel veri analizinin (EDA) önemli bir kısmı görselleştirmeler oluşturmaktır. Neyse ki, bunun için Snowpark'a ihtiyacımız yok; modern veri yığınını kullanmaya devam edebiliriz.

Fikir şu: EDA genel eğilimleri ve içgörüleri keşfetmekle ilgili olduğundan, çoğu zaman tüm veri seti yerine bir örneklem kullanabiliriz. Temsil edici bir örneklem indirdikten sonra, onu Pandas DataFrame'e dönüştürebilir ve eski dost Matplotlib veya Seaborn'u kullanabiliriz.

Dönüşümle başlayalım:

sample = diamonds_df.sample(0.25).to_pandas()
sample.head()Altyapı:

Yukarıda, veri setinin %25'ini bir Pandas DataFrame olarak indiriyoruz. Sütun adlarını küçük harfe çevirelim:

sample.columns = [col.lower() for col in sample.columns]
sample.columnsAltyapı:

Index(['carat', 'cut', 'color', 'clarity', 'depth', 'table', 'price', 'x', 'y', 'z'], dtype='object')Altyapı:

Artık herhangi bir veri setinde yaptığınız gibi EDA yapabilirsiniz. Aşağıda bazı olası fikirleri keşfediyoruz ve fiyat ile karat arasındaki ilişkiyi görselleştirmek için bir saçılım grafiği oluşturarak başlıyoruz:

#Remember we imported seaborn as sns
sns.scatterplot(data=sample, x="price", y="carat", s=1)
plt.title("Elmas fiyatları vs. karat")
plt.show()Altyapı:

Şimdi de tüm sayısal özellik çiftleri arasındaki korelasyonu görmek için bir korelasyon matrisi çizelim:

corr_matrix = sample.corr(numeric_only=True)
sns.heatmap(corr_matrix, center=0, square=True, annot=True
plt.title("Elmas sayısal özelliklerinin korelasyon matrisi")
plt.show()Altyapı:

Elmas kesim kategorilerinin bir çubuk grafiğini de oluşturabiliriz:

cut_counts = sample.groupby("cut")["cut"].count()
cut_counts.plot(kind="bar")
plt.title("Elmas kesimlerinin kategori sayıları")
plt.xlabel("Elmas kesimi")
plt.show()Altyapı:

Bu grafiklerin tüm veri setinde de yaklaşık olarak aynı olacağını teyit etmek için, yukarıdaki çubuk grafiğin SQL sürümünü çalıştıracağız.

Önce, diamonds veri setini CUT'a göre gruplamak için bir SQL ifadesi yazacağız:

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

Şimdi sonucu bir Pandas DataFrame olarak dönüştürüp indirelim:

result_pd = result.to_pandas()
result_pdAltyapı:

Bu kez grafiği oluşturmak için plt.bar() fonksiyonunu kullanacağız:

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

Çubukların sırası farklı ama yan yana bakıldığında aynı bilgiyi verdikleri görülüyor.

Snowpark'ta Bir Makine Öğrenimi Modeli Eğitme

Artık Snowpark'ta makine öğrenimi modellerinin nasıl eğitileceğini öğrenmeye hazırız!

Veri setini temizlemekle başlayacağız.

Snowpark'ta veri temizleme

Önce, tüm sütunların doğru veri tipine sahip olduğundan emin olalım:

list(diamonds_df.schema)Altyapı:

[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)]Altyapı:

table sütunu tuhaf bir ada sahip, bu yüzden onu büyük harf TABLE_'a (yerleşik bir SQL anahtar kelimesiyle çakışmaması için sonda alt çizgiyle) dönüştüreceğiz:

diamonds_df = diamonds_df.with_column_renamed('"table"', "TABLE_")
diamonds_df.columnsAltyapı:

['CARAT', 'CUT', 'COLOR', 'CLARITY', 'DEPTH', 'TABLE_', 'PRICE', 'X', 'Y', 'Z']Altyapı:

Sayısal özelliklerin veri tipini DecimalType'tan DoubleType'a değiştirmemiz gerekecek çünkü ondalıklar Snowpark'ta henüz desteklenmiyor.

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))Altyapı:

[Column("CARAT"),
Column("X"),
Column("Y"),
Column("Z"),
Column("DEPTH"),
Column("TABLE_")]Altyapı:

Yukarıdaki parçada, yine .with_column() yöntemini kullanıyoruz. Yeni bir yöntem de Snowpark DataFrame yöntemlerinin bir parçası olan .cast().

Snowpark ayrıca, metin özelliklerinin kodlanmadan önce büyük harfle yazılmasını ve kelimeler arasında boşluk olmamasını gerektirir. Şu anda CUT özelliğinin değerleri bu gereksinimi ihlal ediyor, bu yüzden bunu fonksiyon dönüşümleriyle düzelteceğiz:

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)
Altyapı:

Artık verilerimiz temizlik sorunlarından arınmış durumda. Bunu Snowflake'e yeni bir tablo olarak geri kaydedebiliriz:

diamonds_df.write.mode("overwrite").save_as_table("diamonds_cleaned")Altyapı:

Bazı temizlik işlemlerini geri dönüp değiştirmek ve tekrar kaydetmek zorunda kalabileceğiniz için overwrite modunu eklediğinizden emin olun.

Snowpark'ta modelleme için veriyi hazırlama

Bu bölümde, modellersenizi eğitmeyi engelleyebilecek kalan ön işleme sorunlarını ele alacağız. Önce önceki bölümden temizlenmiş tabloyu yükleyelim:

clean_df = new_session.table("diamonds_cleaned")
clean_df.show()Altyapı:

Çok iyi!

Sonra, snowflake.ml ad alanından preprocessing ve pipeline alt modüllerini içe aktaracağız.

import snowflake.ml.modeling.preprocessing as snowml
from snowflake.ml.modeling.pipeline import PipelineAltyapı:

Snowpark'ın DataFrame API'si snowflake.snowpark altında yer alırken, Snowpark ML modülleri snowflake.ml içinde bulunur. Başta kafa karıştırıcı olabilir, alışmak için zaman ayırın.

Aşağıdaki kodda şunları yapıyoruz:

• Kodlanması gereken kategorik özellik adlarını listeliyoruz.
• Snowpark, kodlanmış özellikleri eskilerinin yerine koymak yerine yeni sütunlar olarak eklediğinden, çıkış özellikleri için adlar tanımlıyoruz.
• Ordinal kategorilerin doğru sırasını tanımlıyoruz; diamonds veri setinde tüm kategorilerin doğuştan bir sıralaması vardır ve soldan sağa gittikçe daha pahalı hale gelirler.

# 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"]),
}Altyapı:

Şimdi Scikit-learn hattına benzer bir işlem hattı oluşturmaya hazırız:

# 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
           ),
       ),
   ]
)
Altyapı:

Pipeline sınıfı, her biri bir ön işleme sınıfı olan adım listesini kabul eder. Burada kategorikleri 0, 1, 3 vb. olarak kodlamak için OrdinalEncoder ve sayısal özellikleri normalize etmek için StandardScaler kullanıyoruz.

Sonunda, hattı yerelde joblib ile kaydedecek ve tüm veri setinde test edeceğiz:

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 outputAltyapı:

Parça hatasız çalışıyor; yani hattımız çalışıyor ve nihayet bir model eğitebileceğimizin sinyalini veriyor.

Snowpark'ta bir XGBoost modeli eğitme

Bir model eğitmek için, özellik adlarını ve hedef adlarını tekrar listeleyeceğiz:

# 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 snowparkAltyapı:

DataFrame.random_split() kullanarak veriyi böleceğiz ve eğitim ile test setlerinin oranlarını temsil eden ağırlıklar vereceğiz:

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

Ardından hattı yükleyip hem eğitim hem test setlerine fit-transform uygulayacağız.

# 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)Altyapı:

Yukarıda, veri sızıntısını önlemek için test setinde yalnızca .transform() çağırdığınızdan emin olun.

Sonraki adımda, ml.modeling.xgboost alt modülünden bir XGBoost regresör modeli başlatacağız:

# 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,
)Altyapı:

XGBRegressor sınıfı tüm girdi adlarını, tüm hedef adlarını ve çıktı sütunu adlarını gerektirir. Bunları girdikten sonra, eğitim sürecini başlatmak için .fit() çağırırız:

# Train
regressor.fit(train_df_transformed)Altyapı:

Ücretsiz bir Snowflake hesabınız varsa sınırlı hesaplama kaynakları ve GPU olmadığı için eğitim yavaş çalışabilir.

Eğitim tamamlandığında tahminler üretebiliriz:

# Tahmin

train_preds = regressor.predict(train_df_transformed)
test_preds = regressor.predict(test_df_transformed)Altyapı:

Tahminlere bir göz atalım:

train_preds.select("PRICE", "PRICE_PREDICTED").show(5)Altyapı:

Şimdi ilk modelimizin ne kadar iyi olduğunu ölçmemiz gerekiyor. Snowpark, ml.modeling.metrics alt modülü altında Scikit-learn'den düzinelerce metriği içerir ve biz bunu M olarak içe aktarırız:

import snowflake.ml.modeling.metrics as MAltyapı:

Ardından, hem eğitim hem test setleri üzerinde kök ortalama kare hatayı (RMSE) ölçmek için mean_squared_error'ı iki kez çalıştırırız (aşağıda, squared=False RMSE döndürür, MSE değil):

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}")Altyapı:

Train RMSE score for XGBRegressor: 371.9664
Test RMSE score for XGBRegressor: 542.1566Altyapı:

Modelimiz ortalama 542 $ sapma gösteriyor ve eğitim ile test RMSE'leri arasındaki fark büyük olduğu için biraz aşırı uyum (overfit) da ediyor olabilir.

Bu sorunları ele almak için modelin hiperparametrelerini ayarlayalım.

Snowpark'ta hiperparametre ayarı

Şu anda Snowpark iki hiperparametre ayarlama sınıfı sunuyor:

• GridSearchCV: çapraz doğrulama ile tüm hiperparametre kombinasyonlarının kapsamlı aranması.
• RandomizedSearchCV: çapraz doğrulama ile verilen hiperparametre dağılımlarının rastgele aranması.

XGBoost'un performansını artırabilecek bir düzine kadar hiperparametresi vardır (Python'da XGBoost kullanımı üzerine bu eğitimde daha fazla bilgi edinebilirsiniz). Bu da bizi rastgele arama yapmaya iter. Şahsen, Bayesçi arama kullanan Optuna'yı tercih ederdim ancak Snowpark'ta henüz bu imkâna sahip değiliz.

Şimdi aramayı tanımlayalım:

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)
Altyapı:

Tahminci sayısını 2000'e sabitliyor ve yalnızca max_depth ile learning_rate parametrelerini ayarlıyoruz. rscv'de varsayılan n_iter=10 parametresi vardır; bu da aramanın 10 kez yapılacağı ve her seferinde rastgele bir parametre kombinasyonunun seçileceği anlamına gelir. Daha doğru sonuçlar için bu parametreye daha büyük bir sayı seçmek en iyisidir.

Şimdi, bulunan en iyi modelin performansını ölçelim. Kod öncekiyle aynı, ancak regressor yerine rscv nesnesini kullanacağız:

# 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}")Altyapı:

Train RMSE score for optimal model: 224.2405
Test RMSE score for optimal model: 572.0517Altyapı:

Eğitim RMSE'si düştü ancak test RMSE'si daha da büyük. Bu, hâlâ aşırı uyum yaptığımızı ve XGBoost'un altında kullandığı karar ağaçlarını budamak için aramamızı genişletip diğer parametreleri de dahil etmemiz gerektiğini gösteriyor.

Bu kısmı size bırakıyorum.

En iyi modeli Snowpark'ta kaydetme

Oturumu şimdi kapatırsak, ayarlanmış modelimizi kaybederiz. Kaydetmek için, herhangi bir modeli ve meta verilerini kaydetmek için kullanabileceğiniz sanal bir depolama alanı olan Snowpark'ın yerel model kayıt defterini kullanacağız.

Kayıt defteri Registry sınıfı olarak mevcuttur ve mevcut oturumun veritabanı ve şema adlarını gerektirir. Ayrıca, diğer projelerin modelleriyle çakışmamak için projeye bir ad vermemizi de ister:

# 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)Altyapı:

Modellerimizi kaydetmek için Registry.log_model() yöntemini kullanacağız:

# 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,
)Altyapı:

.set_metric() yöntemiyle model için bir metrik kaydedebiliriz (istediğimiz kadar metrik kaydedebiliriz). Modele açıklama eklemek için bir yorum da ekleyeceğiz:

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

# Add a description
v0.comment = "Elmas fiyatlarını tahmin etmek için ilk model"Altyapı:

Rastgele aramayla bulunan en iyi model için de aynısını yapıyoruz. Metrik kaydederken değeri optimal_rmse_test olarak değiştirmeyi unutmayın.

# 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 = "RandomizedSearchCV ile bulunan en iyi model"Altyapı:

Modellerin kaydedildiğini doğrulamak için .show_models() çağırabilirsiniz:

# Confirm the models are added
registry.show_models()Altyapı:

Kayıt defterinin nasıl yönetileceği hakkında daha fazla bilgiyi Snowpark geliştirici dokümanlarının bu sayfasında bulabilirsiniz.

Snowpark'ta çıkarım (inference) yapma

Çıkarım genellikle kayıt defterinizden en iyi modelin seçilmesiyle yapılır. Bunu .show_models() sonucunu filtreleyerek veya aşağıda yaptığımız gibi modeli sürüm etiketiyle doğrudan alarak yapabiliriz:

# 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.columnsAltyapı:

get_model() yöntemi, XGBRegressor'dan farklı olan genel bir model nesnesi döndürür. Bu nedenle, bir çıkarım gerçekleştirmek için fonksiyon adını belirterek .run() çağırmanız gerekir.

Sonuç

Bu eğitimde, Snowflake Snowpark'ta makine öğrenimi modelleri eğitmek için uçtan uca bir çerçeveyi ele aldık. Tebrikler!

Temizlenmemiş, temel bir veri setiyle başladık ve ayarlanmış bir XGBoost regresör modeliyle bitirdik. Tüm işlemleri Snowflake Cloud üzerinde gerçekleştirdik; yani sistem kaynaklarını hiç kullanmamız gerekmedi.

Büyük veri setlerine sahip olduğumuzda bu tür veritabanı içi işlemlerin ne kadar etkili olduğunu öğrendik—ve Snowflake Snowpark'ın bu süreci kolaylaştırmak için pazardaki en iyi araçlardan biri olduğunu gördük.

Snowpark veya Snowflake hakkında daha fazla bilgi edinmek istiyorsanız, aşağıdaki kaynaklara göz atın:

• Snowflake Time Travel Kullanımı: Kapsamlı Bir Rehber
• Python ve SQL kullanarak Snowflake'te Veri Analizine Başlangıç
• 2024 için En İyi Snowflake Sertifikası
• Snowpark API Geliştirici Rehberi — mutlaka okuyun
• Snowpark ML Geliştirici Rehberi

Okuduğunuz için teşekkürler!