Amazon SageMaker ile AWS Üzerinde Makine Öğrenimi için Eksiksiz Rehber

Çoğu kişi Amazon’u hızlı teslimat ve içerikle ilişkilendirse de şirket, geliştiriciler arasında da en çok beğenilenlerden biridir. Özellikle Amazon Web Services (AWS), kurumsal şirketler ve küçük/orta ölçekli işletmeler dahil 1 milyondan fazla aktif kullanıcıya bulut teknolojileri sunar.

Bu yazıda, AWS ekosisteminin bir parçası olan ve uçtan uca makine öğrenimi (ML) iş akışlarını çok büyük ölçekte yürütmeye adanmış bir platform olan AWS SageMaker’a odaklanacağız. Yazının sonunda, bir sınıflandırma görevi için tahmin üretmek üzere istekte bulunabileceğimiz şekilde dağıtılmış bir modele sahip olacağız.

Amazon SageMaker nedir?

Amazon SageMaker, makine öğrenimi modellerini oluşturmak, eğitmek ve dağıtmak için araçlar ve altyapı sağlayan tamamen yönetilen bir hizmettir. Makine öğrenimi iş akışını basitleştirir ve veri bilimciler ile geliştiricilerin modelleri hızlı ve verimli biçimde oluşturup eğitmesini ve dağıtmasını sağlar.

Tipik bir makine öğrenimi projesinde birçok aşamadan geçersiniz:

• Veri alımı, temizleme ve keşif.
• Özellik mühendisliği ve seçimi.
• Model eğitimi ve hiperparametre ayarlaması.
• Dağıtım ve model izleme.

Her aşama, farklı bir araç seti ve bunları sorunsuz biçimde orkestre edecek yetkin bir ekip gerektirir. Amazon SageMaker, bu sürecin tamamını tek bir platformda bir araya getirir. İşte bazı faydaları:

• Uçtan uca makine öğrenimi hizmeti: Veri hazırlamadan model dağıtımı ve izlemesine kadar makine öğrenimi yaşam döngüsünün her aşaması için kapsamlı bir araç takımı sunar.
• Tümleşik geliştirme ortamı: SageMaker Studio, kullanıcıların tek bir arayüzden model oluşturmasını, eğitmesini ve dağıtmasını sağlayarak tüm ML iş akışını basitleştiren bir IDE sunar.
• Kullanım kolaylığı: SageMaker Autopilot gibi özellikler, kodlama deneyimi olmayan kullanıcıların bile sadece birkaç tıklamayla yüksek kaliteli modeller üretmesini sağlar.
• Ölçeklenebilirlik: Modelleri eğitmek ve dağıtmak için altyapıyı otomatik olarak ölçeklendirir ve manuel müdahale olmadan en iyi performansı sağlar.
• Maliyet etkinliği: Spot Training ve çoklu model uç noktaları gibi seçeneklerle eğitim ve barındırma maliyetlerini düşürür.
• Popüler ML çerçeveleri için destek: Veri bilimcilerin TensorFlow, PyTorch ve XGBoost dahil tercih ettikleri çerçeveleri kullanmasına olanak tanır.
• Otomatik hiperparametre ayarlaması: Hiperparametreleri otomatik olarak ayarlayarak en iyi performans gösteren model yapılandırmasını bulur.
• Sağlam model dağıtımı: Modelleri gerçek zamanlı API’ler veya toplu tahmin hizmetleri olarak dağıtmayı basitleştirir ve ML modellerinin uygulamalara entegrasyonunu kolaylaştırır.
• Kapsamlı izleme: SageMaker Model Monitor, üretimde veri kayması ve anormallikleri tespit ederek model performansını sürekli izler.
• Model kaydı: Sürümleme, onay iş akışları ve dağıtım geçmişi dahil makine öğrenimi modellerinin yaşam döngüsünü yönetir.
• Kesintisiz entegrasyon: Veri depolama için Amazon S3, veri hazırlama için AWS Glue, olay güdümlü işleme için AWS Lambda ve izleme ve günlükleme için Amazon CloudWatch gibi diğer AWS hizmetleriyle kolayca entegre olur.
• Güvenlik ve uyumluluk: VPC desteği, şifreleme ve IAM ilkeleri dahil güçlü güvenlik özellikleriyle veri korumasını ve endüstri standartlarıyla uyumu sağlar.

Bu avantajlar, Amazon SageMaker’ı büyük ölçekte makine öğrenimi modeli oluşturma, eğitme ve dağıtma için güçlü ve esnek bir platform haline getirir.

SageMaker için AWS Konsolunuzu ve Ortamınızı Kurma

Belirtildiği gibi SageMaker, depolama, ağ, veritabanları, analitik ve makine öğrenimi yetenekleri sunan birçok bulut bilişim çözümünü içeren AWS ekosisteminin bir parçasıdır. Bu çözümlerin tümü, makine öğrenimi iş akışınızı birleştirmek için SageMaker ile senkronize biçimde çalışır.

