Klasifikasi Binari di TensorFlow: Contoh Pengelasan Linear

Isi kandungan:

Anonim

Dua tugas pembelajaran yang diselia yang paling biasa adalah regresi linear dan pengkelasan linear. Regresi linier meramalkan nilai sementara pengkelasan linear meramalkan suatu kelas. Tutorial ini difokuskan pada Linear Classifier.

Apakah Pengelasan Linear?

A Linear Pengelas di Machine Learning adalah kaedah untuk mencari kelas objek berdasarkan ciri-ciri untuk pengelasan statistik. Ia membuat keputusan klasifikasi berdasarkan nilai gabungan linear ciri-ciri objek. Pengelasan linear digunakan dalam masalah praktikal seperti pengelasan dokumen dan masalah yang mempunyai banyak pemboleh ubah.

Masalah klasifikasi mewakili kira-kira 80 peratus tugas pembelajaran mesin. Klasifikasi bertujuan untuk meramalkan kebarangkalian setiap kelas diberi satu set input. Label (iaitu, pemboleh ubah bersandar) adalah nilai diskrit, disebut kelas.

  1. Sekiranya label hanya mempunyai dua kelas, algoritma pembelajaran adalah Binary Classifier.
  2. Pengelas multiclass mengatasi label dengan lebih daripada dua kelas.

Sebagai contoh, masalah klasifikasi binari yang tipikal adalah meramalkan kemungkinan pelanggan membuat pembelian kedua. Ramalkan jenis haiwan yang dipaparkan pada gambar adalah masalah klasifikasi multiclass kerana terdapat lebih dari dua jenis haiwan yang ada.

Bahagian teori dari tutorial ini meletakkan fokus utama pada kelas binari. Anda akan mengetahui lebih lanjut mengenai fungsi output multikelas dalam tutorial yang akan datang.

Dalam tutorial ini, anda akan belajar

  • Apakah Pengelasan Linear?
  • Bagaimana pengkelasan binari berfungsi?
  • Bagaimana Mengukur prestasi Linear Classifier?
  • Ketepatan
  • Matriks kekeliruan
  • Ketepatan dan Kepekaan
  • Pengelasan Linear dengan TensorFlow
  • Langkah 1) Import data
  • Langkah 2) Penukaran Data
  • Langkah 3) Latih Pengelas
  • Langkah 4) Perbaiki model
  • Langkah 5) Hyperparameter: Lasso & Ridge

Bagaimana pengkelasan binari berfungsi?

Anda belajar di tutorial sebelumnya bahawa fungsi terdiri daripada dua jenis pemboleh ubah, pemboleh ubah bersandar dan sekumpulan ciri (pemboleh ubah bebas). Dalam regresi linear, pemboleh ubah bersandar adalah nombor nyata tanpa julat. Objektif utama adalah untuk meramalkan nilainya dengan meminimumkan ralat kuasa dua rata-rata.

Untuk TensorFlow Binary Classifier, label boleh mempunyai dua kemungkinan nilai integer. Dalam kebanyakan kes, ia adalah [0,1] atau [1,2]. Sebagai contoh, objektifnya adalah untuk meramalkan adakah pelanggan akan membeli produk atau tidak. Label ditakrifkan sebagai berikut:

  • Y = 1 (pelanggan membeli produk)
  • Y = 0 (pelanggan tidak membeli produk)

Model ini menggunakan ciri X untuk mengklasifikasikan setiap pelanggan dalam kelas yang paling mungkin menjadi miliknya, iaitu calon pembeli atau tidak.

Kebarangkalian kejayaan dikira dengan regresi logistik . Algoritma akan mengira kebarangkalian berdasarkan ciri X dan meramalkan kejayaan apabila kebarangkalian ini melebihi 50 peratus. Secara lebih formal, kebarangkalian dikira seperti yang ditunjukkan dalam contoh TensorFlow Binary Classification di bawah ini:

di mana 0 adalah set timbang, ciri dan b bias.

Fungsi tersebut dapat diuraikan menjadi dua bahagian:

  • Model linear
  • Fungsi logistik

