TensorFlow Enterprise ve BigQuery ile Cloud AI Platform'da Sahtekarlık Algılama modeli oluşturma

1. Genel Bakış

Bu laboratuvarda, doğrudan bir BigQuery veri kümesini alacak ve Google Cloud AI Platform'da TensorFlow Enterprise ile bir sahtekarlık algılama modeli eğiteceksiniz.

Öğrenecekleriniz

Öğrenecekleriniz:

• BigQuery'deki verileri analiz etme
• TensorFlow Enterprise'daki BigQuery bağlayıcısını kullanarak veri alma
• Dengesiz veri kümesiyle sahtekarlığı tespit etmek için derin öğrenme modeli oluşturma

2. BigQuery'deki verileri analiz etme

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: BigQuery herkese açık veri kümesine erişin

Google Cloud Console'da BigQuery herkese açık veri kümelerine erişmek için bu bağlantıyı takip edin.

Sol alt köşedeki Kaynak Ağacı'nda veri kümelerinin listesini görürsünüz. ml-datasets'i bulana kadar mevcut veri kümelerinde ilerleyin ve ardından bu veri kümesindeki ulb-fraud-detection tablosunu seçin:

Veri kümesi hakkında daha fazla bilgi edinmek için sekmeleri tıklayın:

• Şema sekmesinde veri türleri açıklanır.
• Ayrıntılar sekmesinde, bu işlemin 284.407 işlem içeren dengesiz bir veri kümesi olduğu ve bu işlemlerden 492'sinin sahtekarlık amaçlı olduğu açıklanmaktadır.
• Önizleme sekmesinde veri kümesindeki kayıtlar gösterilir.

2. adım: Tabloya sorgu uygulayın

Ayrıntılar sekmesinde verilerle ilgili şu bilgiler yer alır:

• Süre, veri kümesindeki ilk işlem ile seçilen işlemin zamanı arasındaki saniye sayısıdır.
• V1-V28, verileri anonimleştiren PCA adlı bir boyut azaltma tekniğiyle dönüştürülmüş sütunlardır.
• Tutar, işlem tutarıdır.

Bir sorgu çalıştırmak için Tabloyu Sorgula'yı tıklayarak daha yakından inceleyelim:

Tüm sütunları görüntülemek için ifadeyi * ekleyecek şekilde güncelleyin ve Çalıştır'ı tıklayın.

SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000

3. adım: Verileri analiz edin

BigQuery, çeşitli istatistiksel işlevler sunar. Verilerin hedef değişken Sınıf ile nasıl ilişkili olduğuna bir göz atalım.

SELECT CORR(Time,Class) as TimeCorr, CORR(V1,Class) as V1Corr, CORR(V2,Class) as V2Corr, CORR(Amount,Class) as AmountCorr FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`

Korelasyon, -1 (negatif korelasyon) ile 1 (pozitif korelasyon) arasında bir aralık sağlar. 0 ise bağımsızdır.

V1 ve V2'nin hedef değişkenimizle hafif bir korelasyonu (sırasıyla yaklaşık -0,1 ve 0,1) olduğunu unutmayın.

Zaman ile çok fazla korelasyon görmüyoruz. Hafif bir negatif korelasyon, veri kümesinde zaman içinde daha az sahtekarlık içeren işlem olduğunu gösterebilir.

Tutar daha da düşük bir korelasyona sahiptir. Bu da sahtekarlık içeren işlemlerin, daha yüksek işlem tutarlarında çok az daha olası olduğunu gösterir.

4. adım: Özellik ölçeklendirme için ortalama değerleri hesaplayın

Özellik değerlerini normalleştirme, sinir ağının daha hızlı yakınsamasına yardımcı olabilir. Yaygın bir şema, değerleri 1 standart sapmayla 0 etrafında ortalamaktır. Aşağıdaki sorgu, ortalama değerleri alır. Sonucu kaydetmeniz gerekmez. Bunun için daha sonra bir kod snippet'i oluşturacağız.

Ayrıca sorgunun ilginç bir WHERE ifadesi içerdiğini de fark edeceksiniz. Verilerin eğitim ve test kümeleri arasında nasıl bölüneceğini ele alacağımız bir sonraki bölümde bu konuyu açıklayacağız.

SELECT
   AVG(Time), AVG(V1), AVG(V2), AVG(V3), AVG(V4), AVG(V5), AVG(V6), AVG(V7), AVG(V8),
   AVG(V9), AVG(V10),AVG(V11), AVG(V12), AVG(V13), AVG(V14), AVG(V15), AVG(V16),
   AVG(V17), AVG(V18), AVG(V19), AVG(V20), AVG(V21), AVG(V22), AVG(V23), AVG(V24),
   AVG(V25), AVG(V26), AVG(V27),AVG(V28), AVG(Amount)
FROM
   `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE
   MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),
   SAFE_CAST(Amount AS STRING)))),10) < 8

5. adım: Verileri bölme

Makine öğrenimi modeli oluştururken 3 veri kümesi kullanmak yaygın bir uygulamadır:

• Eğitim: Parametreleri yinelemeli olarak ayarlayarak modeli oluşturmak için kullanılır.
• Doğrulama: Eğitim sürecinde bağımsız veriler üzerinde doğrulama yaparak modelin aşırı uyum gösterip göstermediğini değerlendirmek için kullanılır.
• Test: Doğruluğu değerlendirmek için model oluşturulduktan sonra kullanılır.

Bu codelab'de 80/10/10 eğitim/doğrulama/test bölümü kullanacağız.

Her veri kümesini BigQuery'de kendi tablosuna yerleştiririz. İlk adım, ilgili tabloların bulunduğu bir kapsayıcı olan BigQuery "veri kümesi" oluşturmaktır. Projeniz seçiliyken Veri Kümesi Oluştur'u seçin.

Ardından, eğitim, doğrulama ve test tablolarını içerecek tfe_codelab adlı bir veri kümesi oluşturun.

Şimdi eğitim, test ve doğrulama için 3 sorgu çalıştırıp verileri yeni tfe_codelab veri kümesine kaydedeceğiz.

Sorgu düzenleyicide, eğitim verilerini oluşturmak için bir sorgu çalıştırın:

SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) < 8

Sorgu tamamlandığında sonuçları BigQuery tablosuna kaydedin.

Yeni oluşturduğunuz tfe_codelab veri kümesinde tabloyu ulb_fraud_detection_train olarak adlandırın ve verileri kaydedin.

WHERE koşulu, önce birkaç sütunda karma oluşturarak verileri böler. Ardından, karma değerinin 10'a bölünmesiyle elde edilen kalanın 80'den küçük olduğu satırları seçerek %80'lik bir sonuç elde eder.

Şimdi de doğrulama ve test kümeleri için aynı işlemi tekrarlayalım. Bu kümeler, her biri verilerin% 10'unu seçen benzer sorgular içerir.

Doğrulama

SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 8

Bu sorgunun sonuçlarını ulb_fraud_detection_val adlı bir tabloya kaydedin.

Test etme

SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 9

Bu sorgunun sonuçlarını ulb_fraud_detection_test adlı bir tabloya kaydedin.

3. Not defteri ortamınızı ayarlama

Verilere kısa bir giriş yaptığımıza göre şimdi model geliştirme ortamımızı ayarlayalım.

1. adım: API'leri etkinleştirin

BigQuery bağlayıcısı, BigQuery Storage API'yi kullanır. Konsolda BigQuery Storage API'yi arayın ve şu anda devre dışıysa API'yi etkinleştirin.

2. 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, en son TensorFlow Enterprise 1.x örnek türünü GPU'suz olarak 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:

Ardından, JupyterLab'den bir Python 3 not defteri oluşturun:

4. BigQuery'den kayıt alma

1. adım: Python paketlerini içe aktarın

Bu codelab'in geri kalanında, Jupyter not defterinizdeki tüm kod snippet'lerini çalıştırın.

Not defterinizin ilk hücresine aşağıdaki içe aktarma işlemlerini ekleyin ve hücreyi çalıştırın. Bu işlemi, üst menüdeki sağ ok düğmesine veya command-enter tuşlarına basarak çalıştırabilirsiniz:

import tensorflow as tf
import tensorflow.keras as keras
import tensorflow.keras.layers as layers

from tensorflow_io.bigquery import BigQueryClient

import functools

tf.enable_eager_execution()

2. adım: Sabitleri tanımlayın

Şimdi projede kullanılacak bazı sabitleri tanımlayalım. GCP_PROJECT_ID kısmını kullandığınız gerçek proje kimliğiyle değiştirin. Oluşturduğunuz yeni hücreleri çalıştırabilirsiniz.

GCP_PROJECT_ID = '<YOUR_PROJECT_ID>'
DATASET_GCP_PROJECT_ID = GCP_PROJECT_ID # A copy of the data is saved in the user project
DATASET_ID = 'tfe_codelab'
TRAIN_TABLE_ID = 'ulb_fraud_detection_train'
VAL_TABLE_ID = 'ulb_fraud_detection_val'
TEST_TABLE_ID = 'ulb_fraud_detection_test'

FEATURES = ['Time','V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19','V20','V21','V22','V23','V24','V25','V26','V27','V28','Amount']
LABEL='Class'
DTYPES=[tf.float64] * len(FEATURES) + [tf.int64]

3. adım: Yardımcı işlevleri tanımlayın

Şimdi birkaç işlev tanımlayalım. read_session(), BigQuery tablosundan veri okur. extract_labels(), etiket sütununu diğerlerinden ayırmaya yarayan bir yardımcı işlevdir. Böylece veri kümesi, daha sonra keras.model_fit() tarafından beklenen biçimde olur.

client = BigQueryClient()

def read_session(TABLE_ID):
    return client.read_session(
        "projects/" + GCP_PROJECT_ID, DATASET_GCP_PROJECT_ID, TABLE_ID, DATASET_ID,
        FEATURES + [LABEL], DTYPES, requested_streams=2
)

def extract_labels(input_dict):
  features = dict(input_dict)
  label = tf.cast(features.pop(LABEL), tf.float64)
  return (features, label)

