TensorFlow İkili Sınıflandırma: Doğrusal Sınıflandırıcı Örneği

⚡ Akıllı Özet

Doğrusal sınıflandırıcılar, her gözlemi özelliklerinin ağırlıklı toplamından bir sınıfa atar. Bu kılavuz, nüfus sayımı veri kümesi üzerinde bir TensorFlow ikili sınıflandırıcı oluşturarak doğruluk oranını 0.76'dan 0.84'e yükseltmektedir.

  • 🔘 Temel tanım: Doğrusal sınıflandırıcı, özellik değerlerinin doğrusal bir kombinasyonundan ayrık bir sınıfı tahmin eder.
  • ☑️ Olasılık adımı: Lojistik fonksiyon, doğrusal model çıktısını 0 ile 1 arasında bir olasılığa dönüştürür.
  • ✅ Ölçümler önemlidir: Dengesiz etiketlerde doğruluk tek başına yanıltıcı olabilir, bu nedenle onu karışıklık matrisi, hassasiyet ve geri çağırma ile birlikte değerlendirin.
  • 🧪 Nüfus sayımı adım adım kılavuzu: Altı sürekli ve sekiz kategorik sütun, tahminleyici onları görmeden önce tensör haline gelir.
  • ️ Özellik mühendisliği: Yaşı karesini alıp, gruplandırıp, ardından eğitimi meslekle çaprazlamak, doğruluğu 0.7616'dan 0.8358'e yükseltiyor.
  • 📈 Düzenlileştirme: L1 değeri 0.9 ve L2 değeri 5 olan bir Ftrl optimizasyon algoritması, nihai doğruluğu 0.8383'e yükseltiyor.

TensorFlow İkili Sınıflandırma Doğrusal Sınıflandırıcı

En yaygın iki denetimli öğrenme Görevler doğrusal regresyon ve doğrusal sınıflandırıcıdır. Doğrusal regresyon bir değeri tahmin ederken, doğrusal sınıflandırıcı bir sınıfı tahmin eder. Bu eğitim Doğrusal Sınıflandırıcılara odaklanmıştır.

Doğrusal Sınıflandırıcı Nedir?

A Doğrusal Sınıflandırıcı Makine Öğreniminde istatistiksel sınıflandırma için özelliklerine göre bir nesnenin sınıfını bulmaya yönelik bir yöntemdir. Bir nesnenin özelliklerinin doğrusal birleşiminin değerine dayalı olarak sınıflandırma kararı verir. Doğrusal sınıflandırıcı, doküman sınıflandırma gibi pratik problemlerde ve çok değişkenli problemlerde kullanılır.

Sınıflandırma sorunları, makine öğrenimi görevinin kabaca yüzde 80'ini temsil eder. Sınıflandırma, bir dizi girdi verildiğinde her sınıfın olasılığını tahmin etmeyi amaçlar. Etiket (yani bağımlı değişken), sınıf adı verilen ayrı bir değerdir.

  1. Etiketin yalnızca iki sınıfı varsa öğrenme algoritması bir İkili Sınıflandırıcıdır.
  2. Çok sınıflı sınıflandırıcı, ikiden fazla sınıfa sahip etiketleri ele alır.

Örneğin, tipik bir ikili sınıflandırma problemi, bir müşterinin ikinci bir satın alma yapma olasılığını tahmin etmektir. İkiden fazla hayvan çeşidi mevcut olduğundan, resimde gösterilen hayvanın tipini tahmin etmek çok sınıflı bir sınıflandırma problemidir.

Bu eğitimin teorik kısmı öncelikli olarak ikili sınıfa odaklanmaktadır. Gelecekteki bir eğitimde çok sınıflı çıktı işlevi hakkında daha fazla bilgi edineceksiniz.

Tanım belirlendiğine göre, bir sonraki adım algoritmanın ham verileri nasıl bir sınıf kararına dönüştürdüğünü görmektir.

İkili sınıflandırıcı nasıl çalışır?

Önceki derste bir fonksiyonun iki tür değişkenden, bir bağımlı değişkenden ve bir dizi özellikten (bağımsız değişkenler) oluştuğunu öğrendiniz. Doğrusal regresyonda bağımlı değişken aralığı olmayan bir gerçek sayıdır. Temel amaç, ortalama karesel hatayı en aza indirerek değerini tahmin etmektir.

Her Ticaretçi İçin Mükemmellik TensorFlow İkili Sınıflandırıcıda, etiket iki olası tamsayı değerine sahip olabilir. Çoğu durumda, bu değerler [0,1] veya [1,2] aralığındadır. Örneğin, amaç bir müşterinin bir ürünü satın alıp almayacağını tahmin etmektir. Etiket şu şekilde tanımlanır:

  • Y = 1 (müşteri ürünü satın aldı)
  • Y = 0 (müşteri ürünü satın almaz)

Model, her müşteriyi ait olduğu en muhtemel sınıfta, yani potansiyel alıcı olup olmadığına göre sınıflandırmak için X özelliklerini kullanır.

Başarı olasılığı şu şekilde hesaplanır: lojistik regresyon. Algoritma, X özelliğine göre bir olasılık hesaplayacak ve bu olasılığın yüzde 50'nin üzerinde olması durumunda başarıyı tahmin edecek. Daha resmi olarak olasılık, aşağıdaki TensorFlow İkili Sınıflandırma örneğinde gösterildiği gibi hesaplanır:

