1. Genel Bakış
Bu laboratuvarda, sahte işlemleri tespit etmeye yönelik bir model oluşturup eğitmek için AI Platform Notebooks'u kullanacak ve Explainable AI SDK'yı kullanarak modelin tahminlerini anlayacaksınız. Sahtekarlık algılama, finansal hizmetlere özgü bir anormallik algılama türüdür ve makine öğrenimi modelleri için bazı ilginç zorluklar ortaya çıkarır: doğası gereği dengesiz olan veri kümeleri ve bir modelin sonuçlarını açıklama ihtiyacı.
Öğrendikleriniz
Öğrenecekleriniz:
- Dengesiz veri kümelerini işleme
- AI Platform Notebooks'ta tf.keras ile sahtekarlık algılama modeli oluşturup değerlendirme
- Modelin işlemleri neden sahte olarak sınıflandırdığını anlamak için not defterindeki Explainable AI SDK'sını kullanın.
- Modeli AI Platform'a açıklamalarla birlikte dağıtma ve dağıtılan modelle ilgili tahminler ve açıklamalar alma
Bu laboratuvarı Google Cloud'da çalıştırmanın toplam maliyeti yaklaşık 1 ABD dolarıdır.
2. Neden sahtekarlık tespiti?
Verilerdeki aykırı değerleri belirlemek için bir dizi kural tabanlı ifade yazmak genellikle zor olduğundan anormallik algılama, makine öğrenimi için iyi bir aday olabilir. Bir tür anormallik algılama türüdür ve makine öğrenimi söz konusu olduğunda iki ilginç zorluk ortaya çıkarır:
- Çok dengesiz veri kümeleri: Anormallikler olduğu için çok fazla değildir. Makine öğrenimi en iyi performansı veri kümeleri dengelendiğinde gösterir. Bu nedenle, verilerinizin% 1'inden azını aykırı değerler oluşturduğunda işler karmaşıklaşabilir.
- Sonuçların açıklanması gerekir: Sahtekarlık içeren bir etkinlik arıyorsanız büyük ihtimalle bir şeyi yalnızca yerine getirmek yerine sistemin neden sahte olarak işaretlediğini öğrenmek istersiniz. Açıklanabilirlik araçları bu konuda size 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 var. Proje oluşturmak için buradaki talimatları uygulayın.
1. Adım: Cloud AI Platform Models API'yi etkinleştirin
Cloud Console'un AI Platform Modelleri bölümüne gidin ve etkinleştirilmemişse Etkinleştir'i tıklayın.
2. Adım: Compute Engine API'yi etkinleştirin
Compute Engine'e gidin ve zaten etkinleştirilmemişse Etkinleştir'i seçin. Not defteri örneğinizi oluşturmak için buna ihtiyacınız olacaktır.
3. Adım: AI Platform Notebooks örneği oluşturun
Cloud Console'un 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ın ve ardından Oluştur'u tıklayın. Örnek oluşturulduktan sonra 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'dan sentetik olarak oluşturulmuş bu veri kümesini kullanacağız. Orijinal veri kümesinde 6,3 milyon satır bulunur. Bu satırların 8'i sahte işlemlerdir. Yani, veri kümesinin yalnızca% 0,1'i kadardır.
1. Adım: Kaggle veri kümesini indirin ve Pandas ile okuyun
Kaggle veri kümesini Google Cloud Storage'da kullanımınıza sunuyoruz. Jupyter not defterinizde aşağıdaki gsutil komutunu çalıştırarak indirebilirsiniz:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Sonra, veri kümesini Pandas DataFrame olarak okuyup önizleyelim:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
Önizlemede şuna benzer bir sayfa görürsünüz:
2. Adım: Dengesiz verilerin hesaba katılması
Yukarıda belirtildiği gibi, şu anda veri kümesi sahte olmayan örneklerin% 99,9'unu içermektedir. Bir modeli veriler üzerinde olduğu gibi eğitirsek, verilerin% 99,9'u sahte olmayan destek kayıtları olduğu için her işlemin sahte olmadığını tahmin ederek modelin% 99,9 doğruluk oranına ulaşması muhtemeldir.
Dengesiz verilerle başa çıkmak için birkaç farklı yaklaşım vardır. Bu örnekte, aşağı örnekleme adlı bir teknik kullanacağız. Örnekleme, eğitimde çoğunluk sınıfından yalnızca küçük bir kısmının kullanılması anlamına gelir. Bu örnekte, "sahtekar değil" en büyük sınıf hâline geldi.Çünkü bu veriler verilerin% 99,9'unu oluşturuyor.
Veri kümemizi küçültmek için yaklaşık 8.000 sahte örneği ve sahtekarlık içermeyen vakaların yaklaşık 31.000'ini rastgele alırız. Bu sayede, ortaya çıkan veri kümesinde önceki% 0,1'lik orana kıyasla% 25 sahtekarlık vakası elde edilir.
Öncelikle verileri biri sahtekarlık, diğeri ise sahtekarlıkla ilgili olmayan için olmak üzere iki DataFrame'e bölün (bunu daha sonra, modelimizi dağıttığımızda codelab'de kullanacağız):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Ardından, sahtekarlıkla ilgili olmayan destek kayıtlarından rastgele bir örnek alın. Sahtekarlık içeren/sahtekarlık yapılmayan işlemler için% 0,005 oranında pay kullanıyoruz. Bu sayede, verileri bir araya getirip karıştırabilirsiniz. İşleri basitleştirmek amacıyla, 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. Bununla birlikte, modelimizin yaklaşık% 75'lik bir doğruluk oranı olduğunu fark edersek modelimizin "sahtekar olmadığını" tahmin etme olasılığı yüksektir. önemlidir.
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 grubunu 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: Sahtekarlık tespiti için finansal mobil para simülasyon aracı". In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaka, Kıbrıs. 2016
5. tf.keras modeli oluşturma, eğitme ve değerlendirme
TensorFlow'un tf.keras API'sini kullanarak oluşturacağız. Bu bölümdeki model kodu, TensorFlow belgelerindeki bu eğitim temel alınarak oluşturulmuştur. İlk olarak verileri normalleştireceğiz. Ardından, kalan veri dengesizliğini hesaba katmak için class_weight parametresini kullanarak modelimizi oluşturup eğiteceğiz.
1. Adım: Verileri normalleştirin
Bir modeli sayısal veriler üzerinde eğitirken, özellikle de her sütun farklı bir aralığa düştüğünde verileri normalleştirmeniz önemlidir. Bu sayede eğitim sırasında kayıpların patlamasını önleyebilirsiniz. Aşağıdakileri kullanarak verilerimizi 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)
Daha sonra, normalleştirilmiş verilerimizin önizlemesini yapalım:
train_set
2. Adım: Sınıf ağırlıklarını belirleme
Verilerde örnekleme sürecini başlatırken, sahte olmayan işlemlerin bir alt kümesini tutmak istedik. Böylece bu işlemlerle ilgili bilgileri kaybetmemiş olduk. Bu nedenle verileri kusursuz bir dengeye kavuşturmadık. Veri kümesi hâlâ dengesiz olduğundan ve sahte işlemleri doğru şekilde tanımlamaya önem verdiğimiz için modelimizin veri kümemizdeki sahte örneklere daha fazla ağırlık vermesini istiyoruz.
Keras class_weight parametresi, her bir sınıftan, veri kümesinde ne sıklıkta gerçekleştiklerine göre tam olarak ne kadar ağırlık örnek vermek istediğimizi belirtmenizi sağlar:
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}
Bir sonraki adımda modelimizi eğitirken bu değişkeni kullanacağız.
3. adım: Modeli eğitin ve değerlendirin
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, modelimizin veri kümemizdeki her sınıfta nasıl performans gösterdiğini anlamamıza yardımcı olacak birkaç metrik izleyeceğiz.
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, bazı erken durdurma parametreleriyle birlikte eğitim sırasında kullanılacak birkaç genel değişken 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 yapmak için yukarıda tanımladığımız fonksiyona atıfta bulunacağı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ğitimin tamamlanması birkaç dakika sürer.
4. Adım: Model metriklerini görselleştirin
Artık eğitilmiş bir modelimiz olduğuna göre, eğitim dönemleri boyunca çeşitli metrikler çizerek modelimizin nasıl performans gösterdiğini inceleyelim:
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ğıdakine benzer bir görünümde olacaktır (ancak tamamen aynı olmayacaktır):
5. Adım: Bir karışıklık matrisi yazdırın
Karışıklık matrisi, modelimizin test veri kümesi genelinde nasıl performans gösterdiğini görselleştirmenin güzel bir yoludur. Her sınıf için, modelimizin doğru ve yanlış tahmin ettiği test örneklerinin yüzdesini gösterir. Scikit Learn, burada karışıklık matrisleri oluşturmaya ve çizmeye yönelik bazı yardımcı programlar sunmaktadır.
Not defterimizin başında confusion_matrix yardımcı programını içe aktardık. Bunu kullanmak için önce modelimizin tahminlerinin bir listesini oluşturacağız. Bu listede, 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 iletmeye hazırız:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Bu, modelimizin test kümemizdeki doğru ve yanlış tahminlerinin mutlak sayılarını gösterir. Sol üstteki sayı, test setimizden kaç tanesinin modelimizin sahte olmadığını doğru şekilde tahmin ettiğini gösterir. Sağ alttaki sayı, doğru tahmin edilen kaç tanesinin sahte olduğunu gösterir (en çok bu sayıya önem veriyoruz). Her sınıf için örneklerin çoğunluğunun doğru tahmin edildiğini görebilirsiniz.
Görselleştirmeyi kolaylaştırmak için plot_confusion_matrix işlevini Scikit Learn dokümanlarından uyarladık. Bu fonksiyonu 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')
Daha sonra, modelimizden elde edilen verileri ileterek grafiği oluşturun. Karışıklık matrisinde doğru ve yanlış tahminlerin sayısının yüzde cinsinden görüntülenmesi için normalize değerini burada True değerine ayarlıyoruz:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Aşağıdaki gibi bir değer görürsünüz (tam sayılar değişiklik gösterir):
Burada,modelimizin test grubumuzdaki 1.594 sahte işlemin% 85'inin doğru şekilde tahmin edildiğini görebiliriz. Bu laboratuvarda model kalitesi üzerinde odaklanılmadığını unutmayın. Üretimde bir sahtekarlık algılama modeli dağıtıyorsanız muhtemelen sahtekarlık sınıfında% 85'in üzerinde doğruluk elde etmek istersiniz. Bu laboratuvarın amacı, dengesiz veri kümeleri üzerinde eğitilmiş modelleri açıklamaya yönelik araçları tanıtmaktır.
Ardından, modelimizin bu tahminleri yaparken hangi özelliklerden yararlandığını anlamak için Explainable AI SDK'sını kullanacağız.
6. Explainable AI SDK'sını kullanma
Explainable AI SDK, modelinizle ilgili açıklamalar almak için yardımcı yöntemler sunar. Tensorflow AI Platform Notebooks örneklerinde önceden yüklenmiş olarak gelir. Laboratuvarımızın başında onu not defterimize aktardığımızı unutmayın. SDK sayesinde, not defteri örneğindeki modelimizden özellik ilişkilendirmeleri alabiliriz. Bu da modelimizi kullanmak için buluta dağıtmamız gerekmediği anlamına gelir.
Bu bölümde, Tensorflow SavedModel olarak eğittiğimiz modeli dışa aktaracak ve ardından açıklama almak için SDK'yı kayıtlı model öğelerimize yönlendireceğiz.
1. Adım: Eğitilen modeli dışa aktarın
Öncelikle, 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/ adında yeni bir dizin oluşturulur.
2. Adım: SDK ile açıklama meta verilerini alın
Ardından, Explainable AI SDK'sını bu dizine yönlendireceğiz. Bu işlem, model açıklamalarını almak için gereken 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 temelini belirtme
Explainable AI hizmeti, tablo verilerinde her bir özellik iç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 öngörülen sahtekarlık olasılığını %0,2 artırmasına neden olduğunu varsayalım. "Neye göre% 0,2?" diye düşünüyor olabilirsiniz. Bu da bizi temel çizgi kavramına getiriyor.
Modelimizin temeli, esasen modelin karşılaştırma yaptığı değerdir. Modelimizdeki her özellik için bir referans değer seçeriz ve sonuç olarak temel tahmin, özellikler temel değere ayarlandığında modelimizin tahmin ettiği değer haline gelir.
Temel çizgisinin seçilmesi, çözmekte olduğunuz tahmin görevine bağlıdır. Sayısal özelliklerde, veri kümenizdeki her özelliğin ortanca değerini temel olarak kullanmak yaygın bir uygulamadır. Ancak sahtekarlık tespiti söz konusu olduğunda bununla tam olarak istediğimiz bir şey değildir. En çok, modelimizin bir işlemin sahte olarak etiketlendiği durumları açıklamaya önem veririz. Bu, karşılaştırmak istediğimiz temel durumun sahtekarlık amacı taşımayan işlemler olduğu anlamına gelir.
Bunu hesaba katmak için, veri kümemizdeki sahte olmayan işlemlerin ortanca değerlerini temel olarak kullanırız. Ortanca değeri, yukarıda çıkardığımız not_fraud_sample DataFrame'i kullanarak ve modelimizin beklenen girişleriyle eşleşecek şekilde ölçeklendirerek 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)
Referans değer belirtmemiz gerekmediğini unutmayın. Aksi takdirde SDK, modelimizin beklediği her giriş değeri için temel olarak 0'ı kullanır. Sahtekarlık tespiti kullanım örneğimizde, bir referans değer belirtmek mantıklıdır. Bunu aşağıda kullanacağı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öntemi çalıştırıldığında, modelimizin dizininde explanation_metadata.json adlı bir dosya oluşturuldu. Dosyanın oluşturulduğunu onaylamak için not defterinizde sahtekarlığı_model/ dizinine gidin. Bu dosya, SDK'nın özellik ilişkilendirmeleri oluşturmak için kullanacağı meta verileri içerir.
4. Adım: Model açıklamaları alma
Artık tek tek örneklerde özellik ilişkilendirmelerini almaya hazırız. Bunun 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()
)
Şimdi de sahtekar olarak sınıflandırılması gereken örnek bir işlemden modelimizle ilgili tahminlere ve açıklamalara göz atalı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ğıdakine benzer bir görselleştirme oluşturulur:
Bu örnekte, işlem gerçekleşmeden önceki hesabın başlangıç bakiyesi, sahtekarlığın en büyük göstergesiydi.Bu da modelimizin tahminini referans değerden 0,5'in üzerine çıkararak. İşlemin tutarı, hedef hesapta oluşan bakiye ve adım, ondan sonraki en önemli göstergelerdi. Veri kümesinde "adım" bir zaman birimini temsil eder (1 adım 1 saattir). İlişkilendirme değerleri de negatif olabilir.
"Yaklaşık değer hatası" bir açıklamaya ne kadar güvenebileceğinizi gösterir. Genellikle% 5'in üzerindeki bir hata, özellik ilişkilendirmelerine güvenemeyebileceği anlamına gelir. Açıklamalarınızın yalnızca kullandığınız eğitim verileri ve model kadar iyi olduğunu unutmayın. Eğitim verilerinizi veya modelinizi iyileştirmek ya da farklı bir model temel çizgisini denemek, yaklaşık hata oranını azaltabilir.
Ayrıca, açıklama yönteminizde kullanılan adım sayısını artırarak bu hatayı azaltabilirsiniz. Açıklama yapılandırmanıza path_count parametresi ekleyerek bu durumu SDK ile değiştirebilirsiniz (belirtmezseniz varsayılan değer 10 olur):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Bu modelde Explainable AI ile yapabileceğiniz daha pek çok şey var. Bununla ilgili bazı fikirler:
- Belirli özelliklerin genel olarak daha önemli olup olmadığını görmek için modelimize birçok örnek gönderme ve ilişkilendirme değerlerinin ortalamasını alma. Bunu modelimizi iyileştirmek ve önemli olmayan özellikleri kaldırmak için kullanabiliriz
- Modelimizin sahtekarlık olarak işaretlediği ancak sahtekarlık amacı taşımayan işlemler olduğu yönünde yanlış pozitif sonuçlar bulma ve ilişkilendirme değerlerini inceleme
- Farklı bir referans değer kullanın ve bunun ilişkilendirme değerlerini nasıl etkilediğini görün
🎉 Tebrikler! 🎉
Dengesiz verileri hesaba katmayı, sahtekarlık amaçlı işlemleri tespit etmek için bir TensorFlow modelini eğitmeyi ve Explainable AI SDK'sını kullanarak modelinizin bağımsız tahminlerde bulunmak için en çok hangi özelliklere ihtiyaç duyduğunu öğrendiniz. İsterseniz burada durabilirsiniz. SDK'yı not defterinde kullanmak, modeli dağıtmadan önce açıklamalara erişmenizi sağlayarak model geliştirme sürecinizi basitleştirir. Memnun kaldığınız bir model oluşturduktan sonra, geniş ölçekte tahminler almak için bu modeli dağıtmak isteyebilirsiniz. Bu sizin için uygunsa isteğe bağlı bir sonraki adıma geçin. Bitirdiyseniz Temizleme adımına geçin.
7. İsteğe bağlı: Modeli AI Platform Tahmin'e dağıtma
Bu adımda, modelinizi AI Platform Prediction'a nasıl dağıtacağınızı öğreneceksiniz.
1. Adım: Kayıtlı model dizininizi bir Cloud Storage paketine kopyalayın.
Daha önce uyguladığımız SDK adımları sayesinde, 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 Explainable AI hizmetinin okuyabileceği bir Cloud Storage Paketine yerleştirmeniz gerekir.
Bunun için bazı ortam değişkenlerini tanımlayacağız. Aşağıdaki değerleri Google Cloud projenizin ve oluşturmak istediğiniz paketin adıyla girin (genel olarak benzersiz olmalıdır).
# 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 model öğelerimizi depolamak için bir depolama paketi oluşturmaya hazırız. Modeli dağıttığımızda AI Platform'u bu pakete yönlendireceğiz.
Paket oluşturmak için not defterinizde şu gsutil komutunu çalıştırın:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Ardından yerel model dizininizi ilgili pakete kopyalayın:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
2. Adım: Modeli dağıtın
Şimdi, 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'
Modeli aşağıdaki gcloud komutuyla 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, kayıtlı modelimizin ve meta veri dosyamızın Cloud Storage konumunu iletiriz. Explainable AI, şu anda tablo biçiminde modeller için iki farklı açıklama yöntemi sunar. Burada Sampled Shapley'yi kullanıyoruz. num-paths parametresi, her bir giriş özelliği için örneklenen yol sayısını belirtir. Genel olarak, model ne kadar karmaşıksa, makul bir yakınlaşmaya ulaşmak için o kadar yakın yaklaşım adımları 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
Eyalet READY olmalıdır.
3. adım: Dağıtılan modelle ilgili tahminleri ve açıklamaları alma
Açıklanabilirlik için en çok, modelimizin sahtekarlığı tahmin ettiği durumları açıklamaya önem veririz. Modelimize, tümü sahte olan 5 test örneği göndereceğiz.
Tahmin almak için Google Cloud KSA'yı kullanırız. Test grubumuzdan 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 kaydedeceğiz ve 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)
gcloud kullanarak modelimize şu beş örneği gönderebiliriz:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
Yanıt JSON dosyasında, bu örneklerde her bir özelliğin ilişkilendirme değerlerini göreceksiniz. Her örnek için example_score anahtarı, modelin tahminini içerir. Bu durumda, belirli bir işlemin sahte olma olasılığı yüzde olarak belirtilir.
8. Temizleme
Bu not defterini kullanmaya devam etmek istiyorsanız, kullanılmadığında devre dışı bırakmanız önerilir. Cloud Console'daki Not Defteri kullanıcı arayüzünden 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 silin.
Cloud Console'daki gezinme menüsünü kullanarak Storage'a gidin ve model öğelerinizi depolamak için oluşturduğunuz her iki paketi de silin.