4. adım: Verileri alma

Son olarak, her veri kümesini oluşturalım ve ardından eğitim veri kümesinden ilk grubu yazdıralım. BATCH_SIZE değerini 32 olarak tanımladığımızı unutmayın. Bu, eğitimin hızını ve doğruluğunu etkileyecek önemli bir parametredir.

BATCH_SIZE = 32

raw_train_data = read_session(TRAIN_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_val_data = read_session(VAL_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_test_data = read_session(TEST_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)

next(iter(raw_train_data)) # Print first batch

5. Model oluşturma

1. adım: Verileri önceden işleyin

Veri kümesindeki her özellik için özellik sütunları oluşturalım. Bu veri kümesinde tüm sütunlar numeric_column türündedir ancak başka sütun türleri de vardır (ör. categorical_column).

Daha önce de belirttiğimiz gibi, ağın daha hızlı yakınlaşması için verileri sıfır etrafında normalleştireceğiz. Bu hesaplamada kullanılacak her özelliğin ortalamasını önceden hesapladık.

MEANS = [94816.7387536405, 0.0011219465482001268, -0.0021445914636999603, -0.002317402958335562,
         -0.002525792169927835, -0.002136576923287782, -3.7586818983702984, 8.135919975738768E-4,
         -0.0015535579268265718, 0.001436137140461279, -0.0012193712736681508, -4.5364970422902533E-4,
         -4.6175444671576083E-4, 9.92177789685366E-4, 0.002366229151475428, 6.710217226762278E-4,
         0.0010325807119864225, 2.557260815835395E-4, -2.0804190062322664E-4, -5.057391100818653E-4,
         -3.452114767842334E-6, 1.0145936326270006E-4, 3.839214074518535E-4, 2.2061197469126577E-4,
         -1.5601580596677608E-4, -8.235017846415852E-4, -7.298316615408554E-4, -6.898459943652376E-5,
         4.724125688297753E-5, 88.73235686453587]

def norm_data(mean, data):
  data = tf.cast(data, tf.float32) * 1/(2*mean)
  return tf.reshape(data, [-1, 1])

numeric_columns = []

for i, feature in enumerate(FEATURES):
  num_col = tf.feature_column.numeric_column(feature, normalizer_fn=functools.partial(norm_data, MEANS[i]))
  numeric_columns.append(num_col)

numeric_columns

2. adım: Modeli oluşturun

Artık model oluşturmaya hazırız. Yeni oluşturduğumuz sütunları ağa aktaracağız. Ardından modeli derleyeceğiz. Dengesiz veri kümeleri için faydalı olan hassasiyet/geri çağırma AUC metriğini ekliyoruz.

model = keras.Sequential([
    tf.keras.layers.DenseFeatures(numeric_columns),
    layers.Dense(64, activation='relu'),
    layers.Dense(64, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy', tf.keras.metrics.AUC(curve='PR')])

3. adım: Modeli eğitin

Dengesiz verileri işlemek için çeşitli teknikler vardır. Bunlar arasında fazla örnekleme (azınlık sınıfında yeni veriler oluşturma) ve az örnekleme (çoğunluk sınıfındaki verileri azaltma) yer alır.

Bu codelab'in amaçları doğrultusunda, azınlık sınıfını yanlış sınıflandırırken kaybı fazla ağırlıklandıran bir teknik kullanalım. Eğitim sırasında bir class_weight parametresi belirleyeceğiz ve çok daha az yaygın olduğu için "1" (sahtekarlık) ağırlığını daha yüksek tutacağız.

Bu laboratuvarda eğitimi hızlandırmak için 3 dönem (verilerde geçiş) kullanacağız. Gerçek hayattaki bir senaryoda, doğrulama kümesinin doğruluğunda artış görülmeyene kadar bu işlemi yeterince uzun süre uygulamak isteriz.

CLASS_WEIGHT = {
    0: 1,
    1: 100
}
EPOCHS = 3

train_data = raw_train_data.shuffle(10000)
val_data = raw_val_data
test_data = raw_test_data

model.fit(train_data, validation_data=val_data, class_weight=CLASS_WEIGHT, epochs=EPOCHS)

4. adım: Modeli değerlendirin

evaluate() işlevi, tarafsız bir değerlendirme sağlamak için modelin daha önce hiç görmediği test verilerine uygulanabilir. Neyse ki bu amaçla kullanabileceğiniz test verileri hazırladık.

model.evaluate(test_data)

5. adım: Keşif

Bu laboratuvarda, BigQuery'deki büyük bir veri kümesinin doğrudan TensorFlow Keras modeline nasıl alınacağını gösterdik. Ayrıca, model oluşturmayla ilgili tüm adımları da ele aldık. Son olarak, dengesiz sınıflandırma sorunlarının nasıl ele alınacağı hakkında bilgi edindik.

Doğruluğu artırıp artıramayacağınızı görmek için dengesiz veri kümesiyle ilgili farklı mimariler ve yaklaşımlar denemeye devam edebilirsiniz.

6. 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.