Bu nedenle, SageMaker’ı kullanmak için, eğer yoksa bir AWS hesabı oluşturmanız gerekir.

1. AWS hesabı oluşturma

Hesap oluşturmak için https://aws.amazon.com/ adresine gidin ve yeni hesap oluşturma adımlarını izleyin.

Kayıt sürecinde faturalandırma bilgilerini ekleme ve telefon numaranızı doğrulama yer alır. Endişelenmeyin — SageMaker işlevlerinin bir kısmını gerçekten kullanmaya başlamadığınız sürece ücret yansıtılmaz (genellikle de maliyet-etkindir). 

İşlem tamamlandığında, aşağıdaki görseldeki gibi görünen AWS konsolunuza yönlendirilirsiniz. Konsoldaki bazı bileşenlerin sizde farklı olabileceğini unutmayın.

2. Notebook örneği oluşturma

Şimdi, Amazon’un bulut makinelerinde kod çalıştırmak için bir JupyterLab oturumu oluşturacağız.

AWS konsolunuzdan, ekranın üst kısmındaki arama çubuğunu kullanarak SageMaker panosunu arayın:

Ardından aşağı kaydırarak “Notebooks” sekmesini ve içinde “Notebooks instances” seçeneğini bulun. Henüz örnek olmayacak, bu yüzden bir tane oluşturmamız gerekiyor:

Yeni bir notebook oluşturmak için ekranın sağ üst köşesindeki “Create notebook instance”a tıklayın. Ardından aşağıdaki alanları doldurun:

• Notebook’unuza bir ad verin. Bu örnekte benimkinin adı sagemaker-test.
• “Notebook instance type” alanı, notebook çekirdeğiniz için istediğiniz makine türünü belirtir. Ben 8 GB RAM ve 2 CPU çekirdeğine sahip ml.t3.large’ı seçiyorum. Yazım anında saatlik maliyeti yaklaşık 0,12 $’dır (güncel bilgiler için SageMaker fiyatlandırma sayfasına bakın).
• “Permissions and encryption” bölümünde “Create new user” seçeneğini seçin; bu, notebook örneğinizi çalıştırmak için gerekli izinlere sahip bir IAM kullanıcısını otomatik olarak oluşturur.

Gerekli tüm bilgileri doldurduktan sonra “Create notebook instance”a tıklayın. 

“Pending” durumu “inService” olarak değiştiğinde, notebook’un yanındaki “Open in JupyterLab” bağlantısına tıklayarak JupyterLab’i başlatabilirsiniz:

Örnek hizmete girer girmez saat işlemeye ve faturalandırma başlamaya başlar. Ara vermek isterseniz, gereksiz maliyetleri önlemek için “Actions”a ardından “Stop”a tıklayarak örneği durdurmayı unutmayın. Boşta kalma zaman aşımı varsayılan olarak iki saattir:

Bir notebook örneğini durdurursanız, daha sonra yeniden başlatabilirsiniz. Ortamınız korunur.

AWS SageMaker’da Kullanılacak Bir Veri Kümesini Yükleme

Bu bölümde, SageMaker’ın gerektirdiği üzere yerel bir dosyayı Amazon’un sunucularına nasıl yükleyeceğinizi öğreneceğiz.

1. Örnek bir veri kümesi indirme

UCI ML deposundaki Dry Bean veri setini kullanarak çok sınıflı bir sınıflandırıcı oluşturacağız. 13 bin adet fasulye örneği ve bunlara ait 15 sayısal ölçüm içerir. 

Görev, bunları yedi fasulye türünden birine sınıflandırmaktır: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz ve Sira.

Yedi fasulye türü: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz ve Sira.

İndirdikten sonra, indirilen ZIP’in içindeki Excel dosyasını JupyterLab’deki yerel data dizininize kaydedin ve ardından aşağıdaki kodu notebook’unuza ekleyin:

from pathlib import Path

cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"

Ardından, aşağıdaki kodu ekleyerek Excel dosyasını pandas ile okuyup CSV olarak kaydedebiliriz:

import pandas as pd

beans = pd.read_excel(data_path)
beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)

2. Bir S3 bucket oluşturma ve veriyi yükleme

SageMaker’ın veri kümesine erişebilmesi için veri kümesinin bir S3 bucket içinde olması gerekir. AWS S3, proje ile ilgili nesneleri Amazon sunucularında barındırılan bucket’larda saklamanıza olanak tanıyan bir bulut depolama çözümüdür.

Bir bucket oluşturmak için şu adımları izleyin:

• S3 konsoluna gidin. Arama çubuğunda “S3” araması yapabilirsiniz.
• “Create bucket”a tıklayın.
• Bucket’a bir ad verin.
• Bucket adı küresel olarak benzersiz olmalıdır; bu yüzden benim kullandığım dry-bean-bucket adını siz kullanamazsınız.
• Kalan alanlarda varsayılan yapılandırmayı bırakın.
• “Create bucket”a tıklayın.

