Regresi Linier dengan TensorFlow (Contoh)

Daftar Isi:

Anonim

Apa itu Regresi Linier?

Regresi Linier adalah suatu pendekatan dalam statistik untuk memodelkan hubungan antara dua variabel. Pemodelan ini dilakukan antara respons skalar dan satu atau lebih variabel penjelas. Hubungan dengan satu variabel penjelas disebut regresi linier sederhana dan untuk lebih dari satu variabel penjelas disebut regresi linier berganda.

TensorFlow menyediakan fitur untuk mengontrol penuh komputasi. Ini dilakukan dengan API tingkat rendah. Selain itu, TensorFlow dilengkapi dengan beragam API untuk menjalankan banyak algoritme pembelajaran mesin. Ini adalah API tingkat tinggi. TensorFlow menyebutnya sebagai estimator

  • API tingkat rendah: Bangun arsitektur, pengoptimalan model dari awal. Ini rumit untuk pemula
  • API tingkat tinggi: Tentukan algoritme. Ramah terhadap easer. TensorFlow menyediakan penaksir panggilan kotak alat untuk membuat, melatih, mengevaluasi, dan membuat prediksi.

Dalam tutorial ini, Anda hanya akan menggunakan penduga . Perhitungannya lebih cepat dan lebih mudah diimplementasikan. Bagian pertama dari tutorial ini menjelaskan cara menggunakan pengoptimal penurunan gradien untuk melatih regresi Linear di TensorFlow. Di bagian kedua, Anda akan menggunakan kumpulan data Boston untuk memprediksi harga rumah menggunakan estimator TensorFlow.

Unduh Boston DataSet

Dalam tutorial Regresi TensorFlow ini, Anda akan mempelajari:

  • Apa itu regresi linier?
  • Cara melatih model regresi linier
  • Cara melatih Regresi Linier dengan TensorFlow
  • Panda
  • Solusi Numpy
  • Solusi Tensorflow

Cara melatih model regresi linier

Sebelum kita mulai melatih model, mari kita lihat apa itu regresi linier.

Bayangkan Anda memiliki dua variabel, x dan y dan tugas Anda adalah memprediksi nilai dari mengetahui nilai. Jika Anda memplot data, Anda dapat melihat hubungan positif antara variabel independen Anda, x dan variabel dependen Anda y.

Anda dapat mengamati, jika x = 1, y kira-kira akan sama dengan 6 dan jika x = 2, y akan menjadi sekitar 8,5.

Ini bukan metode yang sangat akurat dan rawan kesalahan, terutama dengan kumpulan data dengan ratusan ribu titik.

Regresi linier dievaluasi dengan persamaan. Variabel y dijelaskan oleh satu atau banyak kovariat. Dalam contoh Anda, hanya ada satu variabel dependen. Jika Anda harus menulis persamaan ini, itu akan menjadi:

Dengan:

  • adalah bobot yang terkait dengan x
  • adalah sisa atau kesalahan model. Ini mencakup apa yang model tidak dapat pelajari dari data

Bayangkan Anda cocok dengan modelnya dan Anda menemukan solusi berikut untuk:

  • = 3.8
  • = 2.78

Anda dapat mengganti angka-angka itu dalam persamaan dan itu menjadi:

y = 3,8 + 2,78x

Sekarang Anda memiliki cara yang lebih baik untuk mencari nilai y. Artinya, Anda dapat mengganti x dengan nilai apa pun yang ingin Anda prediksi y. Pada gambar di bawah, kami telah mengganti x dalam persamaan dengan semua nilai dalam dataset dan memplot hasilnya.

Garis merah menunjukkan nilai pas, yaitu nilai y untuk setiap nilai x. Anda tidak perlu melihat nilai x untuk memprediksi y, karena setiap x ada yang termasuk dalam garis merah. Anda juga dapat memprediksi nilai x yang lebih tinggi dari 2!

Jika Anda ingin memperluas regresi linier ke lebih banyak kovariat, Anda dapat dengan menambahkan lebih banyak variabel ke model. Perbedaan antara analisis tradisional dan regresi linier adalah regresi linier melihat bagaimana y akan bereaksi untuk setiap variabel x diambil secara independen.