Model linier

Anda sudah biasa dengan cara pengiraan berat. Berat dikira menggunakan produk titik: Y adalah fungsi linear semua ciri x i . Sekiranya model tidak mempunyai ciri, ramalannya sama dengan bias, b.

Berat menunjukkan arah korelasi antara ciri x i dan label y. Korelasi positif meningkatkan kebarangkalian kelas positif sementara korelasi negatif membawa kebarangkalian mendekati 0, (iaitu kelas negatif).

Model linier hanya mengembalikan nombor nyata, yang tidak konsisten dengan ukuran kebarangkalian julat [0,1]. Fungsi logistik diperlukan untuk menukar output model linear menjadi kebarangkalian,

Fungsi logistik

Fungsi logistik, atau fungsi sigmoid, mempunyai bentuk-S dan output fungsi ini selalu antara 0 dan 1.

Contoh Fungsi Logistik

Sangat mudah untuk menggantikan output regresi linier ke fungsi sigmoid. Ia menghasilkan nombor baru dengan kebarangkalian antara 0 dan 1.

Pengelas dapat mengubah kebarangkalian menjadi kelas

  • Nilai antara 0 hingga 0,49 menjadi kelas 0
  • Nilai antara 0.5 hingga 1 menjadi kelas 1

Bagaimana Mengukur prestasi Linear Classifier?

Ketepatan

Prestasi keseluruhan pengkelasan diukur dengan metrik ketepatan. Ketepatan mengumpulkan semua nilai yang betul dibahagi dengan jumlah pemerhatian. Sebagai contoh, nilai ketepatan 80 peratus bermaksud model itu betul dalam 80 peratus kes.

Ukur prestasi Linear Classifier menggunakan metrik Ketepatan

Anda dapat mengetahui kekurangan metrik ini, terutamanya untuk kelas ketidakseimbangan. Set data ketidakseimbangan berlaku apabila jumlah pemerhatian setiap kumpulan tidak sama. Katakan; anda cuba mengelaskan peristiwa yang jarang berlaku dengan fungsi logistik. Bayangkan pengkelas cuba menganggarkan kematian pesakit akibat penyakit. Dalam data tersebut, 5 peratus pesakit meninggal dunia. Anda boleh melatih pengkelasan untuk meramalkan jumlah kematian dan menggunakan metrik ketepatan untuk menilai persembahan. Sekiranya pengkelasan meramalkan 0 kematian untuk keseluruhan kumpulan data, itu akan betul dalam 95 peratus kes.

Matriks kekeliruan

Kaedah yang lebih baik untuk menilai prestasi pengkelasan adalah dengan melihat matriks kekeliruan.

Ukur prestasi Linear Classifier menggunakan Confusion matrix

Matriks kekeliruan memvisualisasikan ketepatan pengkelasan dengan membandingkan kelas sebenar dan ramalan seperti yang ditunjukkan dalam contoh Pengelasan Linear di atas. Matriks kekeliruan binari terdiri daripada kotak:

  • TP: Positif Benar: Nilai ramalan yang diramalkan dengan betul sebagai positif sebenar
  • FP: Nilai yang diramalkan dengan betul meramalkan positif sebenar. iaitu, Nilai negatif diramalkan sebagai positif
  • FN: Negatif Salah: Nilai positif diramalkan sebagai negatif
  • TN: Negatif Benar: Nilai ramalan yang diramalkan dengan betul sebagai negatif sebenarnya

Dari matriks kekeliruan, mudah untuk membandingkan kelas sebenar dan kelas ramalan.

Ketepatan dan Kepekaan

Matriks kekeliruan memberikan gambaran yang baik mengenai positif positif dan positif palsu. Dalam beberapa kes, lebih baik mempunyai metrik yang lebih ringkas.

Ketepatan

Metrik ketepatan menunjukkan ketepatan kelas positif. Ini mengukur kemungkinan ramalan kelas positif itu betul.