Bucket oluşturulduktan sonra, daha önce kaydettiğimiz CSV dosyasını yüklemek için üzerine tıklayın:

• Bucket içinde “Upload”a, ardından “Add files”a tıklayın.
• CSV dosyasını seçin.
• Tekrar “Upload”a tıklayın.

Ardından, nihayet kod çalıştıracağımız için JupyterLab arayüzüne geri dönebilirsiniz!

AWS SageMaker’da Uçtan Uca Model Eğitimi ve Dağıtım İş Akışı

Bu bölümde, bizi bir CSV veri setinden bir uç noktaya dağıtılmış modele götürecek uçtan uca bir iş akışını ele alacağız. Ancak teknik ayrıntılarda kaybolmadan önce, yüksek seviyede neler yapacağımızı netleştirelim.

SageMaker’da ML iş akışlarına yüksek seviyeden bakış

SageMaker’da makine öğrenimi yapmak, yerel makinenizde yapmaktan biraz farklıdır. İlk adımları zaten ele aldık:

• AWS hesabı oluşturma.
• Notebook örneği oluşturma.
• Proje için bir S3 bucket oluşturma.

Yerel notebook’larınız gibi, SageMaker notebook örnekleri de keşif amaçlı analiz içindir — veri temizleme, keşif, alım ve temel denemeler.

Model eğitim aşamasına ulaştığınızda, SageMaker sizden kendi kurallarına uymanızı bekler. Özellikle, SageMaker’ın özel modellerinizi uç noktalar olarak dağıtabilmesi için, aşağıdakileri yapan bir eğitim betiğine ihtiyaç duyar:

• Veriyi kaynağından yükler.
• Bunun üzerinde tek bir model eğitir.
• Modeli ve eserlerini kaydeder.
• Metri̇kleri̇ni̇ raporlar.

Betik ayrıca değişkenleri dinamik olarak komut satırı argümanları olarak kabul etmelidir. Yani gelecekte betik içinde değiştirmek istediğiniz her şey (model hiperparametreleri, dosya yolları vb.) komut satırı argümanları olarak ayarlanmalıdır.

Bu betik hazır olduğunda, SageMaker tarafından sağlanan özel tahmin edicilere (estimator) verilir. Bunlar, scikit-learn, XGBoost, TensorFlow, PyTorch gibi popüler ML kütüphanelerinin yoldaşlarıdır. Bu tahmin ediciler kullanılarak SageMaker, betiğinizin etrafında Docker konteynerleri oluşturur ve bunu ölçekli şekilde hizmet vermek üzere bir uç nokta olarak dağıtır.

Aşağıdaki adımları teker teker uyguladıkça önceki noktaların hepsi anlam kazanacaktır. 

1. SageMaker için notebook örneğini hazırlama

Daha önce oluşturduğunuz sagemaker-test notebook’unun içine gerekli kütüphaneleri içe aktararak başlayalım:

import boto3
import numpy as np
import pandas as pd
import sagemaker
from sagemaker import get_execution_role
from sklearn.model_selection import train_test_split

Bu içe aktarmaların bazıları şunları yapar:

• sagemaker , Amazon SageMaker üzerinde makine öğrenimi modellerini eğiten ve dağıtan resmi Python SDK’sıdır. Bu SDK ile popüler derin öğrenme çerçevelerini, Amazon tarafından sağlanan algoritmaları veya SageMaker uyumlu Docker imajlarına gömülü kendi algoritmalarınızı kullanarak model eğitip dağıtabilirsiniz.
• boto3 başka bir resmi Python SDK’dır, ancak yalnızca SageMaker değil tüm AWS hizmetleri ile kodunuz arasında köprü görevi görür. boto3 hakkında bu kursta daha fazla bilgi edinebilirsiniz. 

İçe aktarmalardan sonra, eğitim boyunca ihtiyaç duyacağımız bazı kaynakları oluşturalım:

sm_boto3 = boto3.client("sagemaker")
sess = sagemaker.Session()

• Yukarıdaki kodda önce boto3 kullanarak bir SageMaker istemci nesnesi oluşturuyoruz. 
• Ardından bir SageMaker oturumu oluşturuyoruz. 

Bu iki nesne, SageMaker platformuyla farklı şekillerde etkileşime girmemizi sağlar.

Şimdi ihtiyacımız olan birkaç genel değişken tanımlayalım:

region = sess.boto_session.region_name
BUCKET_URI = "s3://dry-bean-bucket"
BUCKET_NAME = "dry-bean-bucket"
DATASET_PATH = f"{BUCKET_URI}/dry_bean.csv"
TARGET_NAME = "Class"

Bu değişkenler kendini açıklayıcıdır ve eğitim boyunca kullanılacaktır.