TensorFlow ikili sınıflandırıcısı tarafından kullanılan sigmoid olasılık formülü

burada 0 ağırlıklar kümesi, özellikler ve b önyargıdır.

Fonksiyon iki kısma ayrılabilir:

  • Doğrusal model
  • Lojistik fonksiyon

Doğrusal model

Ağırlıkların nasıl hesaplandığına zaten aşinasınız. Ağırlıklar nokta çarpımı kullanılarak hesaplanır:Ağırlık vektörü ile özellik vektörünün nokta çarpımı Y, x'in tüm özelliklerinin doğrusal bir fonksiyonuduri. Modelin özellikleri yoksa tahmin yanlılığa eşittir, b.

Ağırlıklar x özellikleri arasındaki korelasyonun yönünü gösterir.i ve y etiketi. Pozitif bir korelasyon pozitif sınıfın olasılığını arttırırken, negatif bir korelasyon olasılığı 0'a (yani negatif sınıfa) yaklaştırır.

Doğrusal model yalnızca gerçek sayıyı döndürür; bu da [0,1] aralığının olasılık ölçüsüyle tutarsızdır. Doğrusal model çıktısını olasılığa dönüştürmek için lojistik fonksiyon gereklidir,

Lojistik fonksiyon

Lojistik fonksiyon veya sigmoid fonksiyon S şeklindedir ve bu fonksiyonun çıktısı her zaman 0 ile 1 arasındadır.

Aşağıdaki formül dönüşümü belirtir ve ardından gelen grafik, sonuçta oluşan eğrinin solda 0'a, sağda ise 1'e doğru düzleştiğini göstermektedir.

Doğrusal bir skoru olasılığa dönüştüren lojistik fonksiyon formülü.

0 ile 1 arasında sınırlandırılmış S şeklinde sigmoid eğrisi
Lojistik Fonksiyon örneği

Doğrusal regresyonun çıktısını sigmoid fonksiyonuna koymak kolaydır. Olasılığı 0 ile 1 arasında olan yeni bir sayıyla sonuçlanır.

Sınıflandırıcı olasılığı bir sınıfa dönüştürebilir

  • 0 ila 0.49 arasındaki değerler sınıf 0 olur
  • 0.5 ila 1 arasındaki değerler sınıf 1 olur

Model sınıflar ürettikten sonra, bu sınıfların işe yarayıp yaramadığını değerlendirmenin bir yoluna ihtiyacınız vardır.

Doğrusal Sınıflandırıcının Performansı Nasıl Ölçülür?

doğruluk

Bir sınıflandırıcının genel performansı doğruluk ölçütüyle ölçülür. Doğruluk, tüm doğru değerlerin toplam gözlem sayısına bölünmesiyle elde edilir. Örneğin yüzde 80'lik bir doğruluk değeri, modelin vakaların yüzde 80'inde doğru olduğu anlamına gelir.

Doğruluk formülü, toplam gözlem sayısına göre doğru tahminlerin sayısını hesaplar.

Doğruluk metriğini kullanarak Doğrusal Sınıflandırıcının performansını ölçün

Bu metrikte, özellikle dengesizlik sınıfı için bir eksikliğe dikkat çekebilirsiniz. Grup başına gözlem sayısı eşit olmadığında bir dengesizlik veri kümesi oluşur. Diyelim ki; nadir bir olayı lojistik bir fonksiyonla sınıflandırmaya çalışıyorsunuz. Sınıflandırıcının bir hastalığı takiben bir hastanın ölümünü tahmin etmeye çalıştığını düşünün. Verilerde hastaların yüzde 5'i ölüyor. Bir sınıflandırıcıyı ölüm sayısını tahmin etmesi için eğitebilir ve performansları değerlendirmek için doğruluk metriğini kullanabilirsiniz. Sınıflandırıcı tüm veri kümesi için 0 ölüm tahmin ederse, vakaların yüzde 95'inde doğru olacaktır.

Karışıklık matrisi

Bir sınıflandırıcının performansını değerlendirmenin daha iyi bir yolu karışıklık matrisine bakmaktır.

Doğru (TP), yanlış (FP), yanlış negatif (FN) ve doğru negatif (TN) karelerini gösteren ikili karışıklık matrisi.

Karışıklık matrisini kullanarak Doğrusal Sınıflandırıcının performansını ölçün

MKS karışıklık matrisi Yukarıdaki Doğrusal Sınıflandırıcı örneğinde gösterildiği gibi gerçek ve tahmin edilen sınıfları karşılaştırarak bir sınıflandırıcının doğruluğunu görselleştirir. İkili karışıklık matrisi karelerden oluşur:

  • TP: Gerçek Pozitif: Gerçek pozitif olarak doğru tahmin edilen tahmin edilen değerler
  • FP: Tahmin edilen değerler gerçek pozitifi yanlış tahmin etti. yani, pozitif olarak tahmin edilen negatif değerler
  • FN: Yanlış Negatif: Negatif olarak tahmin edilen pozitif değerler
  • TN: Gerçek Negatif: Tahmin edilen değerler gerçek negatif olarak doğru bir şekilde tahmin edildi