Mari kita lihat contohnya. Bayangkan Anda ingin memprediksi penjualan sebuah toko es krim. Dataset berisi informasi yang berbeda seperti cuaca (yaitu hujan, cerah, mendung), informasi pelanggan (yaitu gaji, jenis kelamin, status perkawinan).

Analisis tradisional akan mencoba memprediksi penjualan dengan misalnya menghitung rata-rata untuk setiap variabel dan mencoba memperkirakan penjualan untuk skenario yang berbeda. Ini akan menyebabkan prediksi yang buruk dan membatasi analisis pada skenario yang dipilih.

Jika Anda menggunakan regresi linier, Anda dapat menulis persamaan ini:

Algoritme akan menemukan solusi terbaik untuk bobot; itu berarti akan mencoba meminimalkan biaya (perbedaan antara garis yang dipasang dan titik data).

Bagaimana algoritme bekerja

Algoritme akan memilih nomor acak untuk masing-masing dan mengganti nilai x untuk mendapatkan nilai prediksi dari y. Jika kumpulan data memiliki 100 pengamatan, algoritme menghitung 100 nilai prediksi.

Kita dapat menghitung kesalahan, mencatat modelnya, yang merupakan selisih antara nilai prediksi dan nilai sebenarnya. Kesalahan positif berarti model meremehkan prediksi y, dan kesalahan negatif berarti model melebih-lebihkan prediksi y.

Tujuan Anda adalah meminimalkan kuadrat kesalahan. Algoritme menghitung rata-rata kesalahan kuadrat. Langkah ini disebut minimisasi kesalahan. Untuk regresi linier adalah Mean Square Error , disebut juga MSE. Secara matematis, itu adalah:

Dimana:

  • mengacu pada nilai prediksi
  • y adalah nilai riil
  • m adalah jumlah observasi

Perhatikan bahwa adalah notasi matematis dari mean.

Tujuannya adalah untuk menemukan yang terbaik yang meminimalkan MSE

Jika kesalahan rata-rata besar, itu berarti model berkinerja buruk dan bobot tidak dipilih dengan benar. Untuk mengoreksi bobot, Anda perlu menggunakan pengoptimal. Pengoptimal tradisional disebut Gradient Descent .

Penurunan gradien mengambil turunan dan mengurangi atau menambah bobot. Jika turunannya positif, bobotnya diturunkan. Jika turunannya negatif, bobotnya bertambah. Model akan memperbarui bobot dan menghitung ulang kesalahannya. Proses ini diulangi sampai kesalahan tidak berubah lagi. Setiap proses disebut iterasi . Selain itu, gradien dikalikan dengan kecepatan pembelajaran. Ini menunjukkan kecepatan belajar.

Jika kecepatan pemelajaran terlalu kecil, akan membutuhkan waktu yang sangat lama untuk menyatukan algoritme (misalnya, membutuhkan banyak iterasi). Jika kecepatan pemelajaran terlalu tinggi, algoritme mungkin tidak akan pernah bertemu.

Anda dapat melihat dari gambar di atas, model mengulangi proses tersebut sekitar 20 kali sebelumnya untuk menemukan nilai bobot yang stabil, sehingga mencapai error yang paling rendah.

Perhatikan bahwa , kesalahan tidak sama dengan nol tetapi menstabilkan sekitar 5. Artinya, model membuat kesalahan tipikal 5. Jika Anda ingin mengurangi kesalahan, Anda perlu menambahkan lebih banyak informasi ke model seperti lebih banyak variabel atau menggunakan penduga yang berbeda.

Anda ingat persamaan pertama

Bobot terakhir adalah 3.8 dan 2.78. Video di bawah menunjukkan kepada Anda bagaimana penurunan gradien mengoptimalkan fungsi kerugian untuk menemukan bobot ini

Cara melatih Regresi Linier dengan TensorFlow

Sekarang setelah Anda memiliki pemahaman yang lebih baik tentang apa yang terjadi di balik terpal, Anda siap menggunakan API estimator yang disediakan oleh TensorFlow untuk melatih regresi linier pertama Anda menggunakan TensorFlow.

Anda akan menggunakan Boston Dataset, yang menyertakan variabel berikut