Skor maksimum adalah 1 apabila pengelasan mengelaskan dengan sempurna semua nilai positif. Ketepatan sahaja tidak begitu membantu kerana mengabaikan kelas negatif. Metrik biasanya dipasangkan dengan metrik Recall. Ingat juga disebut kepekaan atau kadar positif benar.

Kepekaan

Sensitiviti mengira nisbah kelas positif yang dikesan dengan betul. Metrik ini memberikan seberapa baik model untuk mengenali kelas positif.

Pengelasan Linear dengan TensorFlow

Untuk tutorial ini, kami akan menggunakan set data banci. Tujuannya adalah untuk menggunakan pemboleh ubah dalam kumpulan data banci untuk meramalkan tahap pendapatan. Perhatikan bahawa pendapatan adalah pemboleh ubah binari

  • dengan nilai 1 jika pendapatan> 50k
  • 0 jika pendapatan <50k.

Pemboleh ubah ini adalah label anda

Set data ini merangkumi lapan pemboleh ubah kategori:

  • tempat kerja
  • pendidikan
  • perkahwinan
  • pekerjaan
  • hubungan
  • perlumbaan
  • seks
  • negara asal

lebih-lebih lagi, enam pemboleh ubah berterusan:

  • umur
  • fnlwgt
  • pendidikan_num
  • modal_mendapat
  • kerugian_ modal
  • jam_ minggu

Melalui contoh TensorFlow Classification ini, anda akan memahami cara melatih TensorFlow Classifiers linear dengan TensorFlow estimator dan bagaimana meningkatkan metrik ketepatan.

Kami akan meneruskan seperti berikut:

  • Langkah 1) Import data
  • Langkah 2) Penukaran Data
  • Langkah 3) Latih kelas
  • Langkah 4) Perbaiki model
  • Langkah 5) Hyperparameter: Lasso & Ridge

Langkah 1) Import data

Anda mula-mula mengimport perpustakaan yang digunakan semasa tutorial.

import tensorflow as tfimport pandas as pd

Seterusnya, anda mengimport data dari arkib UCI dan menentukan nama lajur. Anda akan menggunakan COLUMNS untuk menamakan lajur dalam bingkai data panda.

Perhatikan bahawa anda akan melatih pengkelas menggunakan bingkai data Pandas.

## Define path dataCOLUMNS = ['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 dalam talian sudah dibahagikan antara set kereta api dan set ujian.

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 api mengandungi 32,561 pemerhatian dan set ujian 16,281

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

Tensorflow memerlukan nilai Boolean untuk melatih pengkelasan. Anda perlu membuang nilai dari rentetan ke bilangan bulat. Label disimpan sebagai objek, namun, anda perlu mengubahnya menjadi nilai angka. Kod di bawah membuat kamus dengan nilai untuk ditukar dan melingkari item lajur. Perhatikan bahawa anda melakukan operasi ini dua kali, satu untuk ujian kereta api, satu untuk ujian set

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 kereta api, terdapat 24,720 pendapatan lebih rendah daripada 50k dan 7841 di atas. Nisbahnya hampir sama untuk set ujian. Sila rujuk tutorial ini di Facets untuk maklumat lebih lanjut.

print(df_train["label"].value_counts())### The model will be correct in atleast 70% of the caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

Langkah 2) Penukaran Data

Beberapa langkah diperlukan sebelum anda melatih pengkelasan linear dengan Tensorflow. Anda perlu menyiapkan ciri untuk disertakan dalam model. Dalam regresi penanda aras, anda akan menggunakan data asal tanpa melakukan transformasi.

Penganggar perlu mempunyai senarai ciri untuk melatih model. Oleh itu, data lajur perlu ditukar menjadi tensor.

Amalan yang baik adalah menentukan dua senarai ciri berdasarkan jenisnya dan kemudian memasukkannya ke dalam ruangan_koleksi penganggar.

Anda akan memulakan dengan menukar ciri berterusan, kemudian menentukan baldi dengan data kategori.

Ciri-ciri set data mempunyai dua format:

  • Bilangan bulat
  • Objek

Setiap ciri disenaraikan dalam dua pemboleh ubah seterusnya mengikut jenisnya.

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