Karışıklık matrisinden gerçek sınıf ile tahmin edilen sınıfı karşılaştırmak kolaydır.

Hassasiyet ve Hassasiyet

Karışıklık matrisi, gerçek pozitif ve yanlış pozitif hakkında iyi bir fikir sağlar. Bazı durumlarda daha kısa bir metriğin kullanılması tercih edilir.

Hassas

Hassasiyet metriği pozitif sınıfın doğruluğunu gösterir. Pozitif sınıfın tahmininin ne kadar doğru olduğunu ölçer.

Hassasiyet formülü, gerçek pozitiflerin tahmin edilen pozitiflere oranı

Sınıflandırıcı tüm pozitif değerleri mükemmel şekilde sınıflandırdığında maksimum puan 1'dir. Kesinlik tek başına pek yararlı değildir çünkü negatif sınıfı göz ardı eder. Metrik genellikle Geri Çağırma metriği ile eşleştirilir. Geri çağırmaya duyarlılık veya gerçek pozitif oran da denir.

Duyarlılık

Hassasiyet, doğru olarak tespit edilen pozitif sınıfların oranını hesaplar. Bu ölçüm, modelin pozitif bir sınıfı tanımada ne kadar iyi olduğunu verir.

Duyarlılık formülü, gerçek pozitifler / fiili pozitifler

Teori artık yerli yerinde, bu nedenle bu kılavuzun geri kalanında teoriyi baştan sona kodda uygulayacağız.

TensorFlow ile Doğrusal Sınıflandırıcı

Bu eğitim için nüfus sayımı veri kümesini kullanacağız. Amaç, nüfus sayımı veri setindeki değişkenleri kullanarak gelir düzeyini tahmin etmektir. Gelirin ikili bir değişken olduğunu unutmayın

  • gelir > 1 bin ise 50 değeriyle
  • Gelir < 0 bin ise 50.

Bu değişken sizin etiketinizdir

Bu veri kümesi sekiz kategorik değişken içerir:

  • işyeri
  • eğitim
  • evlilik
  • işgal
  • ilişki
  • yarış
  • seks
  • ana vatan

ayrıca altı sürekli değişken:

  • yaş
  • fnlwgt
  • eğitim_num
  • Sermaye kazancı
  • sermaye_kaybı
  • saat_hafta

Bu TensorFlow Sınıflandırma örneği aracılığıyla, doğrusal TensorFlow Sınıflandırıcılarının TensorFlow tahmincisi ile nasıl eğitileceğini ve doğruluk ölçüsünün nasıl geliştirileceğini anlayacaksınız.

Sürüm notu: Aşağıdaki kod, TensorFlow 1.x Estimator API'sini kullanmaktadır. tf-estimator Bu paket, TensorFlow 2.15 ile birlikte son sürümünü yayınladı ve TensorFlow 2.16 veya sonraki sürümlerinde mevcut değil; bu nedenle bu kod parçacıklarını TensorFlow 1.x üzerinde çalıştırın veya resmi paketle taşıyın. hazır tahminleyici geçiş kılavuzuKavramlar, özellik mühendisliği ve ölçütler aynı kalıyor.

Aşağıdaki gibi ilerleyeceğiz:

  • Adım 1) Verileri içe aktarın
  • Adım 2) Veri Dönüştürme
  • Adım 3) Sınıflandırıcıyı eğitin
  • Adım 4) Modeli geliştirin
  • Adım 5) Hiperparametre: Kement ve Sırt

Adım 1) Verileri içe aktarın

Öncelikle eğitim sırasında kullanılan kitaplıkları içe aktarırsınız.

import tensorflow as tf
import pandas as pd

Sonra, UCI arşivinden verileri içe aktarırsınız ve sütun adlarını tanımlarsınız. Pandas veri çerçevesindeki sütunları adlandırmak için COLUMNS'u kullanacaksınız.

Sınıflandırıcıyı bir Pandas veri çerçevesi kullanarak eğiteceğinizi unutmayın.

## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

Çevrimiçi olarak depolanan veriler zaten bir tren seti ve test seti arasında bölünmüş durumda.

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

Tren seti 32,561 gözlem ve test seti 16,281 gözlem içeriyor

print(df_train.shape, df_test.shape)
print(df_train.dtypes)
(32561, 15) (16281, 15)
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label             object
dtype: object

TensorFlow, sınıflandırıcıyı eğitmek için Boolean bir değere ihtiyaç duyar. Değerleri string'den integer'a dönüştürmeniz gerekir. Etiket bir nesne olarak saklanır, ancak onu sayısal bir değere dönüştürmeniz gerekir. Aşağıdaki kod, dönüştürülecek değerlerle bir sözlük oluşturur ve sütun öğesi üzerinde döngü yapar. Bu işlemi iki kez gerçekleştirdiğinizi unutmayın: biri eğitim seti için, diğeri test seti için.

label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]

Eğitim verilerinde, 50.000 doların altında gelire sahip 24,720 kişi ve 50.000 doların üzerinde gelire sahip 7841 kişi bulunmaktadır. Test veri seti için de oran neredeyse aynıdır, bu nedenle her iki dağılımın yaklaşık %76'sı negatif gelir grubuna aittir.

