1. Genel Bakış
Bu laboratuvarda, sahtekarlık içeren işlemleri belirlemek için bir model oluşturup eğitmek üzere AI Platform Notebooks'u kullanacak ve Açıklanabilir Yapay Zeka SDK ile modelin tahminlerini anlayacaksınız. Sahtekarlık tespiti, finansal hizmetlere özgü bir anomali tespitidir ve makine öğrenimi modelleri için bazı ilginç zorluklar sunar: doğası gereği dengesiz veri kümeleri ve model sonuçlarının açıklanması ihtiyacı.
Öğrenecekleriniz
Öğrenecekleriniz:
- Dengesiz veri kümelerini işleme
- AI Platform Notebooks'ta tf.keras ile sahtekarlık algılama modeli oluşturma ve değerlendirme
- Modelin işlemleri neden sahtekarlık olarak sınıflandırdığını anlamak için not defterinden Explainable AI SDK'yı kullanın.
- Modeli açıklamalarla birlikte AI Platform'a dağıtın ve dağıtılan modelle ilgili tahminler ve açıklamalar alın.
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 1 ABD dolarıdır.
2. Neden sahtekarlık algılama?
Verilerdeki aykırı değerleri belirlemek için kural tabanlı bir dizi ifade yazmak genellikle zor olduğundan anormallik algılama, makine öğrenimi için iyi bir aday olabilir. Sahtekarlık tespiti bir tür anormallik tespitidir ve makine öğrenimi söz konusu olduğunda iki ilginç zorluk ortaya çıkarır:
- Çok dengesiz veri kümeleri: Anormallikler, anormallik oldukları için çok fazla değildir. Makine öğrenimi, veri kümeleri dengeli olduğunda en iyi şekilde çalışır. Bu nedenle, aykırı değerler verilerinizin% 1'inden azını oluşturduğunda işler karmaşıklaşabilir.
- Sonuçları açıklama ihtiyacı: Sahtekarlık içeren etkinlik arıyorsanız sistemin bir şeyi neden sahtekarlık olarak işaretlediğini bilmek isteyebilirsiniz. Açıklanabilirlik araçları bu konuda yardımcı olabilir.
3. Ortamınızı ayarlama
Bu codelab'i çalıştırmak için faturalandırmanın etkin olduğu bir Google Cloud Platform projesine ihtiyacınız vardır. Proje oluşturmak için buradaki talimatları uygulayın.
1. adım: Cloud AI Platform Models API'yi etkinleştirin
Cloud Console'unuzun AI Platform Modelleri bölümüne gidin ve henüz etkinleştirilmemişse Etkinleştir'i tıklayın.
2. adım: Compute Engine API'yi etkinleştirin
Compute Engine'e gidin ve henüz etkinleştirilmemişse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için bu bilgiye ihtiyacınız vardır.
3. adım: AI Platform Notebooks örneği oluşturun
Cloud Console'unuzun AI Platform Notebooks bölümüne gidin ve New Instance'ı (Yeni Örnek) tıklayın. Ardından, GPU'suz TensorFlow Enterprise 2.1 örnek türünü seçin:
Varsayılan seçenekleri kullanıp Oluştur'u tıklayın. Örnek oluşturulduktan sonra Open JupyterLab'i (JupyterLab'i aç) seçin:
Örneği açtığınızda başlatıcıdan Python 3 not defterini seçin:
4. adım: Python paketlerini içe aktarın
Yeni bir hücre oluşturun ve bu codelab'de kullanacağımız kitaplıkları içe aktarın:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. Verileri indirme ve işleme
Modelimizi eğitmek için Kaggle'daki bu sentetik olarak oluşturulmuş veri kümesini kullanacağız. Orijinal veri kümesi 6,3 milyon satır içeriyor. Bunlardan 8.000'i sahtekarlık içeren işlemler. Bu da tüm veri kümesinin yalnızca% 0,1'i anlamına geliyor.
1. adım: Kaggle veri kümesini indirin ve Pandas ile okuyun
Kaggle veri kümesini Google Cloud Storage'da kullanıma sunduk. Aşağıdaki gsutil komutu Jupyter not defterinizde çalıştırarak indirebilirsiniz:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Ardından, veri kümesini Pandas DataFrame olarak okuyalım ve önizleyelim:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
Önizlemede aşağıdakine benzer bir ifade görürsünüz:
2. adım: Dengesiz verileri hesaba katma
Yukarıda belirtildiği gibi, veri kümesi şu anda% 99,9 oranında sahtekarlık içermeyen örnekler barındırıyor. Bir modeli veriler üzerinde olduğu gibi eğitirsek modelin, verilerin% 99,9'u sahtekarlık içermeyen işlemler olduğu için her işlemin sahtekarlık içermediğini tahmin ederek% 99,9 doğruluk oranına ulaşma olasılığı yüksektir.
Dengesiz verilerle başa çıkmak için birkaç farklı yaklaşım vardır. Burada alt örnekleme adlı bir teknik kullanacağız. Alt örnekleme, eğitimde çoğunluk sınıfının yalnızca küçük bir yüzdesinin kullanılması anlamına gelir. Bu durumda, verilerin% 99,9'unu oluşturduğu için "sahtekarlık içermeyen" çoğunluk sınıfıdır.
Veri kümemizi alt örneklemek için sahtekarlık içeren yaklaşık 8.000 örneğin tamamını ve sahtekarlık içermeyen yaklaşık 31.000 örneğin rastgele bir örneğini alacağız. Bu sayede, sonuçta elde edilen veri kümesinde% 0,1 olan sahtekarlık vakası oranı% 25'e yükselir.
Öncelikle verileri iki DataFrame'e bölün. Biri sahtekarlık, diğeri ise sahtekarlık dışı işlemler için olsun (modelimizi dağıtırken bu DataFrame'leri kullanacağız):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Ardından, sahtekarlık içermeyen vakalardan rastgele bir örneklem alın. Bu, sahtekarlık/sahtekarlık dışı işlemlerin %25/%75 oranında dağılmasını sağlayacağından %0,005'i kullanıyoruz. Bu sayede verileri tekrar bir araya getirebilir ve karıştırabilirsiniz. İşleri basitleştirmek için eğitimde kullanmayacağımız birkaç sütunu da kaldıracağız:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
Artık çok daha dengeli bir veri kümemiz var. Ancak modelimizin yaklaşık% 75 doğruluk oranıyla yakınsadığını fark edersek her durumda "sahtekarlık yok" tahmininde bulunma ihtimali yüksektir.
3. adım: Verileri eğitim ve test kümelerine ayırın
Modelimizi oluşturmadan önce yapmamız gereken son şey verilerimizi bölmektir. %80/20 eğitim-test bölümü kullanacağız:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*E. C. Lopez-Rojas , A. Elmir ve S. Axelsson. "PaySim: A financial mobile money simulator for fraud detection" (PaySim: Sahtekarlık tespiti için finansal mobil para simülasyonu). In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 2016
5. tf.keras modeli oluşturma, eğitme ve değerlendirme
TensorFlow'un tf.keras API'sini kullanarak geliştirme yapacağız. Bu bölümdeki model kodu, TensorFlow belgelerindeki bu eğitime dayanmaktadır. Önce verileri normalleştiririz. Ardından, kalan veri dengesizliğini hesaba katmak için class_weight parametresini kullanarak modelimizi oluşturup eğitiriz.
1. adım: Verileri normalleştirin
Bir modeli sayısal veriler üzerinde eğitirken verileri normalleştirmek önemlidir. Özellikle her sütun farklı bir aralıkta yer alıyorsa bu işlem gereklidir. Bu, eğitim sırasında patlamadan kaynaklanan kayıpları önlemeye yardımcı olabilir. Verilerimizi aşağıdakilerle normalleştirebiliriz:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
Ardından, normalleştirilmiş verilerimizi önizleyelim:
train_set
2. adım: Sınıf ağırlıklarını belirleyin
Verileri daha düşük örnekleme sıklığına indirirken, sahtekarlık içermeyen işlemlerin bir alt kümesini korumak istedik. Böylece bu işlemlerle ilgili bilgileri kaybetmedik. Bu nedenle verileri mükemmel bir şekilde dengeli hale getirmedik. Veri kümesi hâlâ dengesiz olduğundan ve en çok sahtekarlık içeren işlemleri doğru şekilde tanımlamakla ilgilendiğimizden modelimizin veri kümemizdeki sahtekarlık içeren örneklere daha fazla ağırlık vermesini istiyoruz.
Keras class_weight parametresi, veri kümesinde ne sıklıkta bulunduklarına bağlı olarak her sınıftaki örneklere ne kadar ağırlık vermek istediğimizi tam olarak belirtmemize olanak tanır:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
Bu değişkeni, bir sonraki adımda modelimizi eğitirken kullanacağız.
3. adım: Modeli eğitme ve değerlendirme
Modelimizi, modelimizi bir katman yığını olarak tanımlamamıza olanak tanıyan Keras Sequential Model API'yi kullanarak oluşturacağız. Eğitim sırasında izleyeceğimiz bir dizi metrik vardır. Bu metrikler, modelimizin veri kümemizdeki her sınıfta nasıl performans gösterdiğini anlamamıza yardımcı olur.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
Ardından, eğitim sırasında kullanılacak birkaç global değişken ve erken durdurma parametresi tanımlayacağız.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Son olarak, modelimizi oluşturmak için yukarıda tanımladığımız işlevi çağıracağız:
model = make_model()
model.summary()
Modelimizi yukarıda tanımlanan parametreleri ileterek fit() yöntemiyle eğitebiliriz:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
Eğitim birkaç dakika sürer.
4. adım: Model metriklerini görselleştirin
Eğitilmiş bir modelimiz olduğuna göre, eğitim dönemlerimiz boyunca çeşitli metrikleri çizerek modelimizin nasıl performans gösterdiğine bakalım:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
Grafikleriniz aşağıdakilere benzer görünmelidir (ancak tam olarak aynı olmayacaktır):
5. adım: Karışıklık matrisi yazdırma
Karışıklık matrisi, modelimizin test veri kümesinde nasıl performans gösterdiğini görselleştirmenin iyi bir yoludur. Her sınıf için modelimizin doğru ve yanlış tahmin ettiği test örneklerinin yüzdesini gösterir. Scikit Learn, karmaşıklık matrisleri oluşturma ve çizme için bazı yardımcı programlara sahiptir. Bu yardımcı programları burada kullanacağız.
Not defterimizin başında confusion_matrix yardımcı programını içe aktarmıştık. Bu metriği kullanmak için öncelikle modelimizin tahminlerinin bir listesini oluştururuz. Burada, bu listenin kesin referans etiketleri listemizle eşleşmesi için modelimizden döndürülen değerleri yuvarlayacağız:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Şimdi bunu, kesin referans etiketlerimizle birlikte confusion_matrix yöntemine aktarmaya hazırız:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Bu metrik, test setimizdeki modelimizin doğru ve yanlış tahminlerinin mutlak sayılarını gösterir. Sol üstteki sayı, modelimizin test setimizdeki kaç örneği doğru şekilde sahtekarlık içermeyen olarak tahmin ettiğini gösterir. Sağ alttaki sayı, kaç tanesinin sahtekarlık olarak doğru şekilde tahmin edildiğini gösterir (en çok bu sayıyla ilgileniriz). Her sınıf için örneklerin çoğunu doğru tahmin ettiğini görebilirsiniz.
Bunu görselleştirmeyi kolaylaştırmak için Scikit Learn dokümanlarındaki plot_confusion_matrix işlevini uyarladık. İşlevi burada tanımlayın:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
Ardından, modelimizdeki verileri ileterek grafiği oluştururuz. Burada normalize değerini True olarak ayarlıyoruz. Böylece karışıklık matrisinde doğru ve yanlış tahminlerin sayısı yüzdeler halinde gösteriliyor:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Aşağıdakine benzer bir tablo görürsünüz (tam sayılar değişiklik gösterebilir):
Burada,modelimizin test kümemizdeki 1.594 sahtekarlık içeren işlemin yaklaşık% 85'ini doğru şekilde tahmin ettiğini görüyoruz. Bu laboratuvarda model kalitesine odaklanılmadığını unutmayın. Üretimde bir sahtekarlık algılama modeli dağıtıyorsanız sahtekarlık sınıfında% 85'ten daha yüksek bir doğruluk oranı elde etmek isteyebilirsiniz. Bu laboratuvarın amacı, dengesiz veri kümeleri üzerinde eğitilmiş modelleri açıklama araçlarını tanıtmak.
Ardından, modelimizin bu tahminleri yapmak için hangi özelliklere dayandığını anlamak üzere Açıklanabilir Yapay Zeka SDK'sını kullanacağız.
6. Açıklanabilir Yapay Zeka SDK'sını kullanma
Açıklanabilir Yapay Zeka SDK'sı, modelinizle ilgili açıklamalar almak için yardımcı yöntemler sağlar. Tensorflow AI Platform Notebook örneklerinde önceden yüklenmiş olarak gelir. Laboratuvarımızın başında not defterimize içe aktardığımızı unutmayın. SDK ile, modelimizden not defteri örneği içinde özellik ilişkilendirmeleri alabiliriz. Bu da modeli kullanmak için buluta dağıtmamız gerekmediği anlamına gelir.
Bu bölümde, yeni eğittiğimiz modeli TensorFlow SavedModel olarak dışa aktaracak, ardından açıklamalar almak için SDK'yı kaydedilmiş model varlıklarımıza yönlendireceğiz.
1. adım: Eğitilmiş modeli dışa aktarın
İlk olarak modelimizi not defteri örneğimizdeki bir dizine kaydedelim:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Not defterinizin sol kenar çubuğundaki klasör görünümünü yenilerseniz fraud_model/ adlı yeni bir dizin oluşturulduğunu görürsünüz.
2. adım: SDK ile açıklama meta verilerini alma
Ardından, Açıklanabilir Yapay Zeka SDK'sını bu dizine yönlendireceğiz. Bu işlem, model açıklamaları almak için gerekli meta verileri oluşturur. get_metadata() yöntemi, SDK'nın modelinizden çıkardığı meta verileri (ör. giriş adları) gösterir:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
Açıklanabilirlik, "Modelimiz neden bunun sahtekarlık olduğunu düşündü?" sorusunu yanıtlamamıza yardımcı olur.
3. adım: Modelimizin temel performansını belirtme
Açıklanabilir Yapay Zeka hizmeti, tablosal veriler için her özelliğin ilişkilendirme değerlerini döndürerek çalışır. Bu değerler, belirli bir özelliğin tahmini ne kadar etkilediğini gösterir. Belirli bir işlemin tutarının, modelimizin tahmin edilen sahtekarlık olasılığını %0,2 artırdığını varsayalım. "%0,2 neye göre?" diye düşünüyor olabilirsiniz. Bu noktada temel kavramına geliyoruz.
Modelimizin temel çizgisi, esasen karşılaştırma yaptığı noktadır. Modelimizdeki her özellik için temel değeri seçeriz. Bu nedenle, özellikler temel değerde ayarlandığında temel tahmin, modelimizin tahmin ettiği değer olur.
Temel model seçimi, çözdüğünüz tahmin görevine bağlıdır. Sayısal özellikler için, veri kümenizdeki her özelliğin ortanca değerini temel değer olarak kullanmak yaygındır. Ancak sahtekarlık tespitinde bu durum tam olarak istediğimiz gibi değildir. Modelimizin bir işlemi sahtekarlık olarak etiketlediği durumları açıklamaya özellikle önem veriyoruz. Bu, karşılaştırmak istediğimiz temel durumun sahtekarlık içermeyen işlemler olduğu anlamına gelir.
Bunu hesaba katmak için veri setimizdeki sahtekarlık içermeyen işlemlerin ortanca değerlerini temel olarak kullanırız. Yukarıda çıkardığımız not_fraud_sample DataFrame'i kullanarak ve modelimizin beklenen girişleriyle eşleşecek şekilde ölçeklendirerek medyanı elde edebiliriz:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
Temel bir değer belirtmemizin gerekmediğini unutmayın. Aksi takdirde SDK, modelimizin beklediği her giriş değeri için temel olarak 0'ı kullanır. Sahtekarlık tespitine yönelik kullanım alanımızda bir temel belirlemek mantıklıdır. Bunu aşağıda yapacağız:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
Yukarıdaki save_metadata() yöntemini çalıştırmak, modelimizin dizininde explanation_metadata.json adlı bir dosya oluşturdu. Dosyanın oluşturulduğunu onaylamak için not defterinizde fraud_model/ dizinine gidin. Bu, SDK'nın özellik ilişkilendirmeleri oluşturmak için kullanacağı meta verileri içerir.
4. adım: Model açıklamalarını alma
Artık tek tek örneklerde özellik ilişkilendirmelerini almaya hazırız. Bunu yapmak için önce SDK'yı kullanarak modelimize yerel bir referans oluşturacağız:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Ardından, sahtekarlık olarak sınıflandırılması gereken örnek bir işlemden modelimizle ilgili tahminler ve açıklamalar alalım:
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
Bu komut çalıştırıldığında aşağıdaki gibi bir görselleştirme oluşturulur:
Bu örnekte, işlem gerçekleşmeden önceki başlangıç bakiyesi, dolandırıcılığın en büyük göstergesiydi ve modelimizin tahminini temel değerin 0,5 puan üzerine çıkardı. İşlemin tutarı, hedef hesaptaki sonuç bakiyesi ve adım, sonraki en büyük göstergelerdi. Veri kümesinde "adım" bir zaman birimini temsil eder (1 adım 1 saattir). İlişkilendirme değerleri negatif de olabilir.
Görselleştirmelerin üzerinde yazan "yaklaşım hatası", açıklamaya ne kadar güvenebileceğinizi gösterir. Genellikle% 5'in üzerindeki hata, özellik ilişkilendirmelerine güvenemeyebileceğiniz anlamına gelir. Açıklamalarınızın kalitesinin, kullandığınız eğitim verilerinin ve modelin kalitesiyle sınırlı olduğunu unutmayın. Eğitim verilerinizi, modelinizi iyileştirmek veya farklı bir model temeli denemek, yaklaşım hatasını azaltabilir.
Açıklama yönteminizde kullanılan adım sayısını artırarak bu hatayı azaltabilirsiniz. Açıklama yapılandırmanıza path_count parametresini ekleyerek SDK ile bunu değiştirebilirsiniz (belirtmezseniz varsayılan değer 10'dur):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Bu modelde açıklanabilir yapay zeka ile yapabileceğiniz çok daha fazla şey var. Örneğin:
- Modelimize birçok örnek gönderip belirli özelliklerin genel olarak daha önemli olup olmadığını görmek için ilişkilendirme değerlerinin ortalamasını alma. Bu bilgileri modelimizi geliştirmek ve önemli olmayan özellikleri kaldırmak için kullanabiliriz.
- Modelimizin sahtekarlık olarak işaretlediği ancak sahtekarlık içermeyen işlemler olan yanlış pozitifleri bulma ve bunların ilişkilendirme değerlerini inceleme
- Farklı bir temel kullanın ve bunun ilişkilendirme değerlerini nasıl etkilediğini görün.
🎉 Tebrikler! 🎉
Dengesiz verileri nasıl hesaba katacağınızı, sahte işlemleri tespit etmek için TensorFlow modelini nasıl eğiteceğinizi ve modelinizin tek tek tahminlerde bulunmak için en çok hangi özelliklerden yararlandığını görmek üzere Açıklanabilir Yapay Zeka SDK'sını nasıl kullanacağınızı öğrendiniz. İsterseniz burada durabilirsiniz. SDK'yı not defterinde kullanmak, bir modeli dağıtmadan önce açıklamalara erişmenizi sağlayarak model geliştirme sürecinizi basitleştirmeyi amaçlar. Memnun kaldığınız bir model oluşturduktan sonra, tahminleri ölçekli olarak almak için bu modeli dağıtmak isteyebilirsiniz. Bu açıklama size uyuyorsa isteğe bağlı olan sonraki adıma geçin. İşiniz bittiyse Temizleme adımına geçin.
7. İsteğe bağlı: Modeli AI Platform Prediction'a dağıtma
Bu adımda, modelinizi AI Platform Prediction'a nasıl dağıtacağınızı öğreneceksiniz.
1. adım: Kaydedilmiş model dizininizi bir Cloud Storage paketine kopyalayın.
Daha önce çalıştırdığımız SDK adımlarıyla, modelinizi AI Platform'a dağıtmak için ihtiyacınız olan her şeye sahipsiniz. Dağıtıma hazırlanmak için SavedModel öğelerinizi ve açıklama meta verilerinizi, Açıklanabilir Yapay Zeka hizmetinin okuyabileceği bir Cloud Storage paketine yerleştirmeniz gerekir.
Bunu yapmak için bazı ortam değişkenleri tanımlayacağız. Aşağıdaki değerleri Google Cloud projenizin adı ve oluşturmak istediğiniz paketin adıyla (genel olarak benzersiz olmalıdır) doldurun.
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Artık dışa aktarılan TensorFlow modeli varlıklarımızı depolamak için bir depolama paketi oluşturmaya hazırız. Modeli dağıtırken AI Platform'u bu pakete yönlendireceğiz.
Paket oluşturmak için not defterinizden şu gsutil komutunu çalıştırın:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Ardından, yerel model dizininizi bu pakete kopyalayın:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
2. adım: Modeli dağıtın
Ardından, dağıtım komutlarımızda kullanacağımız bazı değişkenleri tanımlayacağız:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Aşağıdaki gcloud komutuyla modeli oluşturabiliriz:
!gcloud ai-platform models create $MODEL --region=us-central1
Artık bu modelin ilk sürümünü gcloud ile dağıtmaya hazırız. Sürümün dağıtılması yaklaşık 5-10 dakika sürer:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
origin işaretinde, kaydedilen modelimizin ve meta veri dosyamızın Cloud Storage konumunu iletiyoruz. Açıklanabilir yapay zeka'da şu anda tablo biçimli modeller için iki farklı açıklama yöntemi mevcuttur. Burada Örneklenmiş Shapley kullanıyoruz. num-paths parametresi, her giriş özelliği için örneklenen yol sayısını gösterir. Genel olarak, model ne kadar karmaşıksa makul bir yakınsamaya ulaşmak için o kadar çok yaklaştırma adımı gerekir.
Modelinizin doğru şekilde dağıtıldığını onaylamak için aşağıdaki gcloud komutunu çalıştırın:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Durum READY olmalıdır.
3. adım: Dağıtılan modelle ilgili tahminler ve açıklamalar alma
Açıklanabilirlik açısından, modelimizin sahtekarlık tahmin ettiği durumları açıklamaya en çok önem veriyoruz. Modelimize, hepsi sahtekarlık içeren 5 test örneği göndeririz.
Tahmin almak için Google Cloud KSA'yı kullanacağız. Test setimizdeki tüm sahtekarlık örneklerinin dizinlerini almak için aşağıdaki kodu çalıştırın:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Ardından, modelimizin beklediği biçimde 5 örnek kaydedip bunları bir dosyaya yazacağız:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
Bu beş örneği gcloud kullanarak modelimize gönderebiliriz:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
Yanıt JSON'ında, bu örneklerdeki her bir özelliğin ilişkilendirme değerlerini görürsünüz. Her örnek için example_score anahtarı, modelin tahminini (bu durumda, belirli bir işlemin sahtekarlık olma olasılığının yüzdesi) içerir.
8. Temizleme
Bu not defterini kullanmaya devam etmek istiyorsanız kullanmadığınız zamanlarda kapatmanız önerilir. Cloud Console'unuzdaki Notebooks kullanıcı arayüzünde not defterini ve ardından Durdur'u seçin:
Bu laboratuvarda oluşturduğunuz tüm kaynakları silmek istiyorsanız not defteri örneğini durdurmak yerine silmeniz yeterlidir.
Cloud Console'daki gezinme menüsünü kullanarak Storage'a gidin ve model varlıklarınızı depolamak için oluşturduğunuz her iki paketi de silin.