2. Bir S3 bucket’tan SageMaker’a veri yükleme

Veri projelerinizin çoğunda eğitim veri kümesi BigQuery, GCS gibi bir bulut depolama çözümünde ya da bir AWS S3 bucket’ında saklanır. Biz veriyi sonuncusunda sakladık; öyleyse pandas kullanarak yükleyelim. Bunun için aşağıdaki kodu notebook’unuza ekleyip çalıştırın:

dry_bean = pd.read_csv(DATASET_PATH)
dry_bean.head()

SageMaker notebook’unda çalışmanın avantajlarından biri, S3’ten dosyaları doğrudan pandas ile okuyabilmemizdir. Tüm SageMaker ortamları, pandas’ın bucket’tan CSV’yi indirebilmesi için kimlik bilgilerinizle yapılandırılmıştır. Bu kodu yerelde çalıştırsaydınız çalışmayabilirdi.

3. SageMaker’da EDA gerçekleştirme

EDA (Keşifsel Veri Analizi) yapmak üzerinde çalıştığınız her projenin bir parçası olmalıdır; bu proje de istisna değil. Ancak burada derinlemesine bir analiz yapmayacağız; çünkü bu, yazının ana konusundan uzaklaştırır. 

Birkaç özet istatistik ve grafik yazdırmakla yetineceğiz:

dry_bean.info()

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 13611 entries, 0 to 13610

Data columns (total 17 columns):

#   Column           Non-Null Count  Dtype 

---  ------           --------------  ----- 

0   Area             13611 non-null  int64 

1   Perimeter        13611 non-null  float64

2   MajorAxisLength  13611 non-null  float64

3   MinorAxisLength  13611 non-null  float64

4   AspectRation     13611 non-null  float64

5   Eccentricity     13611 non-null  float64

6   ConvexArea       13611 non-null  int64 

7   EquivDiameter    13611 non-null  float64

8   Extent           13611 non-null  float64

9   Solidity         13611 non-null  float64

10  roundness        13611 non-null  float64

11  Compactness      13611 non-null  float64

12  ShapeFactor1     13611 non-null  float64

13  ShapeFactor2     13611 non-null  float64

14  ShapeFactor3     13611 non-null  float64

15  ShapeFactor4     13611 non-null  float64

16  Class            13611 non-null  object

dtypes: float64(14), int64(2), object(1)

memory usage: 1.8+ MB

Yukarıdaki bilgiler, 16 sayısal özellik ve Class adlı tek bir hedef olduğunu söylüyor. Veri kümesi küçük; yalnızca 13 bin örnek var, bu nedenle modeli eğitmek için güçlü makineler ya da yüksek maliyet gerekmeyecek.

Şimdi de seaborn kullanarak birkaç önemli özelliğin pair plot’unu oluşturalım:

import seaborn as sns

sns.pairplot(
   dry_bean,
   vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
   hue="Class",
);

Yukarıdaki grafikler, fasulyelerin fiziksel ölçümleri açısından belirgin şekilde farklılaştığını gösteriyor. Yeşil olanlar (Bombay) özellikle iyi ayrışmış.

Özellikler arasındaki ilişkiyi görmek için bir korelasyon matrisi de çizebiliriz:

import matplotlib.pyplot as plt

correlation = dry_bean.corr(numeric_only=True)

# Create a square heatmap with center at 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)
plt.show()

Grafik, mükemmel (pozitif ve negatif) korelasyona sahip birçok özellik olduğunu gösteriyor; bu mantıklı, çünkü tüm özellikler fiziksel ölçümlerle ilgili.

Bu noktada, keşfe devam etmeyi size bırakıyorum.

4. SageMaker’da model eğitimi için veriyi hazırlama

Keşiften sonra, eğitime geçmeden önce veri kümenizdeki kalite ya da mantıksal sorunları ele almalı ve gerekirse yeni özellikler üretmelisiniz. 

Dry Bean veri seti oldukça temiz; işimiz kolay. Sadece metin içerdiği için hedefi kodlamamız yeterli. Bunu yapmak için scikit-learn kullanacağız:

from sklearn.preprocessing import LabelEncoder

# For preprocessing
df = dry_bean.copy(deep=True)

# Encode the target
le = LabelEncoder()
df[TARGET_NAME] = le.fit_transform(df[TARGET_NAME])

Ön işleme tamamlandığında veri kümesini bölmeliyiz:

from sklearn.model_selection import train_test_split

# Split the data into two sets
train, test = train_test_split(df, random_state=1, test_size=0.2)

İsterseniz veriyi üçüncü bir doğrulama setine de bölebilirsiniz; ancak şimdilik basit tutacağız.

Şimdi veri kümelerini CSV olarak kaydedelim:

train.to_csv("dry-bean-train.csv")
test.to_csv("dry-bean-test.csv")

Ve S3 bucket’ımıza yükleyelim:

# Send data to S3. SageMaker will take training data from s3
trainpath = sess.upload_data(
   path="dry-bean-train.csv",
   bucket=BUCKET_NAME,
   key_prefix="sagemaker/sklearncontainer",
)

testpath = sess.upload_data(
   path="dry-bean-test.csv",
   bucket=BUCKET_NAME,
   key_prefix="sagemaker/sklearncontainer",
)

Oturum nesnesinin .upload_data() işlevi, yüklenen dosyanın tam yolunu döndürür ve bunlar sırasıyla trainpath ve testpath değişkenlerinde saklanır. Bu yolları daha sonra kullanacağız.

5. SageMaker için bir eğitim betiği yazma

Yeni bir notebook hücresine aşağıdaki kodu yapıştırın:

%%writefile script.py

import argparse
import os
import joblib
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import balanced_accuracy_score

if __name__ == "__main__":
   print("extracting arguments")
   parser = argparse.ArgumentParser()

   # Hyperparameters sent by the client are passed as command-line arguments to the script.
   parser.add_argument("--n-estimators", type=int, default=10)
   parser.add_argument("--min-samples-leaf", type=int, default=3)

   # Data, model, and output directories
   parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
   parser.add_argument("--train", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))
   parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))
   parser.add_argument("--train-file", type=str, default="dry-bean-train.csv")
   parser.add_argument("--test-file", type=str, default="dry-bean-test.csv")
   args, _ = parser.parse_known_args()
   
   print("reading data")

   train_df = pd.read_csv(os.path.join(args.train, args.train_file))
   test_df = pd.read_csv(os.path.join(args.test, args.test_file))

   print("building training and testing datasets")

   X_train = train_df.drop("Class", axis=1)
   X_test = test_df.drop("Class", axis=1)
   y_train = train_df[["Class"]]
   y_test = test_df[["Class"]]

   # Train model
   print("training model")

   model = RandomForestClassifier(
       n_estimators=args.n_estimators,
       min_samples_leaf=args.min_samples_leaf,
       n_jobs=-1,
   )

   model.fit(X_train, y_train)

   # Print abs error
   print("validating model")

   bal_acc_train = balanced_accuracy_score(y_train, model.predict(X_train))
   bal_acc_test = balanced_accuracy_score(y_test, model.predict(X_test))

   print(f"Train balanced accuracy: {bal_acc_train:.3f}")
   print(f"Test balanced accuracy: {bal_acc_test:.3f}")

   # Persist model
   path = os.path.join(args.model_dir, "model.joblib")
   joblib.dump(model, path)
   print("model persisted at " + path)

Yukarıdaki betikteki %%writefile script.py sihirli komutu, hücre içeriğini çalıştırmak yerine bir Python betiğine dönüştürür.

Şimdi betikte neler olup bittiğine adım adım bakalım:

import argparse
import os
import joblib
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import balanced_accuracy_score

Önce gerekli birkaç kütüphaneyi içe aktarıyoruz. 

if __name__ == "__main__":
   print("extracting arguments")
   parser = argparse.ArgumentParser()
   
   # Hyperparameters sent by the client are passed as command-line arguments to the script.
   parser.add_argument("--n-estimators", type=int, default=10)
   parser.add_argument("--min-samples-leaf", type=int, default=3)

   # Data, model, and output directories
   parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
   parser.add_argument("--train", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))
   parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))
   parser.add_argument("--train-file", type=str, default="dry-bean-train.csv")
   parser.add_argument("--test-file", type=str, default="dry-bean-test.csv")
   args, _ = parser.parse_known_args()

Sonra, komut satırı argümanlarını okumak için bir argüman ayrıştırıcı nesnesi oluşturuyoruz. Belirttiğim gibi, gelecekte güncellenmesi muhtemel her değer CLI argümanları olarak geçirilmelidir. Bu bölüm o argümanları tanımlar:

• Random Forest Classifier nesnesi için iki hiperparametre.
• Model eserleri ve veri kümesi dosyaları dahil beş giriş ve çıkış dosya yolu.

model-dir, train ve test dizinlerinin varsayılan değerlerine dikkat ederseniz bazı ortam değişkenleri görürsünüz. Bunlar, benzeri betik dosyaları yazmaya yönelik talimatların da bulunduğu SageMaker SDK dokümanlarından alınmıştır.

print("reading data")
train_df = pd.read_csv(os.path.join(args.train, args.train_file))
test_df = pd.read_csv(os.path.join(args.test, args.test_file))
print("building training and testing datasets")
X_train = train_df.drop("Class", axis=1)
X_test = test_df.drop("Class", axis=1)
y_train = train_df[["Class"]]
y_test = test_df[["Class"]]

Dinamik değerleri tanımladıktan sonra eğitim ve test veri kümelerini okur ve oluştururuz. Görüldüğü gibi sabit bir yol geçirmek yerine args.argument değerlerini kullanıyoruz. 

# Train model
print("training model")
   
