Klasifikasi Biner TensorFlow: Contoh Pengklasifikasi Linier
Evelyn Clarke
⚡ Ringkasan Cerdas
Pengklasifikasi linier menetapkan setiap observasi ke suatu kelas berdasarkan jumlah tertimbang dari fitur-fiturnya. Panduan ini membangun pengklasifikasi biner TensorFlow pada dataset sensus dan meningkatkan akurasi dari 0.76 menjadi 0.84.
Dua yang paling umum pembelajaran yang diawasi tugasnya adalah regresi linier dan pengklasifikasi linier. Regresi linier memprediksi suatu nilai sedangkan pengklasifikasi linier memprediksi suatu kelas. Tutorial ini difokuskan pada Pengklasifikasi Linier.
Apa itu Pengklasifikasi Linier?
A Pengklasifikasi Linier dalam Machine Learning adalah metode untuk menemukan kelas suatu objek berdasarkan karakteristiknya untuk klasifikasi statistik. Itu membuat keputusan klasifikasi berdasarkan nilai kombinasi linier karakteristik suatu objek. Pengklasifikasi linier digunakan dalam masalah praktis seperti klasifikasi dokumen dan masalah yang memiliki banyak variabel.
Masalah klasifikasi mewakili sekitar 80 persen tugas pembelajaran mesin. Klasifikasi bertujuan untuk memprediksi probabilitas setiap kelas berdasarkan sekumpulan masukan. Label (yaitu variabel terikat) adalah nilai tersendiri yang disebut kelas.
- Jika label hanya memiliki dua kelas, algoritma pembelajarannya adalah Binary Classifier.
- Pengklasifikasi multikelas menangani label dengan lebih dari dua kelas.
Misalnya, masalah klasifikasi biner yang umum adalah memprediksi kemungkinan pelanggan melakukan pembelian kedua. Memprediksi jenis hewan yang ditampilkan pada suatu gambar merupakan masalah klasifikasi multikelas karena terdapat lebih dari dua jenis hewan.
Bagian teoretis dari tutorial ini menempatkan fokus utama pada kelas biner. Anda akan mempelajari lebih lanjut tentang fungsi keluaran multikelas di tutorial mendatang.
Setelah definisi ditetapkan, langkah selanjutnya adalah melihat bagaimana algoritma mengubah fitur mentah menjadi keputusan kelas.
Bagaimana cara kerja pengklasifikasi biner?
Anda telah mempelajari di tutorial sebelumnya bahwa suatu fungsi terdiri dari dua jenis variabel, variabel terikat dan sekumpulan fitur (variabel bebas). Dalam regresi linier, variabel terikat adalah bilangan real tanpa jangkauan. Tujuan utamanya adalah untuk memprediksi nilainya dengan meminimalkan kesalahan kuadrat rata-rata.
Untuk TensorFlow Pada pengklasifikasi biner, label dapat memiliki dua nilai bilangan bulat yang mungkin. Dalam kebanyakan kasus, nilainya adalah [0,1] atau [1,2]. Misalnya, tujuannya adalah untuk memprediksi apakah pelanggan akan membeli suatu produk atau tidak. Label didefinisikan sebagai berikut:
- Y = 1 (pelanggan membeli produk)
- Y = 0 (pelanggan tidak membeli produk)
Model tersebut menggunakan fitur X untuk mengklasifikasikan setiap pelanggan ke dalam kelas yang paling mungkin menjadi miliknya, yaitu calon pembeli atau bukan.
Kemungkinan sukses dihitung dengan regresi logistik. Algoritme akan menghitung probabilitas berdasarkan fitur X dan memprediksi keberhasilan jika probabilitasnya di atas 50 persen. Secara lebih formal, probabilitas dihitung seperti yang ditunjukkan pada contoh Klasifikasi Biner TensorFlow di bawah ini:
dimana 0 adalah himpunan bobot, fitur dan b bias.
Fungsinya dapat diuraikan menjadi dua bagian:
- Model linier
- Fungsi logistik
Model linier
Anda sudah familiar dengan cara penghitungan bobot. Bobot dihitung menggunakan perkalian titik:
Y adalah fungsi linier dari semua fitur xi. Jika model tidak memiliki fitur maka prediksinya sama dengan bias, b.
Bobot menunjukkan arah korelasi antar fitur xi dan label y. Korelasi positif meningkatkan probabilitas kelas positif sedangkan korelasi negatif membawa probabilitas mendekati 0, (yaitu kelas negatif).
Model linier hanya mengembalikan bilangan real, yang tidak konsisten dengan ukuran probabilitas rentang [0,1]. Fungsi logistik diperlukan untuk mengubah keluaran model linier menjadi probabilitas,
Fungsi logistik
Fungsi logistik atau fungsi sigmoid berbentuk S dan keluaran dari fungsi ini selalu antara 0 dan 1.
Rumus di bawah ini menyatakan transformasi tersebut, dan grafik yang menyertainya menunjukkan kurva yang dihasilkan mendatar menuju 0 di sebelah kiri dan menuju 1 di sebelah kanan.
Output regresi linier dapat dengan mudah disubstitusikan ke dalam fungsi sigmoid. Ini menghasilkan angka baru dengan probabilitas antara 0 dan 1.
Pengklasifikasi dapat mengubah probabilitas menjadi sebuah kelas
- Nilai antara 0 hingga 0.49 menjadi kelas 0
- Nilai antara 0.5 hingga 1 menjadi kelas 1
Setelah model menghasilkan kelas, Anda memerlukan cara untuk menilai apakah kelas-kelas tersebut berkualitas baik atau tidak.
Bagaimana Mengukur kinerja Linear Classifier?
Ketepatan
Kinerja keseluruhan pengklasifikasi diukur dengan metrik akurasi. Akurasi mengumpulkan semua nilai yang benar dibagi dengan jumlah total observasi. Misalnya, nilai akurasi 80 persen berarti model tersebut benar dalam 80 persen kasus.
Anda dapat melihat kekurangan metrik ini, terutama untuk kelas ketidakseimbangan. Kumpulan data ketidakseimbangan terjadi ketika jumlah observasi per kelompok tidak sama. Misalnya, Anda mencoba mengklasifikasikan kejadian langka dengan fungsi logistik. Bayangkan pengklasifikasi mencoba memperkirakan kematian pasien setelah suatu penyakit. Dalam data tersebut, 5 persen pasien meninggal dunia. Anda dapat melatih pengklasifikasi untuk memprediksi jumlah kematian dan menggunakan metrik akurasi untuk mengevaluasi kinerja. Jika pengklasifikasi memprediksi 0 kematian untuk seluruh kumpulan data, maka pengklasifikasi akan benar dalam 95 persen kasus.
Matriks kebingungan
Cara yang lebih baik untuk menilai kinerja pengklasifikasi adalah dengan melihat matriks konfusi.
The matriks kebingungan memvisualisasikan keakuratan pengklasifikasi dengan membandingkan kelas aktual dan kelas yang diprediksi seperti yang ditunjukkan pada contoh Pengklasifikasi Linier di atas. Matriks kebingungan biner terdiri dari kotak-kotak:
- TP: Benar Positif: Nilai yang diprediksi diprediksi dengan benar sebagai positif aktual
- FP: Nilai yang diprediksi salah memperkirakan nilai positif sebenarnya. yaitu, nilai Negatif diprediksi sebagai positif
- FN: False Negative: Nilai positif diprediksi negatif
- TN: True Negative: Nilai yang diprediksi diprediksi dengan benar sebagai negatif sebenarnya
Dari matriks konfusi, mudah untuk membandingkan kelas aktual dan kelas prediksi.
Presisi dan Sensitivitas
Matriks konfusi memberikan gambaran yang baik tentang positif sebenarnya dan positif palsu. Dalam beberapa kasus, lebih baik jika memiliki metrik yang lebih ringkas.
Ketelitian
Metrik presisi menunjukkan keakuratan kelas positif. Ini mengukur seberapa besar kemungkinan prediksi kelas positif itu benar.
Skor maksimum adalah 1 ketika pengklasifikasi mengklasifikasikan semua nilai positif dengan sempurna. Presisi saja tidak terlalu membantu karena mengabaikan kelas negatif. Metrik ini biasanya dipasangkan dengan metrik Recall. Penarikan kembali disebut juga sensitivitas atau tingkat positif sebenarnya.
Kepekaan
Sensitivitas menghitung rasio kelas positif yang terdeteksi dengan benar. Metrik ini menunjukkan seberapa baik model dalam mengenali kelas positif.
Teori sudah dipahami, jadi sisa panduan ini akan menerapkannya secara menyeluruh dalam kode.
Pengklasifikasi Linier dengan TensorFlow
Untuk tutorial ini, kita akan menggunakan dataset sensus. Tujuannya adalah menggunakan variabel-variabel dalam kumpulan data sensus untuk memprediksi tingkat pendapatan. Perhatikan bahwa pendapatan adalah variabel biner
- dengan nilai 1 jika pendapatan > 50k
- 0 jika pendapatan <50rb.
Variabel ini adalah label Anda
Kumpulan data ini mencakup delapan variabel kategori:
- tempat kerja
- pendidikan
- perkawinan
- pekerjaan
- hubungan
- ras
- seks
- negara Asal
apalagi, enam variabel kontinu:
- usia
- fnlwgt
- pendidikan_num
- keuntungan dalam bentuk uang
- modal_rugi
- jam_minggu
Melalui contoh Klasifikasi TensorFlow ini, Anda akan memahami cara melatih Pengklasifikasi TensorFlow linier dengan estimator TensorFlow dan cara meningkatkan metrik akurasi.
Catatan versi: Kode di bawah ini menggunakan API Estimator TensorFlow 1.x. tf-estimator Paket ini merilis versi finalnya bersamaan dengan TensorFlow 2.15 dan tidak tersedia di TensorFlow 2.16 atau versi yang lebih baru, jadi jalankan cuplikan kode ini pada TensorFlow 1.x, atau pindahkan ke versi resmi. panduan migrasi estimator kalengKonsep, rekayasa fitur, dan metriknya tetap sama.
Kami akan melanjutkan sebagai berikut:
- Langkah 1) Impor data
- Langkah 2) Konversi Data
- Langkah 3) Latih pengklasifikasi
- Langkah 4) Tingkatkan modelnya
- Langkah 5) Hiperparameter: Lasso & Punggung Bukit
Langkah 1) Impor data
Anda terlebih dahulu mengimpor perpustakaan yang digunakan selama tutorial.
import tensorflow as tf import pandas as pd
Selanjutnya, Anda mengimpor data dari arsip UCI dan menentukan nama kolom. Anda akan menggunakan COLUMNS untuk memberi nama kolom dalam bingkai data pandas.
Perhatikan bahwa Anda akan melatih pengklasifikasi menggunakan kerangka data Pandas.
## 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"
Data yang disimpan secara online sudah dibagi antara set kereta dan set pengujian.
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)
Set kereta berisi 32,561 observasi dan set tes 16,281
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 membutuhkan nilai Boolean untuk melatih pengklasifikasi. Anda perlu mengkonversi nilai dari string ke integer. Label disimpan sebagai objek, namun, Anda perlu mengonversinya menjadi nilai numerik. Kode di bawah ini membuat kamus dengan nilai yang akan dikonversi dan melakukan perulangan pada setiap item kolom. Perhatikan bahwa Anda melakukan operasi ini dua kali, satu untuk data pelatihan dan satu untuk data pengujian.
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]
Dalam data pelatihan, terdapat 24,720 pendapatan di bawah 50.000 dan 7841 di atas 50.000. Rasio ini hampir sama untuk set data uji, sehingga kira-kira 76 persen dari kedua pembagian tersebut termasuk dalam kelas negatif.
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
Langkah 2) Konversi Data
Beberapa langkah diperlukan sebelum Anda melatih pengklasifikasi linier dengan TensorFlow. Anda perlu mempersiapkan fitur-fitur yang akan disertakan dalam model. Dalam regresi benchmark, Anda akan menggunakan data asli tanpa menerapkan transformasi apa pun, persis seperti scikit-belajar Pipeline akan dimulai dari kolom mentah.
Estimator perlu memiliki daftar fitur untuk melatih model. Oleh karena itu, data kolom perlu diubah menjadi tensor.
Praktik yang baik adalah dengan menentukan dua daftar fitur berdasarkan tipenya dan kemudian meneruskannya ke kolom_fitur estimator.
Anda akan mulai dengan mengonversi fitur berkelanjutan, lalu menentukan keranjang dengan data kategorikal.
Fitur kumpulan data memiliki dua format:
- Bilangan bulat
- obyek
Setiap fitur dicantumkan dalam dua variabel berikutnya sesuai tipenya.
## 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 dilengkapi dengan objek numerik_column untuk membantu transformasi variabel kontinu menjadi tensor. Pada kode di bawah ini, Anda mengonversi semua variabel dari CONTI_FEATURES menjadi tensor dengan nilai numerik. Ini wajib untuk membangun model. Semua variabel independen perlu diubah menjadi jenis tensor yang tepat.
Di bawah ini kami menulis kode untuk menunjukkan apa yang terjadi di balik feature_column.numeric_column. Kami akan mencetak nilai yang dikonversi untuk usia. Ini hanya untuk tujuan penjelasan, jadi tidak perlu dipahami. Python Kode. Anda dapat merujuk ke dokumentasi resmi untuk memahami kode-kode tersebut.
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.]]
Nilainya sama persis dengan di df_train
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]
Menurut dokumentasi TensorFlow, ada berbagai cara untuk mengonversi data kategorikal. Jika daftar kosakata suatu fitur diketahui dan tidak memiliki banyak nilai, kolom kategorikal dapat dibuat dengan categorical_column_with_vocabulary_list. Ini akan menetapkan ID ke semua daftar kosakata unik.
Misalnya, jika status variabel memiliki tiga nilai berbeda:
- Suami
- Istri
- Tunggal
Kemudian tiga ID akan dikaitkan. Misal Suami punya KTP 1, Istri KTP 2, dan seterusnya.
Sebagai ilustrasi, Anda dapat menggunakan kode ini untuk mengonversi variabel objek menjadi kolom kategorikal di TensorFlow.
Fitur jenis kelamin hanya dapat memiliki dua nilai: laki-laki atau perempuan. Saat kita mengkonversi fitur jenis kelamin, TensorFlow akan membuat 2 kolom baru, satu untuk laki-laki dan satu untuk perempuan. Jika jenis kelaminnya sama dengan laki-laki, maka kolom baru laki-laki akan bernilai 1 dan perempuan bernilai 0. Contoh ini ditampilkan pada tabel di bawah ini:
| baris | seks | setelah transformasi | pria | wanita |
|---|---|---|---|---|
| 1 | pria | => | 1 | 0 |
| 2 | pria | => | 1 | 0 |
| 3 | wanita | => | 0 | 1 |
Dalam aliran tensor:
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'])
Di bawah ini, kami menambahkan Python kode untuk mencetak pengkodean. Sekali lagi, Anda tidak perlu memahami kodenya, tujuannya adalah untuk melihat transformasinya
Namun, cara yang lebih cepat untuk mentransformasi data adalah dengan menggunakan metode categorical_column_with_hash_bucket. Mengubah variabel string dalam matriks sparse akan sangat berguna. Matriks sparse adalah matriks yang sebagian besar berisi nol. Metode ini menangani semuanya. Anda hanya perlu menentukan jumlah bucket dan kolom kunci. Jumlah bucket adalah jumlah maksimum grup yang dapat dibuat oleh TensorFlow. Kolom kunci hanyalah nama kolom yang akan dikonversi.
Pada kode di bawah ini, Anda membuat perulangan pada semua fitur kategorikal.
categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]
Langkah 3) Latih Pengklasifikasi
TensorFlow saat ini menyediakan estimator untuk regresi linier dan klasifikasi linier.
- Regresi linier: Regresor Linier
- Klasifikasi linier: LinearClassifier
Sintaks pengklasifikasi linier sama seperti pada tutorial regresi linier kecuali satu argumen, n_class. Anda perlu menentukan kolom fitur, direktori model dan membandingkannya dengan regresi linier; Anda harus menentukan jumlah kelas. Untuk regresi logit, jumlah kelasnya sama dengan 2.
Model akan menghitung bobot kolom yang terdapat dalam fitur_kontinu dan fitur_kategori.
model = tf.estimator.LinearClassifier(
n_classes = 2,
model_dir="ongoing/train",
feature_columns=categorical_features+ continuous_features)
Keluaran
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}
Sekarang setelah pengklasifikasi ditentukan, Anda dapat membuat fungsi input. Caranya sama seperti pada tutorial linear regressor. Di sini, Anda menggunakan ukuran batch 128 dan Anda mengacak datanya.
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)
Anda membuat fungsi dengan argumen yang diperlukan oleh estimator linier, yaitu jumlah zaman, jumlah batch, dan mengacak kumpulan data atau catatan. Sejak Anda menggunakan Panda metode untuk meneruskan data ke dalam model, Anda perlu mendefinisikan variabel X sebagai bingkai data pandas. Perhatikan bahwa Anda mengulang semua data yang disimpan di FEATURES.
Mari kita latih modelnya dengan objek model.train. Anda menggunakan fungsi yang ditentukan sebelumnya untuk memberi model dengan nilai yang sesuai. Perhatikan bahwa Anda mengatur ukuran batch ke 128 dan jumlah zaman ke Tidak Ada. Model akan dilatih dalam seribu langkah.
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>
Perhatikan bahwa kerugian kemudian berkurang selama 100 langkah terakhir, yaitu dari 901 menjadi 1000.
Kerugian akhir setelah seribu iterasi adalah 5444. Anda dapat memperkirakan model Anda pada set pengujian dan melihat performanya. Untuk mengevaluasi performa model Anda, Anda perlu menggunakan evaluasi objek. Anda memberi makan model dengan set pengujian dan mengatur jumlah epoch ke 1, yaitu data akan masuk ke model hanya satu kali.
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 menampilkan semua metrik yang Anda pelajari di bagian teoretis. Tidak mengherankan, akurasinya tinggi karena labelnya tidak seimbang. Sebenarnya, performa model sedikit lebih baik daripada tebakan acak. Bayangkan model tersebut memprediksi seluruh rumah tangga dengan pendapatan di bawah 50K, maka model tersebut memiliki akurasi 70 persen. Jika dianalisis lebih dekat, Anda dapat melihat prediksi dan recall yang cukup rendah.
Langkah 4) Tingkatkan modelnya
Sekarang setelah Anda memiliki model benchmark, Anda dapat mencoba memperbaikinya, yaitu meningkatkan akurasi. Di tutorial sebelumnya, Anda mempelajari cara meningkatkan kekuatan prediksi dengan istilah interaksi. Dalam tutorial ini, Anda akan meninjau kembali ide ini dengan menambahkan suku polinomial ke regresi.
Regresi polinomial berguna jika terdapat non-linearitas pada data. Ada dua cara untuk menangkap non-linearitas dalam data.
- Tambahkan suku polinomial
- Masukkan variabel kontinu ke dalam variabel kategori
Istilah polinomial
Dari gambar di bawah ini Anda dapat melihat apa itu regresi polinomial. Ini adalah persamaan dengan variabel X dengan kekuatan berbeda. Regresi polinomial derajat kedua memiliki dua variabel, X dan X kuadrat. Derajat ketiga mempunyai tiga variabel yaitu X, X2, dan X3
Grafik di atas memplot kurva derajat kedua terhadap persamaan dasarnya. Di bawah ini, kami membuat grafik dengan dua variabel, X dan Y. Jelas bahwa hubungannya tidak linier. Jika kita menambahkan regresi linier, kita dapat melihat bahwa model tersebut tidak mampu menangkap polanya (gambar kiri).
Sekarang, lihat gambar kiri dari gambar di bawah, kita menambahkan lima suku ke dalam regresi (yaitu y=x+x2+x3+x4+x5. Model tersebut sekarang menangkap pola dengan lebih baik. Inilah kekuatan regresi polinomial.
Mari kita kembali ke contoh kita. Usia tidak mempunyai hubungan linier dengan pendapatan. Usia dini mungkin memiliki pendapatan tetap mendekati nol karena anak-anak atau remaja tidak bekerja. Kemudian meningkat pada usia kerja dan menurun pada usia pensiun. Biasanya berbentuk U Terbalik. Salah satu cara untuk menangkap pola ini adalah dengan menambahkan pangkat dua pada regresi.
Mari kita lihat apakah ini meningkatkan akurasi.
Anda perlu menambahkan fitur baru ini ke kumpulan data dan daftar fitur berkelanjutan.
Anda menambahkan variabel baru dalam kumpulan data pelatihan dan pengujian, sehingga lebih mudah untuk menulis suatu fungsi.
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
Fungsi ini memiliki 3 argumen:
- df_t: tentukan set pelatihan
- df_te: tentukan set pengujian
- var_name = 'age': Tentukan variabel yang akan diubah
Anda dapat menggunakan objek pow(2) untuk mengkuadratkan variabel usia. Perhatikan bahwa variabel baru diberi nama 'baru'
Sekarang setelah fungsi square_var ditulis, Anda dapat membuat kumpulan data baru.
df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')
Seperti yang Anda lihat, kumpulan data baru memiliki satu fitur lagi.
print(df_train_new.shape, df_test_new.shape)
(32561, 16) (16281, 16)
Variabel kuadrat disebut baru dalam kumpulan data. Anda perlu menambahkannya ke daftar fitur berkelanjutan.
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]
Note bahwa Anda mengubah direktori Graph. Anda tidak dapat melatih model berbeda dalam direktori yang sama. Artinya, Anda perlu mengubah jalur argumen model_dir. Jika Anda tidak melakukannya, TensorFlow akan menimbulkan kesalahan.
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)
Sekarang pengklasifikasi dirancang dengan kumpulan data baru, Anda dapat melatih dan mengevaluasi model.
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}
Variabel kuadrat meningkatkan akurasi dari 0.76 menjadi 0.79. Mari kita lihat apakah Anda dapat melakukan yang lebih baik dengan menggabungkan bucketisasi dan istilah interaksi secara bersamaan.
Bucketisasi dan interaksi
Seperti yang Anda lihat sebelumnya, pengklasifikasi linier tidak dapat menangkap pola usia-pendapatan dengan benar. Hal ini karena ia mempelajari satu bobot untuk setiap fitur. Untuk memudahkan pengklasifikasi, satu hal yang dapat Anda lakukan adalah mengelompokkan fitur tersebut. Pengelompokan mengubah fitur numerik menjadi beberapa fitur tertentu berdasarkan rentangnya, dan masing-masing fitur baru ini menunjukkan apakah usia seseorang termasuk dalam rentang tersebut.
Dengan fitur baru ini, model linier dapat menangkap hubungan dengan mempelajari bobot berbeda untuk setiap keranjang.
Di TensorFlow, ini dilakukan dengan bucketized_column. Anda perlu menambahkan rentang nilai dalam batasan.
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])
Anda pasti tahu usia tidak linier dengan pendapatan. Cara lain untuk meningkatkan model adalah melalui interaksi. Dalam kata TensorFlow, ini adalah persilangan fitur. Persilangan fitur adalah cara untuk membuat fitur baru yang merupakan kombinasi dari fitur yang sudah ada, yang dapat berguna untuk pengklasifikasi linier yang tidak dapat memodelkan interaksi antar fitur.
Anda dapat mengelompokkan usia dengan fitur lain seperti pendidikan. Artinya, beberapa kelompok cenderung mempunyai pendapatan tinggi dan kelompok lainnya rendah (Pikirkan tentang mahasiswa PhD).
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)]
Untuk membuat kolom fitur silang, Anda menggunakan kolom_silang dengan variabel yang disilang dalam tanda kurung. Hash_bucket_size menunjukkan kemungkinan penyeberangan maksimum. Untuk membuat interaksi antar variabel (setidaknya satu variabel harus bersifat kategoris), Anda dapat menggunakan tf.feature_column.crossed_column. Untuk menggunakan objek ini, Anda perlu menambahkan variabel yang akan berinteraksi dalam tanda kurung siku dan argumen kedua, ukuran keranjang. Ukuran bucket adalah jumlah grup maksimum yang mungkin ada dalam suatu variabel. Di sini Anda menetapkannya pada 1000 karena Anda tidak mengetahui jumlah pasti grupnya
age_buckets perlu dikuadratkan sebelum menambahkannya ke kolom fitur. Anda juga menambahkan fitur baru ke kolom fitur dan menyiapkan estimator
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)
Keluaran
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)
Anda siap memperkirakan model baru dan melihat apakah model tersebut meningkatkan akurasinya.
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}
Tingkat akurasi baru sebesar 83.58 persen. Ini empat persen lebih tinggi dari model sebelumnya.
Terakhir, Anda dapat menambahkan istilah regularisasi untuk mencegah overfitting.
Langkah 5) Hiperparameter: Lasso & Punggung Bukit
Model Anda mungkin menderita terlalu pas or kurang pas.
- Overfitting: Model tidak dapat menggeneralisasi prediksi ke data baru
- Underfitting: Model tidak dapat menangkap pola data. yaitu regresi linier ketika datanya non-linier
Jika suatu model memiliki banyak parameter dan jumlah data yang relatif sedikit, hal ini akan menghasilkan prediksi yang buruk. Bayangkan, satu kelompok hanya melakukan tiga observasi; model akan menghitung bobot untuk grup ini. Bobot digunakan untuk membuat prediksi; jika observasi set pengujian untuk kelompok tertentu berbeda sama sekali dengan set pelatihan, maka model akan membuat prediksi yang salah. Selama evaluasi dengan set pelatihan, keakuratannya baik, tetapi tidak baik dengan set pengujian karena bobot yang dihitung tidak sesuai untuk menggeneralisasi pola. Dalam hal ini, ia tidak membuat prediksi yang masuk akal atas data yang tidak terlihat.
Untuk mencegah overfitting, regularisasi memberi Anda kemungkinan untuk mengendalikan kompleksitas tersebut dan membuatnya lebih dapat digeneralisasi. Ada dua teknik regularisasi:
- L1: Laso
- L2: Punggungan
Di TensorFlow, Anda dapat menambahkan dua hyperparameter ini di pengoptimal. Misalnya, semakin tinggi hyperparameter L2, bobotnya cenderung sangat rendah dan mendekati nol. Garis yang dipasang akan sangat datar, sedangkan L2 yang mendekati nol berarti bobotnya mendekati regresi linier biasa.
Anda dapat mencoba sendiri nilai hyperparameter yang berbeda dan melihat apakah Anda dapat meningkatkan tingkat akurasinya.
Note bahwa jika Anda mengubah hiperparameter, Anda perlu menghapus folder being/train4 jika tidak, model akan mulai dengan model yang telah dilatih sebelumnya.
Mari kita lihat bagaimana keakuratannya dengan hype tersebut
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))
Keluaran
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)
Keluaran
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)
Keluaran
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}
Dengan hyperparameter ini, Anda sedikit meningkatkan metrik akurasi. Tabel di bawah ini mengumpulkan setiap metrik yang dilaporkan oleh keempat panggilan evaluasi dalam tutorial ini.
| Pilih Model | Kumpulan fitur | Ketepatan | AUC | Ketelitian | Mengingat kembali |
|---|---|---|---|---|---|
| model | Data dasar kontinu + kategorikal | 0.7615626 | 0.63300294 | 0.49401596 | 0.38637546 |
| model_1 | Usia dasar ditambah kuadrat usia | 0.7944229 | 0.6093755 | 0.6682401 | 0.2576703 |
| model_imp | Usia yang dikelompokkan ditambah kolom bersilang | 0.8358209 | 0.88401634 | 0.68986726 | 0.55408216 |
| model_regu | Kolom bersilang ditambah L1 dan L2 | 0.83833915 | 0.8869794 | 0.69720596 | 0.5579823 |
Perhatikan bahwa akurasi dasar dari model yang selalu memprediksi kelas mayoritas adalah 0.76377374, jadi hanya dua model terakhir yang mengalahkan tebakan sederhana dengan selisih yang bermanfaat.
Pada tutorial berikutnya, Anda akan mempelajari cara meningkatkan pengklasifikasi linier menggunakan sebuah metode kernel.