kejahatan tingkat kejahatan per kapita menurut kota
zn proporsi tanah tempat tinggal yang dikategorikan untuk bidang lebih dari 25.000 kaki persegi.
indus proporsi hektar bisnis non-ritel per kota.
nox konsentrasi oksida nitrat
rm jumlah rata-rata kamar per hunian
usia proporsi unit yang ditempati pemilik yang dibangun sebelum 1940
dis jarak tertimbang ke lima pusat kerja Boston
pajak tarif pajak properti nilai penuh per dolar 10.000
ptratio.dll rasio murid-guru menurut kota
medv Nilai median rumah yang ditempati pemilik dalam ribuan dolar

Anda akan membuat tiga set data berbeda:

Himpunan data objektif bentuk
Latihan Latih model dan dapatkan bobotnya 400, 10
Evaluasi Evaluasi kinerja model pada data yang tidak terlihat 100, 10
Meramalkan Gunakan model tersebut untuk memprediksi nilai rumah pada data baru 6, 10

Tujuannya adalah untuk menggunakan fitur set data untuk memprediksi nilai rumah.

Selama bagian kedua tutorial, Anda akan mempelajari cara menggunakan TensorFlow dengan tiga cara berbeda untuk mengimpor data:

  • Dengan Panda
  • Dengan Numpy
  • Hanya TF

Perhatikan bahwa, semua opsi memberikan hasil yang sama.

Anda akan mempelajari cara menggunakan API tingkat tinggi untuk membuat, melatih evaluasi model regresi linier TensorFlow. Jika Anda menggunakan API tingkat rendah, Anda harus menentukan sendiri:

  • Fungsi kerugian
  • Optimalkan: Penurunan gradien
  • Perkalian matriks
  • Grafik dan tensor

Ini membosankan dan lebih rumit untuk pemula.

Panda

Anda perlu mengimpor pustaka yang diperlukan untuk melatih model.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Langkah 1) Impor data dengan panda.

Anda menentukan nama kolom dan menyimpannya di COLUMNS. Anda dapat menggunakan pd.read_csv () untuk mengimpor data.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]

training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

Anda dapat mencetak bentuk datanya.

print(training_set.shape, test_set.shape, prediction_set.shape)

Keluaran

(400, 10) (100, 10) (6, 10)

Perhatikan bahwa label, yaitu y Anda, termasuk dalam kumpulan data. Jadi, Anda perlu menentukan dua daftar lainnya. Satu hanya berisi fitur dan satu lagi dengan nama labelnya saja. Kedua daftar ini akan memberi tahu penaksir Anda apa saja fitur dalam dataset dan nama kolom apa yang merupakan labelnya

Itu dilakukan dengan kode di bawah ini.

FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv"

Langkah 2) Konversi data

Anda perlu mengonversi variabel numerik dalam format yang tepat. Tensorflow menyediakan metode untuk mengonversi variabel kontinu: tf.feature_column.numeric_column ().

Pada langkah sebelumnya, Anda menentukan daftar fitur yang ingin Anda sertakan dalam model. Sekarang Anda dapat menggunakan daftar ini untuk mengubahnya menjadi data numerik. Jika Anda ingin mengecualikan fitur dalam model Anda, jangan ragu untuk melepaskan satu atau lebih variabel dalam daftar FITUR sebelum Anda membuat feature_cols

Perhatikan bahwa Anda akan menggunakan pemahaman daftar Python dengan daftar FITUR untuk membuat daftar baru bernama feature_cols. Ini membantu Anda menghindari menulis sembilan kali tf.feature_column.numeric_column (). Pemahaman daftar adalah cara yang lebih cepat dan lebih bersih untuk membuat daftar baru

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Langkah 3) Tentukan penduga

Pada langkah ini, Anda perlu menentukan estimatornya. Tensorflow saat ini menyediakan 6 estimator yang dibuat sebelumnya, termasuk 3 untuk tugas klasifikasi dan 3 untuk tugas regresi TensorFlow:

  • Regresor
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Penggolong
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

Dalam tutorial ini, Anda akan menggunakan Regresor Linier. Untuk mengakses fungsi ini, Anda perlu menggunakan tf.estimator.

Fungsi tersebut membutuhkan dua argumen:

  • feature_columns: Berisi variabel untuk disertakan dalam model
  • model_dir: jalur untuk menyimpan grafik, menyimpan parameter model, dll