model = RandomForestClassifier(
    n_estimators=args.n_estimators,
    min_samples_leaf=args.min_samples_leaf,
    n_jobs=-1,
)

model.fit(X_train, y_train)

# Print abs error
print("validating model")
   
bal_acc_train = balanced_accuracy_score(y_train, model.predict(X_train))
bal_acc_test = balanced_accuracy_score(y_test, model.predict(X_test))

print(f"Train balanced accuracy: {bal_acc_train:.3f}")
print(f"Test balanced accuracy: {bal_acc_test:.3f}")

Modeli hem eğitim hem de test veri kümelerinde değerlendirip performansı yazdırıyoruz. 

# Persist model
path = os.path.join(args.model_dir, "model.joblib")
joblib.dump(model, path)
print("model persisted at " + path)

Son olarak modeli joblib kullanarak model dizinine kaydediyoruz.

Bu hücreyi notebook’unuzda çalıştırdığınızda, script.py dosyası JupyterLab ortamınızda belirecektir. Aşağıdaki gibi çalıştırarak düzgün çalışıp çalışmadığını kontrol edebilirsiniz:

! python script.py --n-estimators 100 \

                  --min-samples-leaf 2 \

                  --model-dir ./ \

                  --train ./ \

                  --test ./ \

extracting arguments

reading data

building training and testing datasets

validating model

Train balanced accuracy: 1.000

Test balanced accuracy: 0.998

model persisted at ./modejoblib

Harika, %99 dengeli doğruluk puanı elde ettik—daha iyisi olmaz! Bu da artık bir eğitim işi başlatabileceğimiz anlamına geliyor.

6. SageMaker’da özel bir eğitim işi oluşturma

Şimdi betiği bir SageMaker estimator nesnesine aktaracağız. AWS bağlamında bir eğitim işi, belirtilen bir algoritma, veri kümesi ve AWS SageMaker tarafından sağlanan hesaplama kaynakları kullanılarak bir modelin eğitildiği bir süreçtir. Yerel makinede veya notebook’ta eğitimden farklı olarak bu iş bulutta ölçeklenebilir altyapıda çalışır; daha fazla hesaplama gücü, daha hızlı işlem ve daha büyük veri kümelerini işleme olanağı sağlar.

Notebook’unuzda yeni bir hücreye aşağıdaki kodu ekleyin:

# We use the Estimator from the SageMaker Python SDK
from sagemaker.sklearn.estimator import SKLearn
FRAMEWORK_VERSION = "0.23-1"

sklearn_estimator = SKLearn(
   entry_point="script.py",
   role=get_execution_role(),
   instance_count=1,
   instance_type="ml.c5.xlarge",
   framework_version=FRAMEWORK_VERSION,
   base_job_name="rf-scikit",
   hyperparameters={
       "n-estimators": 100,
       "min-samples-leaf": 3,
   },
)

Yukarıdaki kodda SKLearn sınıfı scikit-learn betikleriyle ilgilenir. Açıklanması gereken birkaç temel parametreye sahiptir:

• entry_point: Betiğin yolu.
• role: SageMaker’a erişimi olan kullanıcı adı.
• instance_count: Kaç makinenin başlatılacağı.
• instance_type: Makine türü.

Hiperparametreler için yalnızca eğitim betiğinde tanımladıklarınızı geçirin. Aksi halde hata alırsınız. 

Şimdi bu tahmin ediciyi verimize uydurabiliriz:

# Launch training job, with asynchronous call
sklearn_estimator.fit({"train": trainpath, "test": testpath}, wait=True)

Eğitimin önceki bölümlerde belirttiğimiz üzere, trainpath ve testpath CSV dosyalarımıza işaret eden S3 bucket yollarıdır. 

Yukarıdaki kodun bulunduğu hücreyi çalıştırdığınızda eğitim başlar:

INFO:sagemaker:Creating training-job with name: rf-scikit-2024-06-04-10-36-31-142

2024-06-04 10:36:31 Starting - Starting the training job...

2024-06-04 10:36:46 Starting - Preparing the instances for training...

2024-06-04 10:37:13 Downloading - Downloading input data...

2024-06-04 10:37:53 Training - Training image download completed. Training in progress...

SageMaker, scikit-learn kodu çalıştırmanızı sağlayan gerekli Docker imajını indirir ve betiğinizi yürütür. İşlem bittiğinde şu mesajı alırsınız:

2024-06-04 10:38:17 Uploading - Uploading generated training model

2024-06-04 10:38:17 Completed - Training job completed

Training seconds: 65

Billable seconds: 65

SageMaker panonuzun “SageMaker” > “Traning” > “Training Jobs” bölümüne giderseniz, eğitim işini orada listelenmiş olarak da görürsünüz.

7. Maliyetleri düşürmek için eğitimde Spot Instance kullanma

Veri setimiz küçük olduğundan, eğitim için düşük maliyetli ve düşük konfigürasyonlu bir makine kullanarak işin içinden çıktık: ml.c5.xlarge. Ancak kendi projelerinizde milyonlarca kayıttan oluşan veri kümeleri veya devasa görsel veri kümeleriyle uğraşmanız gerekebilir. Bu durumlarda çok daha yüksek güç ve GPU sunan makineleri seçmeniz gerekir.

Bu makineleri isteğe bağlı kullanmak çok pahalı olabilir. Maliyetleri düşürmek için Amazon Spot Training instance’larını sunar. Bu instance’larda, tek bir çekinceyle uygun fiyata yüksek güçlü hesaplama kaynaklarını seçebilirsiniz — eğitim hemen başlamaz. Bunun yerine SageMaker, talep düşünce ve istediğiniz makine kullanılabilir olunca başlatır. 

Spot Training’i etkinleştirmek için son kod bloğuna yalnızca birkaç satır eklemeniz yeterlidir:

spot_sklearn_estimator = SKLearn(
   entry_point="script.py",
   role=get_execution_role(),
   instance_count=1,
   instance_type="ml.c5.xlarge",
   framework_version=FRAMEWORK_VERSION,
   base_job_name="rf-scikit",
   hyperparameters={
       "n-estimators": 100,
       "min-samples-leaf": 3,
   },
   use_spot_instances=True,
   max_wait=7200,
   max_run=3600,
)

use_spot_instances’ı True olarak ayarlayarak spot_sklearn_estimator’ın spot eğitim kullanmasını sağlarsınız. Ayrıca bir spot instance’ın kullanılabilir hale gelmesi için azami bekleme süresini ve eğitimin çalışacağı azami süreyi belirleyebilirsiniz. 

Eğitim, .fit() metodunu tekrar çağırdığınızda gerçekten başlar:

# Launch training job, with asynchronous call
spot_sklearn_estimator.fit({"train": trainpath, "test": testpath}, wait=True)

8. SageMaker ile hiperparametre ayarlaması

Aynı eğitim betiğini kullanarak benzer bir iş akışıyla hiperparametreleri ayarlanmış bir model elde edebiliriz. 

Önce, sagemaker.tuner içinden IntegerParameter sınıfını içe aktaralım:

from sagemaker.tuner import IntegerParameter

IntegerParameter sınıfı, tamsayı değer kabul eden parametreler için ayarlama aralıkları tanımlamaya olanak tanır. tuner modülü, diğer parametre türleri için de sınıflar içerir:

• CategoricalParameter: Ayrık bir kategorik değerler kümesi alan hiperparametreleri tanımlar.
• ContinuousParameter: Sürekli değer kabul eden hiperparametreler için ayarlama aralıkları tanımlar.

Ancak bu eğitimde, Random Forest’ın sadece iki parametresini ayarladığımız için IntegerParameter ile yetineceğiz:

# We use the Hyperparameter Tuner
from sagemaker.tuner import IntegerParameter

# Define exploration boundaries
hyperparameter_ranges = {
   "n-estimators": IntegerParameter(20, 100),
   "min-samples-leaf": IntegerParameter(2, 6),
}

Ardından bir tuner nesnesi oluşturalım:

# Create Optimizer
Optimizer = sagemaker.tuner.HyperparameterTuner(
   estimator=sklearn_estimator,
   hyperparameter_ranges=hyperparameter_ranges,
   base_tuning_job_name="RF-tuner",
   objective_type="Maximize",
   objective_metric_name="balanced-accuracy",
   metric_definitions=[
       {"Name": "balanced-accuracy", "Regex": "Test balanced accuracy: ([0-9.]+).*$"}
   ],  # Extract tracked metric from logs with regexp
   max_jobs=10,
   max_parallel_jobs=2,
)

Optimizer’ın temel parametreleri şunlardır:

• estimator: Eğitim betiğinizle uyumlu tahmin edici nesne.
• hyperparameter_ranges: tuner modülündeki sınıflarla tanımlanan parametre aralıkları.
• objective_type: Belirtilen metriğin maksimize mi minimize mi edileceği. Dengeli doğruluk maksimize edilmelidir.
• metric_definitions: Optimize edilecek metriklerin adı ve eğitim günlüklerinden nasıl alınacağı.

metric_definitions parametresi biraz karmaşıktır; çünkü metrikleri tanımlarken büyük esneklik sunar. 

Eğitim betiğinde, dengeli doğruluğu şu günlük mesajlarıyla raporluyoruz:

print(f"Train balanced accuracy: {bal_acc_train:.3f}")
print(f"Test balanced accuracy: {bal_acc_test:.3f}")

metric_definitions’ın bizden istediği, bu mesajı düzenli ifadelerle yakalamamızdır. Bu yüzden, “Test balanced accuracy” ile başlayan metriği yakalayan aşağıdaki sözlüğe sahibiz ve bu metriğe özel bir ad veriyoruz.

{
   "Name": "balanced-accuracy",
   "Regex": "Test balanced accuracy: ([0-9.]+).*$",
}

Geri kalan kod tanıdık:

Optimizer.fit({"train": trainpath, "test": testpath})

INFO:sagemaker:Creating hyperparameter tuning job with name: RF-tuner-240604-1049

Optimizasyon tamamlandığında, sonuçları bir DataFrame olarak görüntüleyebilirsiniz:

# Get tuner results in a df
results = Optimizer.analytics().dataframe()

while results.empty:
   time.sleep(1)
   results = Optimizer.analytics().dataframe()

results.head()

Ardından en iyi tahmin ediciyi alabilirsiniz:

best_estimator = Optimizer.best_estimator()

9. SageMaker’da modelleri uç noktalara dağıtma 

Deneylerinizde kullanacağınız modele karar verdiğinizde, tüm eserleriyle birlikte SageMaker’a yükleyebilirsiniz. Bu işlem boto3 kullanılarak yapılabilir:

artifact_path = sm_boto3.describe_training_job(
   TrainingJobName=best_estimator.latest_training_job.name
)["ModelArtifacts"]["S3ModelArtifacts"]

print("Model artifact persisted at " + artifact)

Model artifact persisted at s3://sagemaker-us-east-1-496320894061/RF-tuner-240604-1049-009-38d75f35/output/model.tar.gz

describe_training_job() işlevi bir estimator nesnesini alır ve SageMaker tarafından sağlanan varsayılan bir S3 konumuna iter. Yukarıda, işlevin modeli yüklemeden önce bir tarball’a dönüştürdüğünü görebilirsiniz.

Yüklenen modeller, SageMaker panonuzun “Inference” > “Models” bölümünde görünür:

Bunlardan herhangi birine tıklarsanız, ekranın sağ üstünde “Create endpoint” düğmesini görürsünüz:

Modeli bu düğmeyle dağıtabileceğiniz gibi, notebook örneğine geri dönüp .deploy() metodunu kullanarak kodla da dağıtabilirsiniz:

from sagemaker.sklearn.model import SKLearnModel

model = SKLearnModel(
   model_data=artifact_path,
   role=get_execution_role(),
   entry_point="script.py",
   framework_version=FRAMEWORK_VERSION,
)

Bu kez, halihazırda eğitilmiş modeller için kullanılan SKLearnModel sınıfını kullanıyoruz. Model eserlerinin saklandığı S3 konumu ve modeli eğitmek için kullanılan betik gereklidir. Bu bilgileri sağladıktan sonra dağıtımı çalıştırabilirsiniz:

predictor = model.deploy(instance_type="ml.c5.large", initial_instance_count=1)
INFO:sagemaker:Creating model with name: sagemaker-scikit-learn-2024-06-04-11-03-54-465
INFO:sagemaker:Creating endpoint-config with name sagemaker-scikit-learn-2024-06-04-11-03-54-960
INFO:sagemaker:Creating endpoint with name sagemaker-scikit-learn-2024-06-04-11-03-54-960

Ardından, SageMaker panonuzun “Inference” > “Endpoints” bölümünde uç noktayı listelenmiş olarak görmelisiniz:

Tahmin için kullanmak üzere notebook’unuzdan uç nokta nesnesinin .predict() metodunu çağırabilirsiniz:

preds = predictor.predict(test.sample(4).drop("Class", axis=1))
preds

array([3, 0, 1, 2])

Tebrikler, SageMaker ile ilk modelinizi dağıttınız!

Kullanımınız bittiğinde, sürekli maliyet oluşturmaya devam edeceğinden uç noktayı silmeyi unutmayın:

sm_boto3.delete_endpoint(EndpointName=predictor.endpoint)

Unutmayın, SageMaker’da oluşturduğunuz her notebook örneği, SageMaker’ın farklı özelliklerini gösteren örnek notebook’ların bulunduğu ayrı bir sekmeyle birlikte gelir:

Ayrıca, SageMaker Python SDK için resmi dokümantasyona göz atın.

Sonuç

Bugün, en popüler kurumsal makine öğrenimi platformlarından biri olan AWS SageMaker’ı kullanmayı öğrendik. AWS hesabı oluşturmaktan, SageMaker kullanarak ML modellerini uç noktalar olarak dağıtmaya kadar her şeyi ele aldık.

Her platformda olduğu gibi burada da yalnızca yüzeyi kazıdık. Kendi projelerinizde diğer AWS teknolojileriyle birleştirdiğinizde çok daha fazlasını yapabilirsiniz. İşte göz atabileceğiniz bazı ilgili kaynaklar:

• AWS Teknolojileri ve Hizmetleri Kursu
• AWS’ye Giriş Kursu
• AWS Kinesis ve Lambda ile Akan Veri İşleme Kursu
• AWS Step Functions’ı Ustaca Kullanma için Kapsamlı Rehber