Kolom feature_ dilengkapi dengan kolum numerik_ objek untuk membantu transformasi pemboleh ubah berterusan menjadi tensor. Dalam kod di bawah, anda menukar semua pemboleh ubah dari CONTI_FEATURES menjadi tensor dengan nilai berangka. Ini adalah wajib untuk membina model. Semua pemboleh ubah bebas perlu ditukar menjadi jenis tensor yang betul.

Di bawah ini kami tuliskan kod untuk membolehkan anda melihat apa yang berlaku di sebalik kolom feature_column.numeric_column. Kami akan mencetak nilai yang ditukar untuk usia. Ini adalah untuk tujuan penjelasan, oleh itu tidak perlu memahami kod python. Anda boleh merujuk kepada dokumentasi rasmi untuk memahami kodnya.

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif 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 valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(sess.run(input_layer))print_transformation(feature = "age", continuous = True)[[39.][50.][38.]… [58.][22.][52.]]

Nilainya sama seperti di df_train

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

Menurut dokumentasi TensorFlow, terdapat pelbagai cara untuk menukar data kategori. Sekiranya senarai perbendaharaan kata ciri diketahui dan tidak mempunyai banyak nilai, adalah mungkin untuk membuat lajur kategori dengan senarai_kategori_kategori_kategori_kategori. Ia akan memberikan ID pada semua kosa kata unik.

Contohnya, jika status pemboleh ubah mempunyai tiga nilai yang berbeza:

  • Suami
  • Isteri
  • Bujang

Kemudian tiga ID akan dikaitkan. Contohnya, Suami akan mempunyai ID 1, Isteri ID 2 dan sebagainya.

Untuk tujuan ilustrasi, anda boleh menggunakan kod ini untuk menukar pemboleh ubah objek ke lajur kategori di TensorFlow.

Seks ciri hanya boleh mempunyai dua nilai: lelaki atau wanita. Apabila kita menukar jenis kelamin, Tensorflow akan membuat 2 lajur baru, satu untuk lelaki dan satu untuk wanita. Sekiranya jantina sama dengan lelaki, maka lelaki lajur baru akan sama dengan 1 dan perempuan hingga 0. Contoh ini ditunjukkan dalam jadual di bawah:

barisan

seks

selepas transformasi

lelaki

perempuan

1

lelaki

=>

1

0

2

lelaki

=>

1

0

3

perempuan

=>

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 kod Python untuk mencetak pengekodan. Sekali lagi, anda tidak perlu memahami kodnya, tujuannya adalah untuk melihat transformasinya

Walau bagaimanapun, cara yang lebih cepat untuk mengubah data adalah dengan menggunakan kaedah kategori_kolom_with_hash_bucket. Mengubah pemboleh ubah rentetan dalam matriks jarang akan berguna. Matriks jarang adalah matriks dengan kebanyakan sifar. Kaedahnya menguruskan segalanya. Anda hanya perlu menentukan bilangan baldi dan lajur kunci. Bilangan baldi adalah jumlah maksimum kumpulan yang dapat dibuat oleh Tensorflow. Lajur utama hanyalah nama lajur yang hendak ditukar.

Dalam kod di bawah, anda membuat gelung ke atas semua ciri kategori.

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

Langkah 3) Latih Pengelas

TensorFlow kini menyediakan penganggar untuk regresi linear dan klasifikasi linear.

  • Regresi linear: LinearRegressor
  • Klasifikasi linear: LinearClassifier

Sintaks pengkelasan linear adalah sama seperti dalam tutorial regresi linear kecuali satu argumen, n_class. Anda perlu menentukan lajur ciri, direktori model dan, bandingkan dengan regresor linier; anda mempunyai menentukan bilangan kelas. Untuk regresi logit, jumlah kelas adalah sama dengan 2.

Model ini akan mengira berat lajur yang terdapat dalam ciri_kesinambungan dan sifat_kategori.

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

PENGELUARAN:

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':, '_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}