Tensorflow secara otomatis akan membuat file bernama train di direktori kerja Anda. Anda perlu menggunakan jalur ini untuk mengakses Tensorboard seperti yang ditunjukkan pada contoh regresi TensorFlow di bawah ini.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")

Keluaran

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': '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}

Bagian rumit dengan TensorFlow adalah cara memberi makan model. Tensorflow dirancang untuk bekerja dengan komputasi paralel dan kumpulan data yang sangat besar. Karena keterbatasan sumber daya mesin, tidak mungkin untuk memberi makan model dengan semua data sekaligus. Untuk itu, Anda perlu memberi makan sekumpulan data setiap kali. Perhatikan bahwa, kita berbicara tentang kumpulan data besar dengan jutaan atau lebih catatan. Jika Anda tidak menambahkan batch, Anda akan mendapatkan error memori.

Misalnya, jika data Anda berisi 100 observasi dan Anda menentukan ukuran batch 10, itu berarti model akan melihat 10 observasi untuk setiap iterasi (10 * 10).

Jika model telah melihat semua data, model akan menyelesaikan satu periode . Epoch menentukan berapa kali Anda ingin model melihat data. Lebih baik menyetel langkah ini ke none dan membiarkan model melakukan jumlah waktu iterasi.

Informasi kedua yang ditambahkan adalah jika Anda ingin mengacak data sebelum setiap iterasi. Selama pelatihan, penting untuk mengacak data agar model tidak mempelajari pola spesifik dari kumpulan data tersebut. Jika model mempelajari detail pola yang mendasari data, model akan mengalami kesulitan untuk menggeneralisasi prediksi untuk data yang tidak terlihat. Ini disebut overfitting . Model tersebut bekerja dengan baik pada data pelatihan tetapi tidak dapat memprediksi dengan benar untuk data yang tidak terlihat.

TensorFlow membuat dua langkah ini mudah dilakukan. Saat data masuk ke pipeline, ia tahu berapa banyak observasi yang dibutuhkan (batch) dan apakah harus mengacak data.

Untuk menginstruksikan Tensorflow cara memberi makan model, Anda dapat menggunakan pandas_input_fn. Objek ini membutuhkan 5 parameter:

  • x: data fitur
  • y: data label
  • batch_size: batch. Secara default 128
  • num_epoch: Jumlah epoch, secara default 1
  • shuffle: Mengocok atau tidak data. Secara default, Tidak Ada

Anda perlu memberi makan model berkali-kali sehingga Anda menentukan fungsi untuk mengulangi proses ini. semua fungsi ini get_input_fn.

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)

Metode yang biasa digunakan untuk mengevaluasi kinerja model adalah dengan:

  • Latih modelnya
  • Evaluasi model dalam kumpulan data yang berbeda
  • Buat prediksi

Estimator Tensorflow menyediakan tiga fungsi berbeda untuk melakukan tiga langkah ini dengan mudah.

Langkah 4) : Latih modelnya

Anda dapat menggunakan rangkaian penduga untuk mengevaluasi model. Estimator kereta membutuhkan input_fn dan sejumlah langkah. Anda dapat menggunakan fungsi yang Anda buat di atas untuk memberi makan model. Kemudian, Anda menginstruksikan model untuk mengulang 1000 kali. Perhatikan bahwa, Anda tidak menentukan jumlah epoch, Anda membiarkan model melakukan iterasi 1000 kali. Jika Anda menyetel jumlah epoch ke 1, model akan berulang 4 kali: Ada 400 record dalam set pelatihan, dan ukuran batch adalah 128

  1. 128 baris
  2. 128 baris
  3. 128 baris
  4. 16 baris

Oleh karena itu, lebih mudah untuk menyetel jumlah epoch ke tidak ada dan menentukan jumlah iterasi seperti yang ditunjukkan di bawah contoh klasifikasi TensorFlow.

estimator.train(input_fn=get_input_fn(training_set,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 train/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.

Anda dapat memeriksa Tensorboard akan perintah berikut:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

Langkah 5) Evaluasi model Anda

Anda dapat mengevaluasi kesesuaian model Anda pada set pengujian dengan kode di bawah ini:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))