print(df_train["label"].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test["label"].value_counts())
## Unbalanced label
print(df_train.dtypes)
0    24720
1     7841
Name: label, dtype: int64
0    12435
1     3846
Name: label, dtype: int64
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label              int64
dtype: object

Adım 2) Veri Dönüştürme

TensorFlow ile doğrusal bir sınıflandırıcı eğitmeden önce birkaç adım gereklidir. Modele dahil edilecek özellikleri hazırlamanız gerekir. Karşılaştırmalı regresyonda, herhangi bir dönüşüm uygulamadan, tam olarak olduğu gibi orijinal verileri kullanacaksınız. scikit-öğrenme İşlem hattı ham sütunlardan başlayacaktır.

Tahmincinin modeli eğitmek için bir özellikler listesine sahip olması gerekir. Bu nedenle sütundaki verilerin tensöre dönüştürülmesi gerekir.

İyi bir uygulama, türlerine göre iki özellik listesi tanımlamak ve ardından bunları tahmincinin özellik_sütunlarına iletmektir.

Sürekli özellikleri dönüştürerek başlayacak, ardından kategorik verilerle bir grup tanımlayacaksınız.

Veri kümesinin özellikleri iki formata sahiptir:

  • Tamsayı
  • nesne

Her özellik, türlerine göre sonraki iki değişkende listelenmiştir.

## Add features to the bucket: 
### Define continuous list
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
### Define the categorical list
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

feature_column, sürekli değişkenlerin tensöre dönüştürülmesine yardımcı olmak için bir numeric_column nesnesiyle donatılmıştır. Aşağıdaki kodda, CONTI_FEATURES değişkenindeki tüm değişkenleri sayısal değere sahip bir tensöre dönüştürürsünüz. Bu, modeli oluşturmak için zorunludur. Tüm bağımsız değişkenlerin uygun tensör tipine dönüştürülmesi gerekir.

Aşağıda feature_column.numeric_column'un arkasında neler olduğunu görmenizi sağlayacak bir kod yazıyoruz. Yaşa göre dönüştürülen değeri yazdıracağız. Açıklama amaçlıdır, dolayısıyla anlaşılmasına gerek yoktur. Python kod. Kodları anlamak için resmi belgelere başvurabilirsiniz.

def print_transformation(feature = "age", continuous = True, size = 2): 
    #X = fc.numeric_column(feature)
    ## Create feature name
    feature_names = [
    feature]

    ## Create dict with the data
    d = dict(zip(feature_names, [df_train[feature]]))

    ## Convert age
    if continuous == True:
        c = tf.feature_column.numeric_column(feature)
        feature_columns = [c]
    else: 
        c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size) 
        c_indicator = tf.feature_column.indicator_column(c)
        feature_columns = [c_indicator]
    
## Use input_layer to print the value
    input_layer = tf.feature_column.input_layer(
        features=d,
        feature_columns=feature_columns
        )
    ## Create lookup table
    zero = tf.constant(0, dtype=tf.float32)
    where = tf.not_equal(input_layer, zero)
    ## Return lookup tble
    indices = tf.where(where)
    values = tf.gather_nd(input_layer, indices)
    ## Initiate graph
    sess = tf.Session()
    ## Print value
    print(sess.run(input_layer))
print_transformation(feature = "age", continuous = True) 
[[39.]
 [50.]
 [38.]
 ...
 [58.]
 [22.]
 [52.]]

Değerler df_train'deki ile tamamen aynıdır

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]

TensorFlow belgelerine göre kategorik verileri dönüştürmenin farklı yolları vardır. Bir özelliğin kelime listesi biliniyorsa ve çok fazla değeri yoksa kategorik_column_with_vocabulary_list ile kategorik sütunu oluşturmak mümkündür. Tüm benzersiz kelime listesine bir kimlik atayacaktır.

Örneğin, bir değişkenin durumu üç farklı değere sahipse:

  • Koca
  • Kadın eş
  • Tek

Daha sonra üç kimlik atfedilecektir. Örneğin, Kocanın ID 1'i, Karı'nın ID'si 2 vb. olacaktır.

Gösterim amacıyla, bir nesne değişkenini TensorFlow'da kategorik bir sütuna dönüştürmek için bu kodu kullanabilirsiniz.

Cinsiyet özelliği yalnızca iki değer alabilir: erkek veya kadın. Cinsiyet özelliğini dönüştürdüğümüzde, TensorFlow erkek ve kadın için iki yeni sütun oluşturacaktır. Cinsiyet erkek ise, yeni erkek sütunu 1, kadın sütunu ise 0 olacaktır. Bu örnek aşağıdaki tabloda gösterilmiştir:

satır seks dönüşümden sonra erkek kadın
1 erkek => 1 0
2 erkek => 1 0
3 kadın => 0 1

Tensor akışında:

print_transformation(feature = "sex", continuous = False, size = 2)
[[1. 0.]
 [1. 0.]
 [1. 0.]
 ...
 [0. 1.]
 [1. 0.]
 [0. 1.]]

relationship = tf.feature_column.categorical_column_with_vocabulary_list(
    'relationship', [
        'Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried',
        'Other-relative'])

