Tutorial Regresi Linier dengan TensorFlow [Contoh]
Evelyn Clarke
Apa itu Regresi Linier?
linear Regression adalah pendekatan dalam statistik untuk memodelkan hubungan antara dua variabel. Pemodelan ini dilakukan antara respon skalar dan satu atau lebih variabel penjelas. Hubungan satu variabel penjelas disebut regresi linier sederhana dan untuk lebih dari satu variabel penjelas disebut regresi linier berganda.
TensorFlow menyediakan alat untuk memiliki kontrol penuh atas komputasi. Hal ini dilakukan dengan API tingkat rendah. Selain itu, TensorFlow dilengkapi dengan beragam API untuk melakukan banyak hal Mesin belajar algoritma. Ini adalah API tingkat tinggi. TensorFlow menyebutnya sebagai estimator
- API tingkat rendah: Membangun arsitektur, optimasi model dari awal. Rumit untuk pemula
- API tingkat tinggi: Tentukan algoritmanya. Mudah digunakan. TensorFlow menyediakan kotak peralatan yang disebut penduga untuk membangun, melatih, mengevaluasi dan membuat prediksi.
Dalam tutorial ini, Anda akan menggunakan estimator saja. Perhitungannya lebih cepat dan lebih mudah diterapkan. Bagian pertama tutorial menjelaskan cara menggunakan pengoptimal penurunan gradien untuk melatih regresi Linier di TensorFlow. Di bagian kedua, Anda akan menggunakan dataset Boston untuk memprediksi harga rumah menggunakan estimator TensorFlow.
Cara melatih model regresi linier
Sebelum kita mulai melatih modelnya, mari kita lihat apa itu regresi linier.
Bayangkan Anda memiliki dua variabel, x dan y dan tugas Anda adalah memperkirakan nilai dengan mengetahui nilai . Jika Anda memplot data, Anda dapat melihat hubungan positif antara variabel independen, x dan variabel dependen y.
Anda dapat mengamati, jika x=1,y kira-kira sama dengan 6 dan jika x=2,y akan menjadi sekitar 8.5.
Ini bukanlah metode yang sangat akurat dan rawan kesalahan, terutama dengan kumpulan data yang memiliki ratusan ribu poin.
Regresi linier dievaluasi dengan persamaan. Variabel y dijelaskan oleh satu atau banyak kovariat. Dalam contoh Anda, hanya ada satu variabel terikat. Jika Anda harus menulis persamaan ini, hasilnya akan menjadi:
Dengan:
adalah biasnya. yaitu jika x=0, y=
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 model tersebut dan menemukan solusi berikut untuk:
- = 3.8
- = 2.78
Anda dapat mengganti angka-angka tersebut dalam persamaan dan hasilnya menjadi:
kamu= 3.8 + 2.78x
Anda sekarang memiliki cara yang lebih baik untuk menemukan nilai y. Artinya, Anda bisa mengganti x dengan nilai apa pun yang ingin Anda prediksi y. Pada gambar di bawah, kita mengganti x dalam persamaan dengan semua nilai dalam kumpulan data dan memplot hasilnya.
Garis merah melambangkan nilai yang dipasang, yaitu nilai y untuk setiap nilai x. Anda tidak perlu melihat nilai x untuk memprediksi y, untuk setiap x ada nilai yang termasuk dalam garis merah. Anda juga dapat memprediksi nilai x lebih tinggi dari 2!
Jika Anda ingin memperluas regresi linier ke lebih banyak kovariat, Anda dapat menambahkan lebih banyak variabel ke model. Perbedaan antara analisis tradisional dan regresi linier adalah regresi linier melihat bagaimana reaksi y terhadap setiap variabel x yang diambil secara independen.
Mari kita lihat sebuah contoh. Bayangkan Anda ingin memprediksi penjualan sebuah toko es krim. Dataset berisi informasi berbeda seperti cuaca (yaitu hujan, cerah, berawan), informasi pelanggan (yaitu gaji, jenis kelamin, status perkawinan).
Analisis tradisional akan mencoba memprediksi penjualan dengan menghitung rata-rata setiap variabel dan mencoba memperkirakan penjualan untuk skenario yang berbeda. Hal ini akan menghasilkan 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 tersebut; Artinya, ia akan berusaha meminimalkan biaya (perbedaan antara garis yang dipasang dan titik data).
Cara kerja algoritma
Algoritme akan memilih nomor acak untuk masing-masingnya 
dan 
dan ganti nilai x untuk mendapatkan nilai prediksi y. Jika kumpulan data memiliki 100 observasi, algoritme menghitung 100 nilai prediksi.
Kita bisa menghitung kesalahannya, catat 
model, yaitu 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 minimalisasi kesalahan. Untuk regresi linier adalah Kesalahan Kuadrat Rata-rata, juga disebut UMK. Secara matematis, itu adalah:
Dimana:
apakah bobotnya begitu 
mengacu pada nilai prediksi- y adalah nilai sebenarnya
- m adalah jumlah pengamatan
mengacu pada nilai prediksiPerhatikan bahwa 
berarti menggunakan transpos matriks. Itu 
adalah notasi matematika dari mean.
Tujuannya adalah untuk menemukan yang terbaik 
yang meminimalkan UMK
Jika kesalahan rata-ratanya besar, berarti kinerja model buruk dan bobot tidak dipilih dengan benar. Untuk memperbaiki bobot, Anda perlu menggunakan pengoptimal. Pengoptimal tradisional disebut Keturunan Gradien.
Penurunan gradien mengambil turunan dan menurunkan atau menambah bobot. Jika turunannya positif maka bobotnya berkurang. Jika turunannya negatif maka bobotnya bertambah. Model akan memperbarui bobot dan menghitung ulang kesalahannya. Proses ini diulangi hingga error tidak berubah lagi. Setiap proses disebut perulangan. Selain itu, gradien dikalikan dengan kecepatan pembelajaran. Ini menunjukkan kecepatan pembelajaran.
Jika kecepatan pemelajaran terlalu kecil, algoritma akan memerlukan waktu yang sangat lama untuk menyatu (yaitu memerlukan banyak iterasi). Jika kecepatan pemelajaran terlalu tinggi, algoritme mungkin tidak akan pernah konvergen.
Terlihat dari gambar di atas, model mengulangi proses tersebut sekitar 20 kali sebelumnya untuk menemukan nilai bobot yang stabil sehingga mencapai error terendah.
Perhatikan bahwa, kesalahannya tidak sama dengan nol tetapi stabil di sekitar 5. Artinya, model membuat kesalahan tipikal sebesar 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 akhir adalah 3.8 dan 2.78. Video di bawah ini 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 layar, Anda siap menggunakan API estimator yang disediakan oleh TensorFlow untuk melatih regresi linier pertama Anda menggunakan TensorFlow.
Anda akan menggunakan Dataset Boston, yang mencakup variabel berikut
| kejahatan | tingkat kejahatan per kapita menurut kota |
|---|---|
| zn | proporsi lahan perumahan yang dikategorikan untuk lahan seluas 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 tahun 1940 |
| dis | jarak tertimbang ke lima pusat ketenagakerjaan Boston |
| pajak | tarif pajak properti nilai penuh per dolar 10,000 |
| rasio | rasio murid-guru menurut kota |
| medv | Nilai median rumah yang ditempati pemilik dalam ribuan dolar |
Anda akan membuat tiga kumpulan data berbeda:
| kumpulan data | tujuan | bentuk |
|---|---|---|
| Pelatihan | 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 menggunakan fitur kumpulan data untuk memprediksi nilai rumah.
Pada bagian kedua tutorial, Anda akan mempelajari cara menggunakan TensorFlow dengan tiga cara berbeda untuk mengimpor data:
- Dengan Panda
- Dengan lumpuh
- Hanya TF
Perhatikan itu, semua opsi memberikan hasil yang sama.
Anda akan mempelajari cara menggunakan API tingkat tinggi untuk membangun, melatih, dan mengevaluasi model regresi linier TensorFlow. Jika Anda menggunakan API tingkat rendah, Anda harus mendefinisikan secara manual:
- Fungsi kerugian
- Optimalkan: Penurunan gradien
- Perkalian matriks
- Grafik dan tensor
Ini membosankan dan lebih rumit untuk pemula.
Panda
Anda perlu mengimpor perpustakaan yang diperlukan untuk melatih model.
import pandas as pd from sklearn import datasets import tensorflow as tf import 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=Benar,skiprows=1, nama=KOLOM)
test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=Benar,skiprows=1, nama=KOLOM)
prediksi_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, nama=COLUMNS)
Anda dapat mencetak bentuk data.
print(training_set.shape, test_set.shape, prediction_set.shape)
Keluaran
(400, 10) (100, 10) (6, 10)
Perhatikan bahwa labelnya, yaitu y Anda, disertakan dalam kumpulan data. Jadi, Anda perlu mendefinisikan dua daftar lainnya. Satu hanya berisi fitur dan satu lagi berisi nama labelnya saja. Kedua daftar ini akan memberi tahu estimator Anda apa saja fitur dalam kumpulan data dan nama kolom apa yang menjadi labelnya
Itu dilakukan dengan kode di bawah ini.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Langkah 2) Konversikan datanya
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, silakan hapus satu atau lebih variabel dalam daftar FEATURES sebelum Anda membuat feature_cols
Perhatikan bahwa Anda akan menggunakan Python pemahaman daftar dengan daftar FEATURES untuk membuat daftar baru bernama feature_cols. Ini membantu Anda menghindari penulisan sembilan kali tf.feature_column.numeric_column(). Pemahaman daftar adalah cara yang lebih cepat dan bersih untuk membuat daftar baru
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Langkah 3) Tentukan penduganya
Pada langkah ini, Anda perlu menentukan estimator. Tensorflow saat ini menyediakan 6 estimator bawaan, termasuk 3 untuk tugas klasifikasi dan 3 untuk tugas regresi TensorFlow:
- Regresor
- Regresor DNN
- Regresor Linier
- Regresor Gabungan DNNLinea
- menggolongkan
- Pengklasifikasi DNN
- Pengklasifikasi Linier
- Pengklasifikasi Gabungan DNNLinea
Dalam tutorial ini, Anda akan menggunakan Regresor Linier. Untuk mengakses fungsi ini, Anda perlu menggunakan tf.estimator.
Fungsi ini memerlukan dua argumen:
- feature_columns: Berisi variabel yang akan disertakan dalam model
- model_dir: jalur untuk menyimpan grafik, menyimpan parameter model, dll
Tensorflow akan secara otomatis 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.
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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_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 tersulit 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 memasukkan semua data ke model sekaligus. Untuk itu, Anda perlu memasukkan sejumlah data setiap saat. Perhatikan bahwa, kita berbicara tentang kumpulan data besar dengan jutaan catatan atau lebih. Jika Anda tidak menambahkan batch, Anda akan mengalami kesalahan 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).
Ketika model telah melihat semua data, model menyelesaikan satu data masa. Epoch menentukan berapa kali Anda ingin model melihat data. Lebih baik untuk menyetel langkah ini ke none dan membiarkan model melakukan iterasi beberapa kali.
Informasi kedua yang perlu ditambahkan adalah jika Anda ingin mengacak data sebelum setiap iterasi. Selama pelatihan, penting untuk mengacak data sehingga model tidak mempelajari pola tertentu dari kumpulan data. Jika model mempelajari detail pola dasar data, model akan kesulitan untuk menggeneralisasi prediksi untuk data yang tidak terlihat. Ini disebut terlalu pas. Model ini berperforma 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 mengetahui berapa banyak observasi yang diperlukan (batch) dan apakah data harus diacak.
Untuk memberikan instruksi kepada Tensorflow cara memberi makan model, Anda dapat menggunakan pandas_input_fn. Objek ini membutuhkan 5 parameter:
- x: data fitur
- y: data label
- ukuran_batch: kumpulan. Secara default 128
- num_epoch: Jumlah zaman, secara default 1
- shuffle: Mengacak atau tidak datanya. Secara default, Tidak Ada
Anda perlu memberi makan model berkali-kali sehingga Anda dapat 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 dilakukan untuk mengevaluasi kinerja suatu model adalah dengan:
- Latih modelnya
- Evaluasi model dalam kumpulan data yang berbeda
- Buat prediksi
Estimator Tensorflow menyediakan tiga fungsi berbeda untuk menjalankan tiga langkah ini dengan mudah.
Langkah 4): Melatih modelnya
Anda dapat menggunakan rangkaian estimator untuk mengevaluasi model. Estimator kereta memerlukan input_fn dan sejumlah langkah. Anda dapat menggunakan fungsi yang Anda buat di atas untuk memberi makan model. Kemudian, Anda menginstruksikan model untuk melakukan iterasi 1000 kali. Perhatikan bahwa, Anda tidak menentukan jumlah epoch, Anda membiarkan model melakukan iterasi 1000 kali. Jika Anda menetapkan jumlah epoch ke 1, maka model akan melakukan iterasi sebanyak 4 kali: Ada 400 catatan dalam set pelatihan, dan ukuran batch adalah 128
- 128 baris
- 128 baris
- 128 baris
- 16 baris
Oleh karena itu, lebih mudah untuk menyetel jumlah epoch ke none dan menentukan jumlah iterasi seperti yang ditunjukkan pada contoh klasifikasi TensorFlow di bawah ini.
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 = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO: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 dengan perintah berikut:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --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:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO: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 sebesar 3215. Anda dapat memeriksa statistik ringkasan untuk mendapatkan gambaran seberapa besar kesalahannya.
training_set['medv'].describe()
Keluaran
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Dari rangkuman statistik di atas, Anda tahu bahwa rata-rata harga sebuah rumah adalah 22 ribu, dengan harga minimal 9 ribu dan maksimal 50 ribu. Model ini membuat kesalahan umum sebesar 3 ribu dolar.
Langkah 6) Buatlah prediksinya
Terakhir, Anda dapat menggunakan penaksir prediksi 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 perkiraan nilai , 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-1000 INFO: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 tersebut meramalkan 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 kita tidak mengetahui nilai sebenarnya dari . Dalam tutorial pembelajaran mendalam, Anda akan mencoba mengalahkan model linier
Solusi Numpy
Bagian ini menjelaskan cara melatih model menggunakan estimator numpy untuk memasukkan data. Metodenya sama kecuali Anda akan menggunakan estimator 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
prediksi_set_n = pd.read_csv(“E:/boston_predict.csv”).nilai
Langkah 1) Impor data
Pertama-tama, Anda perlu membedakan variabel fitur dari labelnya. 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 ini untuk memisahkan label dari fitur kumpulan data pelatihan/evaluasi
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 array. Perhatikan bahwa label tidak boleh memiliki dimensi, artinya (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 tempat 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_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 estimasi numpy untuk memasukkan data ke model dan kemudian melatih model tersebut. Perhatikan bahwa, kami mendefinisikan fungsi input_fn sebelumnya untuk memudahkan keterbacaan.
# 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 = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO: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]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Anda mereplikasi langkah yang sama dengan estimator 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:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Terakhir, Anda dapat menghitung prediksinya. Seharusnya sama 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-1000 INFO: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 dibandingkan metode lainnya.
Perhatikan bahwa jika Anda menggunakan Jupyter buku catatan, Anda perlu Restart dan bersihkan kernel untuk menjalankan sesi ini.
TensorFlow telah membangun alat yang hebat untuk meneruskan data ke dalam pipeline. Di bagian ini, Anda akan membuat sendiri fungsi input_fn.
Langkah 1) Tentukan jalur dan format data
Pertama-tama, Anda mendeklarasikan dua variabel dengan path 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 float 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 dipecah menjadi tiga bagian:
- Impor data
- Buat iteratornya
- Konsumsi datanya
Di bawah ini adalah kode keseluruhan untuk mendefinisikan fungsi. Kode akan dijelaskan setelahnya
def input_fn(data_file, batch_size, num_epoch = None):
# Step 1
def 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 the
Dataset 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 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
** Impor data**
Untuk file csv, metode kumpulan data membaca satu baris dalam satu waktu. Untuk membangun kumpulan data, Anda perlu menggunakan objek TextLineHimpunan data. Kumpulan data Anda memiliki header sehingga Anda perlu menggunakan skip(1) untuk melewati baris pertama. Pada titik ini, Anda hanya membaca data dan mengecualikan header di saluran. Untuk memberi makan model, Anda perlu memisahkan fitur dari label. Metode yang digunakan untuk menerapkan transformasi apa pun pada data adalah peta.
Metode ini memanggil fungsi yang akan Anda buat untuk menginstruksikan cara mengubah data. Singkatnya, Anda perlu meneruskan data ke dalam TextLineObjek kumpulan data, kecualikan header dan terapkan 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 catatan ke dalam tensorAnda perlu mendefinisikan fungsi untuk menginstruksikan objek peta. Anda dapat memanggil fungsi ini parse_csv.
Fungsi ini mengurai berkas csv dengan metode tf.decode_csv dan mendeklarasikan fitur dan label. Fitur dapat dideklarasikan sebagai kamus atau tupel. Anda menggunakan metode kamus karena lebih praktis. Penjelasan kode
- tf.decode_csv(value, record_defaults= RECORDS_ALL): metode decode_csv menggunakan output dari TextLineKumpulan data untuk membaca file csv. record_defaults menginstruksikan TensorFlow tentang tipe kolom.
- dict(zip(_CSV_COLUMNS, kolom)): Isi kamus dengan semua kolom yang diekstraksi selama pemrosesan data ini
- fitur.pop('median_house_value'): Kecualikan variabel target dari variabel fitur dan buat variabel label
Set Data memerlukan elemen lebih lanjut untuk memberi makan Tensor secara berulang. Memang benar, Anda perlu menambahkan metode pengulangan agar kumpulan data dapat terus berlanjut tanpa batas waktu untuk memberi makan model. Jika Anda tidak menambahkan metode ini, model hanya akan mengulangi satu kali dan kemudian menimbulkan kesalahan karena tidak ada lagi data yang dimasukkan ke dalam alur.
Setelah itu, Anda dapat mengontrol ukuran batch dengan metode batch. Artinya, Anda memberi tahu kumpulan data berapa banyak data yang ingin Anda teruskan dalam alur untuk setiap iterasi. Jika Anda menetapkan ukuran batch yang besar, modelnya akan lambat.
Langkah 3) Buat iteratornya
Sekarang Anda siap untuk langkah kedua: buat iterator untuk mengembalikan elemen dalam kumpulan data.
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 datanya
Anda dapat memeriksa apa yang terjadi dengan fungsi input_fn. Anda perlu memanggil fungsi dalam suatu sesi untuk menggunakan data. Anda mencoba dengan ukuran batch sama dengan 1.
Perhatikan bahwa, ini mencetak fitur dalam kamus dan label sebagai array.
Ini akan menampilkan baris pertama 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 mendefinisikan 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 model
Anda dapat melatih model dengan estimator 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_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 mengizinkan penulisan argumen di fungsi input_fn. Jika Anda tidak menggunakan a fungsi lambda, Anda tidak dapat 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 = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO: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]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
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:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
Langkah terakhir adalah memprediksi nilai berdasarkan nilai , 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 setiap fitur yang terdapat dalam 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)
Terakhir, Anda mencetak prediksinya.
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-1000
INFO: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:
- Tentukan ciri-cirinya: Variabel bebas: X
- Tentukan labelnya: Variabel terikat: y
- Buatlah set kereta/ujian
- Tentukan berat awal
- Tentukan fungsi kerugian: MSE
- Optimalkan model: Penurunan gradien
- Menetapkan:
- Tingkat belajar
- Jumlah zaman
- Ukuran batch
Dalam tutorial ini, Anda mempelajari cara menggunakan API tingkat tinggi untuk estimator TensorFlow regresi linier. Anda perlu mendefinisikan:
- Kolom fitur. Jika berkelanjutan: tf.feature_column.numeric_column(). Anda dapat mengisi daftar dengan pemahaman daftar python
- Penaksir: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Fungsi untuk mengimpor data, ukuran batch dan zaman: input_fn()
Setelah itu, Anda siap untuk melatih, mengevaluasi, dan membuat prediksi dengan train(), evaluasi(), dan prediksi()