Keluaran

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Anda dapat mencetak kerugian dengan kode di bawah ini:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))

Keluaran

Loss: 3215.895996

Model mengalami kerugian 3215. Anda dapat memeriksa statistik ringkasan untuk mendapatkan gambaran tentang seberapa besar kesalahannya.

training_set['medv'].describe()

Keluaran

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

Dari ringkasan statistik diatas diketahui bahwa rata-rata harga sebuah rumah adalah 22 ribu dengan harga minimal 9 ribuan dan maksimal 50 ribu. Model membuat kesalahan tipikal sebesar 3k dolar.

Langkah 6) Buat prediksi

Terakhir, Anda dapat menggunakan penduga TensorFlow untuk memperkirakan nilai 6 rumah di Boston.

y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False))

Untuk mencetak nilai taksiran, Anda dapat menggunakan kode ini:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Keluaran

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Model memperkirakan nilai-nilai berikut:

Rumah

Ramalan

1

32.29

2

18.96

3

27.27

4

29.29

5

16.43

7

21.46

Perhatikan bahwa kami tidak mengetahui nilai sebenarnya dari. Dalam tutorial deep learning, Anda akan mencoba mengalahkan model linier

Solusi Numpy

Bagian ini menjelaskan cara melatih model menggunakan penaksir numpy untuk memasukkan data. Metode ini sama kecuali Anda akan menggunakan penaksir numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). nilai

test_set_n = pd.read_csv ("E: /boston_test.csv"). nilai

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). nilai

Langkah 1) Impor data

Pertama-tama, Anda perlu membedakan variabel fitur dari label. Anda perlu melakukan ini untuk data pelatihan dan evaluasi. Lebih cepat mendefinisikan fungsi untuk membagi data.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train

Anda dapat menggunakan fungsi tersebut untuk memisahkan label dari fitur set data train / evalu

X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)

Anda perlu mengecualikan kolom terakhir dari kumpulan data prediksi karena hanya berisi NaN

x_predict = prediction_set_n[:, :-2]

Konfirmasikan bentuk larik. Perhatikan bahwa label tidak boleh memiliki dimensi, itu berarti (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Keluaran

(400, 9) (400,) (6, 9)

Anda dapat membuat kolom fitur sebagai berikut:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Estimator didefinisikan seperti sebelumnya, Anda menginstruksikan kolom fitur dan di mana untuk menyimpan grafik.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Keluaran

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': '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}

Anda dapat menggunakan numpy estimapor untuk memasukkan data ke model, lalu melatih model tersebut. Perhatikan bahwa, kami mendefinisikan fungsi input_fn sebelumnya untuk memudahkan pembacaan.

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_train},y=y_train,batch_size=128,shuffle=False,num_epochs=None)estimator.train(input_fn = train_input,steps=5000)

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 train1/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.INFO:tensorflow:Loss for final step: 5925.985.Out[23]:

Anda mereplikasi langkah yang sama dengan penaksir berbeda untuk mengevaluasi model Anda

eval_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_test},y=y_test,shuffle=False,batch_size=128,num_epochs=1)estimator.evaluate(eval_input,steps=None)

Keluaran

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Akhirnya, Anda bisa menghitung prediksi. Ini harus serupa dengan panda.

test_input = tf.estimator.inputs.numpy_input_fn(x={"x": x_predict},batch_size=128,num_epochs=1,shuffle=False)y = estimator.predict(test_input)predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Keluaran

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Solusi Tensorflow

Bagian terakhir didedikasikan untuk solusi TensorFlow. Metode ini sedikit lebih rumit dari yang lain.

Perhatikan bahwa jika Anda menggunakan notebook Jupyter, Anda perlu Restart dan membersihkan kernel untuk menjalankan sesi ini.

TensorFlow telah membuat alat yang hebat untuk meneruskan data ke pipeline. Di bagian ini, Anda akan membangun fungsi input_fn sendiri.

Langkah 1) Tentukan jalur dan format data

Pertama-tama, Anda mendeklarasikan dua variabel dengan jalur file csv. Perhatikan bahwa, Anda memiliki dua file, satu untuk set pelatihan dan satu lagi untuk set pengujian.

import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"

Kemudian, Anda perlu menentukan kolom yang ingin Anda gunakan dari file csv. Kami akan menggunakan semuanya. Setelah itu, Anda perlu mendeklarasikan jenis variabelnya.

Variabel mengambang ditentukan oleh [0.]

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]

Langkah 2) Tentukan fungsi input_fn

Fungsinya dapat dibagi menjadi tiga bagian:

  1. Impor datanya
  2. Buat iterator
  3. Konsumsi datanya

Di bawah ini adalah kode keseluruhan untuk mendefinisikan fungsi tersebut. Kode akan dijelaskan setelahnya

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def parse_csv(value):columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)features = dict(zip(COLUMNS, columns))#labels = features.pop('median_house_value')labels = features.pop('medv')return features, labels# Extract lines from input files using theDataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file.skip(1) # Skip header row.map(parse_csv))dataset = dataset.repeat(num_epoch)dataset = dataset.batch(batch_size)# Step 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Impor data **

Untuk file csv, metode set data membaca satu baris dalam satu waktu. Untuk membuat kumpulan data, Anda perlu menggunakan objek TextLineDataset. Dataset Anda memiliki tajuk sehingga Anda perlu menggunakan lewati (1) untuk melewati baris pertama. Pada tahap ini, Anda hanya membaca data dan mengecualikan header di pipeline. Untuk memberi makan model, Anda perlu memisahkan fitur dari label. Metode yang digunakan untuk menerapkan transformasi apa pun ke data adalah peta.

Metode ini memanggil fungsi yang akan Anda buat untuk menginstruksikan cara mentransformasikan data. Singkatnya, Anda perlu meneruskan data di objek TextLineDataset, mengecualikan header dan menerapkan transformasi yang diinstruksikan oleh fungsi. Penjelasan kode

  • tf.data.TextLineDataset (data_file): Baris ini membaca file csv
  • .skip (1): lewati header
  • .map (parse_csv)): mengurai record menjadi tensorAnda perlu menentukan fungsi untuk menginstruksikan objek peta. Anda dapat memanggil fungsi ini parse_csv.

Fungsi ini mengurai file csv dengan metode tf.decode_csv dan mendeklarasikan fitur dan label. Fitur tersebut dapat dideklarasikan sebagai kamus atau tupel. Anda menggunakan metode kamus karena lebih nyaman. Penjelasan kode

  • tf.decode_csv (nilai, record_defaults = RECORDS_ALL): metode decode_csv menggunakan keluaran dari TextLineDataset untuk membaca file csv. record_defaults menginstruksikan TensorFlow tentang jenis kolom.
  • dict (zip (_CSV_COLUMNS, kolom)): Isi kamus dengan semua kolom yang diekstraksi selama pemrosesan data ini
  • features.pop ('median_house_value'): Kecualikan variabel target dari variabel fitur dan buat variabel label

Set Data membutuhkan elemen lebih lanjut untuk mengumpan Tensor secara berulang. Memang, Anda perlu menambahkan metode berulang untuk memungkinkan kumpulan data terus tanpa batas untuk memberi makan model. Jika Anda tidak menambahkan metode, model hanya akan melakukan iterasi satu kali, lalu menampilkan error karena tidak ada lagi data yang dimasukkan ke dalam pipeline.

Setelah itu, Anda dapat mengontrol ukuran batch dengan metode batch. Artinya, Anda memberi tahu kumpulan data berapa banyak data yang ingin Anda teruskan di pipeline untuk setiap iterasi. Jika Anda menyetel ukuran tumpukan besar, modelnya akan lambat.

Langkah 3) Buat iterator

Sekarang Anda siap untuk langkah kedua: buat iterator untuk mengembalikan elemen dalam dataset.

Cara paling sederhana untuk membuat operator adalah dengan metode make_one_shot_iterator.

Setelah itu, Anda dapat membuat fitur dan label dari iterator.

Langkah 4) Konsumsi data

Anda dapat memeriksa apa yang terjadi dengan fungsi input_fn. Anda perlu memanggil fungsi dalam satu sesi untuk menggunakan data. Anda coba dengan ukuran batch sama dengan 1.

Perhatikan bahwa, ini mencetak fitur dalam kamus dan label sebagai array.