Aşağıda ekledik Python Kodlamayı yazdırmak için kod. Tekrar ediyorum, kodu anlamanıza gerek yok, amaç dönüşümü görmek

Ancak, verileri dönüştürmenin daha hızlı bir yolu, `categorical_column_with_hash_bucket` yöntemini kullanmaktır. Seyrek bir matristeki dize değişkenlerini değiştirmek faydalı olacaktır. Seyrek matris, çoğunlukla sıfırlardan oluşan bir matristir. Bu yöntem her şeyi halleder. Sadece kova sayısını ve anahtar sütunu belirtmeniz gerekir. Kova sayısı, TensorFlow'un oluşturabileceği maksimum grup sayısıdır. Anahtar sütun ise dönüştürülecek sütunun adıdır.

Aşağıdaki kodda tüm kategorik özellikler üzerinde bir döngü oluşturacaksınız.

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

Adım 3) Sınıflandırıcıyı Eğitin

TensorFlow şu anda doğrusal regresyon ve doğrusal sınıflandırma için bir tahmin aracı sunmaktadır.

  • Doğrusal regresyon: DoğrusalRegresör
  • Doğrusal sınıflandırma: Doğrusal Sınıflandırıcı

Doğrusal sınıflandırıcının sözdizimi öğreticideki ile aynıdır. doğrusal regresyon tek bir argüman dışında, n_class. Özellik sütununu, model dizinini tanımlamanız ve doğrusal regresörle karşılaştırmanız gerekir; sınıf sayısını tanımladınız. Logit regresyonda sınıf sayısı 2'ye eşittir.

Model, sürekli_özellikler ve kategorik_özelliklerde bulunan sütunların ağırlıklarını hesaplayacaktır.

model = tf.estimator.LinearClassifier(
    n_classes = 2,
    model_dir="ongoing/train", 
    feature_columns=categorical_features+ continuous_features)

Çıktı

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x181f24c898>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Artık sınıflandırıcı tanımlandığına göre giriş fonksiyonunu oluşturabilirsiniz. Yöntem, doğrusal regresör eğitimindekiyle aynıdır. Burada 128'lik bir parti boyutu kullanırsınız ve verileri karıştırırsınız.

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']
LABEL= 'label'
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Doğrusal tahmincinin gerektirdiği argümanlarla (yani dönem sayısı, grup sayısı) bir işlev oluşturur ve veri kümesini veya notu karıştırırsınız. kullandığınızdan beri Pandalar Verileri modele aktarma yöntemini kullanmak için X değişkenlerini pandaların veri çerçevesi olarak tanımlamanız gerekir. ÖZELLİKLER'de saklanan tüm veriler üzerinde döngü yaptığınızı unutmayın.

Modeli model.train nesnesi ile eğitelim. Modeli uygun değerlerle beslemek için daha önce tanımlanan işlevi kullanırsınız. Toplu iş boyutunu 128'e ve dönem sayısını Yok olarak ayarladığınızı unutmayın. Model bin adımın üzerinde eğitilecek.