Setelah pengelasan ditentukan, anda boleh membuat fungsi input. Kaedahnya sama seperti dalam tutorial regresor linear. Di sini, anda menggunakan ukuran kumpulan 128 dan anda mengubah data.

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 penganggar linear, iaitu, jumlah zaman, bilangan kumpulan dan mengombak set data atau nota. Oleh kerana anda menggunakan kaedah Pandas untuk memasukkan data ke dalam model, anda perlu menentukan pemboleh ubah X sebagai bingkai data panda. Perhatikan bahawa anda melingkari semua data yang disimpan dalam CIRI.

Mari latih model dengan model objek.train. Anda menggunakan fungsi yang ditentukan sebelumnya untuk memberi makan model dengan nilai yang sesuai. Perhatikan bahawa anda menetapkan saiz kumpulan menjadi 128 dan bilangan zaman menjadi Tiada. Model akan dilatih lebih dari 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 = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO: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.

Perhatikan bahawa kerugian menurun kemudian selama 100 langkah terakhir, iaitu dari 901 hingga 1000.

Kerugian terakhir setelah seribu lelaran adalah 5444. Anda boleh menganggar model anda pada set ujian dan melihat prestasinya. Untuk menilai prestasi model anda, anda perlu menggunakan objek yang dinilai. Anda memberi makan model dengan set ujian dan menetapkan jumlah zaman menjadi 1, iaitu, data akan masuk ke model hanya sekali.

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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO: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:23INFO: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 mengembalikan semua metrik yang anda pelajari di bahagian teori. Tanpa mengejutkan, ketepatannya besar kerana label yang tidak seimbang. Sebenarnya, model itu berprestasi sedikit lebih baik daripada tekaan rawak. Bayangkan model meramalkan semua isi rumah dengan pendapatan lebih rendah daripada 50K, maka model itu mempunyai ketepatan 70 peratus. Pada analisis yang lebih dekat, anda dapat melihat ramalan dan penarikan balik agak rendah.

Langkah 4) Perbaiki model

Setelah anda mempunyai model penanda aras, anda boleh mencuba memperbaikinya, iaitu meningkatkan ketepatan. Dalam tutorial sebelumnya, anda belajar bagaimana meningkatkan daya ramalan dengan istilah interaksi. Dalam tutorial ini, anda akan melihat semula idea ini dengan menambahkan istilah polinomial ke regresi.

Regresi polinomial sangat penting apabila terdapat data yang tidak linear. Terdapat dua cara untuk menangkap non-linear dalam data.

  • Tambah istilah polinomial
  • Bucketize pemboleh ubah selanjar menjadi pemboleh ubah kategori

Istilah polinomial

Dari gambar di bawah, anda dapat melihat apa itu regresi polinomial. Ini adalah persamaan dengan pemboleh ubah X dengan daya yang berbeza. Regresi polinomial darjah kedua mempunyai dua pemboleh ubah, X dan X kuasa dua. Darjah ketiga mempunyai tiga pemboleh ubah, X, X 2 , dan X 3

Apa itu Regresi Polinomial

Di bawah ini, kami membina graf dengan dua pemboleh ubah, X dan Y. Jelas bahawa hubungannya tidak linear. Sekiranya kita menambahkan regresi linier, kita dapat melihat model tidak dapat menangkap corak (gambar kiri).

Sekarang, lihat gambar kiri dari gambar di bawah, kami menambahkan lima penggal ke regresi (iaitu y = x + x 2 + x 3 + x 4 + x 5. Model sekarang menangkap corak yang lebih baik. Ini adalah kekuatan regresi polinomial.

Mari kembali kepada contoh kita. Umur tidak dalam hubungan linear dengan pendapatan. Awal usia mungkin mempunyai pendapatan yang hampir mendekati sifar kerana kanak-kanak atau orang muda tidak bekerja. Kemudian ia meningkat dalam usia bekerja dan menurun semasa bersara. Ini biasanya berbentuk Inversed-U. Salah satu cara untuk menangkap corak ini adalah dengan menambahkan kekuatan dua pada regresi.

Mari lihat sama ada ia meningkatkan ketepatan.

Anda perlu menambahkan ciri baru ini ke set data dan dalam senarai ciri berterusan.

Anda menambahkan pemboleh ubah baru di dalam set data kereta api dan ujian, jadi lebih senang menulis 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 mempunyai 3 argumen:

  • df_t: tentukan set latihan
  • df_te: tentukan set ujian
  • var_name = 'age': Tentukan pemboleh ubah yang akan diubah

Anda boleh menggunakan objek pow (2) untuk memusatkan usia berubah. Perhatikan bahawa pemboleh ubah baru dinamakan 'baru'

Setelah fungsi square_var ditulis, anda boleh membuat set data baru.

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

Seperti yang anda lihat, set data baru mempunyai satu lagi ciri.

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

Pemboleh ubah segiempat disebut baru dalam set data. Anda perlu menambahkannya ke senarai ciri berterusan.

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]

Perhatikan bahawa anda mengubah direktori Grafik. Anda tidak dapat melatih model yang berbeza dalam direktori yang sama. Maknanya, anda perlu mengubah jalan model_dir argumen. Sekiranya tidak, 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':, '_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)

Setelah pengkelasan dirancang dengan set data baru, anda boleh melatih dan menilai modelnya.

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 = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO: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.
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:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO: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:39INFO: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}

Pemboleh ubah kuasa dua meningkatkan ketepatan dari 0.76 hingga 0.79. Mari lihat sama ada anda boleh melakukan yang lebih baik dengan menggabungkan istilah baletisasi dan interaksi bersama.

Bucketization dan interaksi

Seperti yang anda lihat sebelumnya, pengkelasan linear tidak dapat menangkap corak pendapatan umur dengan betul. Ini kerana ia belajar satu berat untuk setiap ciri. Untuk mempermudah pengkelasan, satu perkara yang boleh anda lakukan ialah memasukkan ciri. Bucket mengubah ciri numerik menjadi beberapa yang tertentu berdasarkan julatnya, dan setiap ciri baru ini menunjukkan sama ada usia seseorang berada dalam julat tersebut.

Dengan ciri-ciri baru ini, model linier dapat menangkap hubungan dengan mempelajari bobot yang berbeza untuk setiap baldi.

Di TensorFlow, ia dilakukan dengan kolom_berpanjang. Anda perlu menambahkan julat nilai dalam batas.

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 sudah tahu usia tidak linear dengan pendapatan. Kaedah lain untuk memperbaiki model adalah melalui interaksi. Dalam kata TensorFlow, ia adalah penyeberangan ciri. Penyilangan ciri adalah cara untuk membuat ciri baru yang merupakan kombinasi dari yang ada, yang dapat membantu bagi pengklasifikasi linier yang tidak dapat memodelkan interaksi antara ciri.

Anda boleh menguraikan usia dengan ciri lain seperti pendidikan. Maksudnya, beberapa kumpulan cenderung mempunyai pendapatan tinggi dan yang lain rendah (Fikirkan tentang pelajar Ph.D.)

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 lajur ciri silang, anda menggunakan kolum silang_ dengan pemboleh ubah untuk menyeberang dalam kurungan. The hash_bucket_size menunjukkan kemungkinan melintasi maksimum. Untuk membuat interaksi antara pemboleh ubah (sekurang-kurangnya satu pemboleh ubah perlu dikategorikan), anda boleh menggunakan tf.feature_column.crossed_column. Untuk menggunakan objek ini, anda perlu menambahkan tanda kurung segi empat pemboleh ubah untuk berinteraksi dan argumen kedua, ukuran baldi. Ukuran baldi adalah bilangan kumpulan maksimum yang mungkin dalam pemboleh ubah. Di sini anda menetapkannya pada 1000 kerana anda tidak mengetahui bilangan kumpulan yang tepat

age_buckets perlu dikuadrat sebelum menambahkannya ke lajur ciri. Anda juga menambah ciri baru ke lajur ciri dan menyediakan penganggar

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)

PENGELUARAN

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': , '_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 sudah bersedia untuk menganggar model baru dan melihat apakah model tersebut dapat meningkatkan ketepatan.

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 = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO: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.
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:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO: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:54INFO: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}

Tahap ketepatan baru adalah 83.58 peratus. Ia empat peratus lebih tinggi daripada model sebelumnya.

Akhirnya, anda boleh menambahkan istilah regularisasi untuk mengelakkan overfitting.

Langkah 5) Hyperparameter: Lasso & Ridge

Model anda boleh mengalami overfitting atau underfitting .

  • Overfitting: Model tidak dapat menggeneralisasikan ramalan terhadap data baru
  • Underfitting: Model tidak dapat menangkap corak data. iaitu regresi linier apabila data tidak linear

Apabila model mempunyai banyak parameter dan jumlah data yang agak rendah, ini menghasilkan ramalan yang buruk. Bayangkan, satu kumpulan hanya mempunyai tiga pemerhatian; model akan mengira berat bagi kumpulan ini. Berat digunakan untuk membuat ramalan; jika pemerhatian terhadap set ujian untuk kumpulan tertentu ini sama sekali berbeza dengan set latihan, maka model akan membuat ramalan yang salah. Semasa penilaian dengan set latihan, ketepatannya baik, tetapi tidak baik dengan set ujian kerana bobot yang dihitung bukanlah yang benar untuk menggeneralisasikan corak. Dalam kes ini, ia tidak membuat ramalan yang munasabah terhadap data yang tidak dapat dilihat.

Untuk mengelakkan overfitting, regulasi memberi anda kemungkinan untuk mengawal kerumitan tersebut dan menjadikannya lebih umum. Terdapat dua teknik regularisasi:

  • L1: Lasso
  • L2: Ridge

Di TensorFlow, anda boleh menambahkan dua hyperparameter ini dalam pengoptimum. Sebagai contoh, semakin tinggi hiperparameter L2, berat badan cenderung sangat rendah dan hampir dengan sifar. Garis yang dipasang akan sangat rata, sementara L2 mendekati sifar menunjukkan bobotnya hampir dengan regresi linier biasa.

Anda boleh mencuba sendiri nilai hiperparameter yang berbeza dan melihat sama ada anda dapat meningkatkan tahap ketepatan.

Perhatikan bahawa jika anda menukar hyperparameter, anda perlu memadam folder yang sedang berjalan / train4 jika tidak, model akan bermula dengan model yang dilatih sebelumnya.

Mari lihat bagaimana ketepatan dengan gembar-gembur

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))

KELUAR

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': , '_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)

KELUAR

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 = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO: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.
model_regu.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

PENGELUARAN

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:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO: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:09INFO: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 hiperparameter ini, anda sedikit meningkatkan metrik ketepatan. Dalam tutorial seterusnya, anda akan belajar bagaimana meningkatkan pengkelasan linear menggunakan kaedah kernel.

Ringkasan

Untuk melatih model, anda perlu:

  • Tentukan ciri: Pemboleh ubah bebas: X
  • Tentukan label: Pemboleh ubah bersandar: y
  • Bina set kereta api / ujian
  • Tentukan berat awal
  • Tentukan fungsi kerugian: MSE
  • Mengoptimumkan model: Keturunan kecerunan
  • Tentukan:
    • Kadar pembelajaran
    • Bilangan zaman
    • Saiz kumpulan
    • Bilangan kelas

Dalam tutorial ini, anda belajar bagaimana menggunakan API peringkat tinggi untuk pengkelasan regresi linear. Anda perlu menentukan:

  1. Lajur ciri. Sekiranya berterusan: tf.feature_column.numeric_column (). Anda boleh mengisi senarai dengan pemahaman senarai python
  2. Penganggar: tf.estimator.LinearClassifier (ciri_kolom, model_dir, n_kelas = 2)
  3. Fungsi untuk mengimport data, ukuran kumpulan dan zaman: input_fn ()

Selepas itu, anda bersedia untuk melatih, menilai dan membuat ramalan dengan kereta api (), menilai () dan meramalkan ()

Untuk meningkatkan prestasi model, anda boleh:

  • Gunakan regresi polinomial
  • Istilah interaksi: tf.feature_column.crossed_column
  • Tambahkan parameter pengatur