Ini akan menampilkan baris pertama dari file csv. Anda dapat mencoba menjalankan kode ini berkali-kali dengan ukuran batch yang berbeda.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)with tf.Session() as sess:first_batch = sess.run(next_batch)print(first_batch)

Keluaran

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

Langkah 4) Tentukan kolom fitur

Anda perlu menentukan kolom numerik sebagai berikut:

X1= tf.feature_column.numeric_column('crim')X2= tf.feature_column.numeric_column('zn')X3= tf.feature_column.numeric_column('indus')X4= tf.feature_column.numeric_column('nox')X5= tf.feature_column.numeric_column('rm')X6= tf.feature_column.numeric_column('age')X7= tf.feature_column.numeric_column('dis')X8= tf.feature_column.numeric_column('tax')X9= tf.feature_column.numeric_column('ptratio')

Perhatikan bahwa Anda perlu menggabungkan semua variabel dalam satu keranjang

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Langkah 5) Bangun modelnya

Anda dapat melatih model dengan penaksir LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Keluaran

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': '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}

Anda perlu menggunakan fungsi lambda untuk memungkinkan menulis argumen dalam fungsi inpu_fn. Jika Anda tidak menggunakan fungsi lambda, Anda tidak bisa melatih modelnya.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

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 train3/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.Out[8]:

Anda dapat mengevaluasi kesesuaian model Anda pada set pengujian dengan kode di bawah ini:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))for key in results:print(" {}, was: {}".format(key, results[key]))

Keluaran

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

Langkah terakhir adalah memprediksi nilai berdasarkan nilai dari matriks fitur. Anda dapat menulis kamus dengan nilai yang ingin Anda prediksi. Model Anda memiliki 9 fitur sehingga Anda perlu memberikan nilai untuk masing-masing fitur. Model tersebut akan memberikan prediksi untuk masing-masingnya.

Pada kode di bawah ini, Anda menuliskan nilai dari setiap fitur yang terdapat pada file csv df_predict.

Anda perlu menulis fungsi input_fn baru karena tidak ada label di dataset. Anda dapat menggunakan API from_tensor dari Dataset.

prediction_input = {'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],'zn': [75.0,0.0,25.0,33.0,0.0,0.0],'indus': [2.95,18.10,5.13,2.18,18.10,9.90],'nox': [0.428,0.713,0.453,0.472,0.700,0.544],'rm': [7.024,6.297,6.762,7.236,5.390,5.782],'age': [15.8,91.8,43.4,41.1,98.9,71.7],'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],'tax': [252,666,284,222,666,304],'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]}def test_input_fn():dataset = tf.data.Dataset.from_tensors(prediction_input)return dataset# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)

Akhirnya, Anda mencetak prediksi.

for pred in enumerate(pred_results):print(pred)

Keluaran

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.(0, {'predictions': array([32.297546], dtype=float32)})(1, {'predictions': array([18.96125], dtype=float32)})(2, {'predictions': array([27.270979], dtype=float32)})(3, {'predictions': array([29.299236], dtype=float32)})(4, {'predictions': array([16.436684], dtype=float32)})(5, {'predictions': array([21.460876], dtype=float32)})INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

Ringkasan

Untuk melatih model, Anda perlu:

  • Definisikan fitur-fiturnya: Variabel independen: X
  • Tentukan labelnya: Variabel terikat: y
  • Buat set pelatihan / pengujian
  • Tentukan bobot awal
  • Tentukan fungsi kerugian: MSE
  • Optimalkan model: Penurunan gradien
  • Menetapkan:
    • Kecepatan pembelajaran
    • Jumlah periode
    • Ukuran batch

Dalam tutorial ini, Anda telah mempelajari cara menggunakan API tingkat tinggi untuk penaksir TensorFlow regresi linier. Anda perlu mendefinisikan:

  1. Kolom fitur. Jika kontinu: tf.feature_column.numeric_column (). Anda dapat mengisi daftar dengan pemahaman daftar python
  2. Estimator: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Sebuah fungsi untuk mengimpor data, ukuran batch dan epoch: input_fn ()

Setelah itu anda siap untuk melatih, mengevaluasi dan membuat prediksi dengan train (), evalu () dan predict ()