model.train(input_fn=get_input_fn(df_train, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									 
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow: Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.
INFO:tensorflow:Loss for final step: 5444.363.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

Son 100 adımda kaybın daha sonra azaldığını, yani 901'den 1000'e düştüğünü unutmayın.

Bin tekrardan sonraki nihai kayıp 5444'tür. Modelinizi test seti üzerinde tahmin edebilir ve performansını görebilirsiniz. Modelinizin performansını değerlendirmek için nesne değerlendirmesini kullanmanız gerekir. Modeli test seti ile besliyorsunuz ve dönem sayısını 1 olarak ayarlıyorsunuz, yani veriler modele yalnızca bir kez gidecek.

model.evaluate(input_fn=get_input_fn(df_test, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546

{'accuracy': 0.7615626,
 'accuracy_baseline': 0.76377374,
 'auc': 0.63300294,
 'auc_precision_recall': 0.50891197,
 'average_loss': 47.12155,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 5993.6406,
 'precision': 0.49401596,
 'prediction/mean': 0.18454961,
 'recall': 0.38637546}

TensorFlow teorik kısımda öğrendiğiniz tüm ölçümleri döndürür. Dengesiz etiket nedeniyle doğruluğun büyük olması şaşırtıcı değil. Aslında model rastgele bir tahminden biraz daha iyi performans gösteriyor. Modelin geliri 50 binin altında olan tüm haneleri tahmin ettiğini düşünün, o zaman modelin doğruluğu yüzde 70'tir. Daha yakından incelendiğinde tahminin ve hatırlanmanın oldukça düşük olduğunu görebilirsiniz.

Adım 4) Modeli geliştirin

Artık bir kıyaslama modeliniz olduğuna göre onu iyileştirmeyi, yani doğruluğunu artırmayı deneyebilirsiniz. Önceki derste, bir etkileşim terimiyle tahmin gücünü nasıl geliştireceğinizi öğrendiniz. Bu derste regresyona bir polinom terimi ekleyerek bu fikri tekrar ele alacaksınız.

Verilerde doğrusallık olmadığında polinom regresyonu etkilidir. Verilerdeki doğrusal olmayışı yakalamanın iki yolu vardır.

  • Polinom terimi ekle
  • Sürekli değişkeni kategorik bir değişkene ayırın

Polinom terimi

Aşağıdaki resimden polinom regresyonunun ne olduğunu görebilirsiniz. Farklı güce sahip X değişkenleri içeren bir denklemdir. İkinci derece bir polinom regresyonunun iki değişkeni vardır: X ve X'in karesi. Üçüncü derecenin üç değişkeni vardır: X, X2ve X3

İkinci ve üçüncü dereceden polinom regresyon denklemleri

Polinom Regresyon Nedir?

Yukarıdaki grafik, ikinci dereceden bir eğriyi temel denklemine karşı çizmektedir. Aşağıda, X ve Y olmak üzere iki değişkenle bir grafik oluşturduk. İlişkinin doğrusal olmadığı açıktır. Doğrusal bir regresyon eklersek, modelin bu örüntüyü yakalayamadığını görebiliriz (sol resim).

Şimdi aşağıdaki resimden soldaki resme bakın, regresyona beş terim ekledik (yani y=x+x)2+x3+x4+x5. Model artık modeli çok daha iyi yakalıyor. Bu polinom regresyonun gücüdür.

Aynı dağılım grafiğinde doğrusal uyum ile beş terimli polinom uyumunun karşılaştırılması

Örneğimize geri dönelim. Yaş ile gelir arasında doğrusal bir ilişki yoktur. Çocukların ve gençlerin çalışmaması nedeniyle erken yaşlarda sıfıra yakın sabit bir gelir söz konusu olabilir. Daha sonra çalışma çağında artar, emeklilik döneminde azalır. Tipik olarak Ters U şeklidir. Bu modeli yakalamanın bir yolu regresyona iki kuvvet eklemektir.

Bakalım doğruluk artacak mı?

Bu yeni özelliği veri setine ve sürekli özellik listesine eklemeniz gerekiyor.

Yeni değişkeni eğitim ve test veri kümesine eklersiniz, böylece bir fonksiyon yazmak daha uygundur.

def square_var(df_t, df_te, var_name = 'age'):
    df_t['new'] = df_t[var_name].pow(2) 
    df_te['new'] = df_te[var_name].pow(2) 
    return df_t, df_te

Fonksiyonun 3 argümanı vardır:

  • df_t: eğitim setini tanımlayın
  • df_te: test setini tanımlayın
  • var_name = 'age': Dönüştürülecek değişkeni tanımlayın

Yaş değişkeninin karesini almak için pow(2) nesnesini kullanabilirsiniz. Yeni değişkenin adının 'yeni' olduğunu unutmayın

Artık square_var işlevi yazıldığına göre yeni veri kümelerini oluşturabilirsiniz.

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')

Gördüğünüz gibi yeni veri kümesinin bir özelliği daha var.

print(df_train_new.shape, df_test_new.shape)			
(32561, 16) (16281, 16)

Kare değişkeni veri kümesinde yeni olarak adlandırılır. Sürekli özellikler listesine eklemeniz gerekir.

CONTI_FEATURES_NEW  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

not Grafiğin dizinini değiştirdiğinizi. Aynı dizinde farklı modelleri eğitemezsiniz. Bu, model_dir argümanının yolunu değiştirmeniz gerektiği anlamına gelir. Bunu yapmazsanız TensorFlow bir hata verecektir.

model_1 = tf.estimator.LinearClassifier(
    model_dir="ongoing/train1", 
    feature_columns=categorical_features+ continuous_features_new)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x1820f04b70>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES_NEW}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Artık sınıflandırıcı yeni veri kümesiyle tasarlandığı için modeli eğitebilir ve değerlendirebilirsiniz.

model_1.train(input_fn=get_input_fn(df_train, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train1/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.
INFO:tensorflow:Loss for final step: 28861.898.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>
model_1.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703

{'accuracy': 0.7944229,
 'accuracy_baseline': 0.76377374,
 'auc': 0.6093755,
 'auc_precision_recall': 0.54885805,
 'average_loss': 111.0046,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 14119.265,
 'precision': 0.6682401,
 'prediction/mean': 0.09116262,
 'recall': 0.2576703}

Kare değişkeni doğruluğu 0.76'dan 0.79'a çıkardı. Bakalım gruplandırma ve etkileşim terimini birleştirerek daha iyisini yapıp yapamayacağınızı görelim.

Paketleme ve etkileşim

Daha önce de gördüğünüz gibi doğrusal bir sınıflandırıcı yaş-gelir modelini doğru bir şekilde yakalayamamaktadır. Bunun nedeni her özellik için tek bir ağırlık öğrenmesidir. Sınıflandırıcının işini kolaylaştırmak için yapabileceğiniz şeylerden biri özelliği gruplandırmaktır. Gruplandırma, sayısal bir özelliği, içine düştüğü aralığa göre birkaç belirli özelliğe dönüştürür ve bu yeni özelliklerin her biri, bir kişinin yaşının bu aralığa girip girmediğini gösterir.

Bu yeni özellikler sayesinde doğrusal model, her bir paket için farklı ağırlıkları öğrenerek ilişkiyi yakalayabilir.

TensorFlow'da bu, budgetized_column ile yapılır. Değer aralığını sınırlara eklemeniz gerekir.

age = tf.feature_column.numeric_column('age')
age_buckets = tf.feature_column.bucketized_column(
    age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

Yaşın gelirle doğrusal olmadığını zaten biliyorsunuz. Modeli geliştirmenin bir başka yolu da etkileşimdir. TensorFlow'un tabiriyle özellik geçişidir. Özellik geçişi, özellikler arasındaki etkileşimleri modelleyemeyen doğrusal bir sınıflandırıcı için yararlı olabilecek, mevcut özelliklerin birleşimi olan yeni özellikler oluşturmanın bir yoludur.

Eğitim gibi başka bir özellik ile yaşı kırabilirsiniz. Yani, bazı grupların geliri muhtemelen yüksek, diğerlerinin ise düşüktür (Doktora öğrencisini düşünün).

education_x_occupation = [tf.feature_column.crossed_column(
    ['education', 'occupation'], hash_bucket_size=1000)]
age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column(
    [age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

Bir çapraz özellik sütunu oluşturmak için çapraz_column'u parantez içinde çaprazlanacak değişkenlerle birlikte kullanırsınız. Hash_bucket_size maksimum geçiş olasılığını gösterir. Değişkenler arasında etkileşim oluşturmak için (en az bir değişkenin kategorik olması gerekir), tf.feature_column.crossed_column'u kullanabilirsiniz. Bu nesneyi kullanmak için, etkileşime girecek değişkeni ve ikinci bir argüman olan kova boyutunu köşeli parantez içine eklemeniz gerekir. Paket boyutu, bir değişken içinde mümkün olan maksimum grup sayısıdır. Grupların tam sayısını bilmediğiniz için burada 1000 olarak ayarlıyorsunuz.

özellik sütunlarına eklenmeden önce age_buckets'in karesinin alınması gerekir. Ayrıca yeni özellikleri özellikler sütunlarına ekleyip tahminciyi hazırlarsınız.

base_columns = [
    age_buckets,
]

model_imp = tf.estimator.LinearClassifier(
    model_dir="ongoing/train3", 
    feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

Çıktı

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1823021be0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital',
                'occupation', 'relationship', 'race', 'sex', 'native_country', 'new']

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES_imp}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Yeni modeli tahmin etmeye ve doğruluğu arttırıp artırmadığını görmeye hazırsınız.

model_imp.train(input_fn=get_input_fn(df_train_new, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									  
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train3/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.
INFO:tensorflow:Loss for final step: 44.18133.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>
model_imp.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216


{'accuracy': 0.8358209,
 'accuracy_baseline': 0.76377374,
 'auc': 0.88401634,
 'auc_precision_recall': 0.69599575,
 'average_loss': 0.35122654,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.67437,
 'precision': 0.68986726,
 'prediction/mean': 0.23320661,
 'recall': 0.55408216}

Yeni doğruluk düzeyi yüzde 83.58'dir. Önceki modele göre yüzde dört daha yüksek.

Son olarak, aşırı uyumu önlemek için bir düzenleme terimi ekleyebilirsiniz.

Adım 5) Hiperparametre: Kement ve Sırt

Modeliniz zarar görebilir aşırı oturma or yetersiz uyan.

  • Aşırı uyum: Model, tahmini yeni verilere genelleyemiyor
  • Yetersiz Uyum: Model, veri modelini yakalayamıyor. yani veriler doğrusal olmadığında doğrusal regresyon

Bir modelin çok fazla parametresi ve nispeten düşük miktarda verisi varsa, bu durum kötü tahminlere yol açar. Bir grubun yalnızca üç gözlemi olduğunu hayal edin; model bu grup için bir ağırlık hesaplayacaktır. Ağırlık bir tahminde bulunmak için kullanılır; eğer bu belirli grup için test setinin gözlemleri eğitim setinden tamamen farklıysa, o zaman model yanlış bir tahminde bulunacaktır. Eğitim seti ile değerlendirme sırasında doğruluk iyidir, ancak test seti için iyi değildir çünkü hesaplanan ağırlıklar modeli genelleştirmek için doğru değildir. Bu durumda görünmeyen veriler üzerinden makul bir tahminde bulunmaz.

Aşırı uyumu önlemek için, düzenleme size bu tür karmaşıklığı kontrol etme ve daha genelleştirilebilir hale getirme olanağı verir. İki düzenleme tekniği vardır:

  • L1: Kement
  • L2: Sırt

TensorFlow'da bu iki hiper parametreyi optimize ediciye ekleyebilirsiniz. Örneğin, L2 hiperparametresi ne kadar yüksek olursa, ağırlık da çok düşük ve sıfıra yakın olma eğilimindedir. Takılan çizgi çok düz olacaktır, sıfıra yakın bir L2 ise ağırlıkların düzenli doğrusal regresyona yakın olduğu anlamına gelir.

Hiperparametrelerin farklı değerlerini kendiniz deneyebilir ve doğruluk düzeyini artırıp artıramayacağınızı görebilirsiniz.

not Eğer hiperparametreyi değiştirirseniz, ongoing/train4 klasörünü silmeniz gerekir, aksi takdirde model daha önce eğitilen modelle başlayacaktır.

Bakalım yutturmacanın doğruluğu nasıl

model_regu = tf.estimator.LinearClassifier(
    model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,
    optimizer=tf.train.FtrlOptimizer(
        learning_rate=0.1,
        l1_regularization_strength=0.9,
        l2_regularization_strength=5))

Çıktı

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820d9c128>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
model_regu.train(input_fn=get_input_fn(df_train_new, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

Çıktı

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train4/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.
INFO:tensorflow:Loss for final step: 43.4942.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>
model_regu.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

Çıktı

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823





{'accuracy': 0.83833915,
 'accuracy_baseline': 0.76377374,
 'auc': 0.8869794,
 'auc_precision_recall': 0.7014905,
 'average_loss': 0.34691378,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.12581,
 'precision': 0.69720596,
 'prediction/mean': 0.23662092,
 'recall': 0.5579823}

Bu hiperparametre ile doğruluk metriklerini biraz artırırsınız. Aşağıdaki tabloda, bu eğitimdeki dört değerlendirme çağrısı tarafından bildirilen tüm metrikler toplanmıştır.

Model Özellik seti doğruluk AUC Hassas Geri çağırmak
model Temel sürekli + kategorik 0.7615626 0.63300294 0.49401596 0.38637546
model_1 Temel değer artı yaşın karesi 0.7944229 0.6093755 0.6682401 0.2576703
model_imp Gruplandırılmış yaş artı çapraz sütunlar 0.8358209 0.88401634 0.68986726 0.55408216
model_regu Çapraz sütunlar artı L1 ve L2 0.83833915 0.8869794 0.69720596 0.5579823

Çoğunluk sınıfını her zaman tahmin eden bir modelin temel doğruluk oranının 0.76377374 olduğunu unutmayın; bu nedenle yalnızca son iki model, önemsiz bir tahmini faydalı bir farkla geride bırakmıştır.

Sonraki eğitimde, doğrusal bir sınıflandırıcıyı nasıl geliştireceğinizi öğreneceksiniz. çekirdek yöntemi.

SSS

Lojistik regresyon, doğrusal sınıflandırıcıların bir türüdür. Doğrusal bir puanlama yapar, ardından kalibre edilmiş olasılıkları döndürmek için bunu bir sigmoid fonksiyonundan geçirir. Doğrusal SVM veya algılayıcı gibi diğer doğrusal sınıflandırıcılar, doğrusal sınırı paylaşır ancak farklı bir kayıp fonksiyonunu optimize eder.

Doğrusal bir SVM, menteşe kaybını optimize eder ve yalnızca marj noktaları sınırı etkiler; bu da küçük ve gürültülü veri kümelerinde faydalıdır. Lojistik regresyon, çok büyük verilerde daha hızlı eğitilir ve ayarlanabilir bir karar eşiğine ihtiyaç duyduğunuzda önemli olan olasılık tahminleri döndürür.

Hayır. tf-estimator paketi son sürümünü TensorFlow 2.15 ile birlikte yayınladı ve TensorFlow 2.16 ve sonrasında yer almıyor. Bu eğitimi TensorFlow 1.x üzerinde çalıştırın veya resmi geçiş kılavuzunu kullanarak hazır tahminleyiciyi bir Keras doğrusal modeline taşıyın.

Otomatik arama kütüphaneleri, L1, L2, öğrenme oranı ve kova sınırlarını bir arama alanı olarak ele alır ve ardından zayıf denemeleri erken aşamada elemek için Bayes optimizasyonu veya çok kollu bandit yöntemlerini kullanır. Bu, bu eğitimde önerilen manuel taramanın yerini alır ve genellikle daha iyi bir düzenleme çifti bulur.

Copilot, sürekli sütunlar ve çapraz sütun blokları üzerindeki liste anlama ifadeleri de dahil olmak üzere, tekrarlayan feature_column şablonlarını hızla taslak haline getirir. Çıktıyı ilk taslak olarak değerlendirin; Copilot, TensorFlow 1.x ve 2.x yöntemlerini bir arada kullandığı için, her API adını çalıştırdığınız sürümle karşılaştırarak doğrulayın.

Bu parametre, kategorik bir sütunun karma işlemine tabi tutulacağı kova sayısını belirler. Çok küçük bir değer, ilgisiz kategorilerin çakışmasına ve aynı ağırlığı paylaşmasına neden olur; çok büyük bir değer ise bellek israfına yol açar. Bu değeri, bu eğitimde olduğu gibi 1000 ile, farklı değer sayısının oldukça üzerinde ayarlayın.

Karesel terimi eklemek, modeli çoğunluk sınıfını daha güvenle tahmin etmeye doğru kaydırır. Hassasiyet 0.6682'ye yükselirken, geri çağırma 0.2577'ye düşer; bu, kodlama hatasından ziyade dengesiz bir etiket durumunda görülen olağan hassasiyet-geri çağırma dengesidir.

Gruplandırma ve özellik geçişinden sonra bile sınıfları ayıran doğrusal bir sınır olmadığında çekirdek fonksiyonu kullanın. Çekirdek fonksiyonları, verileri daha yüksek boyutlu bir alana örtük olarak eşler; ancak bu, burada gösterilen doğrusal ağırlıklara kıyasla daha yavaş eğitim ve daha zayıf yorumlanabilirlik pahasına gerçekleşir.

Bu yazıyı şu şekilde özetleyin: