Regresi Linear dengan TensorFlow (Contoh)

Isi kandungan:

Anonim

Apa itu Regresi Linear?

Linear Regression adalah pendekatan dalam statistik untuk memodelkan hubungan antara dua pemboleh ubah. Pemodelan ini dilakukan antara tindak balas skalar dan satu atau lebih pemboleh ubah penjelasan. Hubungan dengan satu pemboleh ubah penjelasan disebut regresi linear sederhana dan untuk lebih dari satu pemboleh ubah penjelasan, ia disebut regresi linear berganda.

TensorFlow menyediakan alat untuk mengawal sepenuhnya pengiraan. Ini dilakukan dengan API tahap rendah. Selain itu, TensorFlow dilengkapi dengan pelbagai API untuk melakukan banyak algoritma pembelajaran mesin. Ini adalah API peringkat tinggi. TensorFlow memanggil mereka sebagai penganggar

  • API tahap rendah: Membina seni bina, mengoptimumkan model dari awal. Ini sukar bagi pemula
  • API tahap tinggi: Tentukan algoritma. Mesra mesra. TensorFlow menyediakan alat penganggar panggilan kotak alat untuk membina, melatih, menilai dan membuat ramalan.

Dalam tutorial ini, anda akan menggunakan penganggar sahaja . Pengiraannya lebih pantas dan lebih mudah dilaksanakan. Bahagian pertama tutorial menerangkan bagaimana menggunakan pengoptimum keturunan gradien untuk melatih regresi Linear di TensorFlow. Pada bahagian kedua, anda akan menggunakan set data Boston untuk meramalkan harga sebuah rumah menggunakan penganggar TensorFlow.

Muat turun Boston DataSet

Dalam tutorial TensorFlow Regression ini, anda akan belajar:

  • Apakah regresi Linear?
  • Cara melatih model regresi linear
  • Cara melatih Regresi Linear dengan TensorFlow
  • Panda
  • Penyelesaian Numpy
  • Penyelesaian Tensorflow

Cara melatih model regresi linear

Sebelum kita mula melatih model, mari kita lihat apa itu regresi linear.

Bayangkan anda mempunyai dua pemboleh ubah, x dan y dan tugas anda adalah untuk meramalkan nilai mengetahui nilai. Sekiranya anda memplot data, anda dapat melihat hubungan positif antara pemboleh ubah bebas anda, x dan pemboleh ubah bersandar anda y.

Anda mungkin melihat, jika x = 1, y kira-kira sama dengan 6 dan jika x = 2, y akan menjadi sekitar 8.5.

Ini bukan kaedah yang sangat tepat dan terdedah kepada ralat, terutamanya dengan set data dengan ratusan ribu mata.

Regresi linear dinilai dengan persamaan. Pemboleh ubah y dijelaskan oleh satu atau banyak kovariat. Dalam contoh anda, hanya ada satu pemboleh ubah bersandar. Sekiranya anda harus menulis persamaan ini, ia akan menjadi:

Dengan:

  • ialah berat yang berkaitan dengan x
  • adalah baki atau kesalahan model. Ini merangkumi apa yang model tidak dapat belajar dari data

Bayangkan anda sesuai dengan model dan anda mencari penyelesaian berikut untuk:

  • = 3.8
  • = 2.78

Anda boleh menggantikan nombor tersebut dalam persamaan dan ia menjadi:

y = 3.8 + 2.78x

Anda kini mempunyai kaedah yang lebih baik untuk mencari nilai untuk y. Maksudnya, anda boleh mengganti x dengan nilai yang anda mahu ramalkan y. Dalam gambar di bawah, kami telah menggantikan x dalam persamaan dengan semua nilai dalam set data dan plot hasilnya.

Garis merah mewakili nilai yang sesuai, iaitu nilai y untuk setiap nilai x. Anda tidak perlu melihat nilai x untuk meramalkan y, kerana setiap x ada yang termasuk dalam garis merah. Anda juga boleh meramalkan nilai x lebih tinggi daripada 2!

Sekiranya anda ingin memperluas regresi linier kepada lebih banyak kovariat, anda boleh dengan menambahkan lebih banyak pemboleh ubah pada model. Perbezaan antara analisis tradisional dan regresi linear adalah regresi linier melihat bagaimana y akan bertindak balas bagi setiap pemboleh ubah x yang diambil secara bebas.

Mari lihat contoh. Bayangkan anda ingin meramalkan penjualan sebuah kedai ais krim. Set data mengandungi maklumat yang berbeza seperti cuaca (seperti hujan, cerah, mendung), maklumat pelanggan (iaitu gaji, jantina, status perkahwinan).

Analisis tradisional akan cuba meramalkan penjualan dengan mengatakan mengira purata bagi setiap pemboleh ubah dan cuba menganggarkan penjualan untuk senario yang berbeza. Ini akan menyebabkan ramalan yang buruk dan menyekat analisis pada senario yang dipilih.

Sekiranya anda menggunakan regresi linear, anda boleh menulis persamaan ini:

Algoritma akan mencari penyelesaian terbaik untuk pemberat; itu bermaksud ia akan berusaha meminimumkan kos (perbezaan antara garis yang dipasang dan titik data).

Bagaimana algoritma berfungsi

Algoritma akan memilih nombor rawak untuk masing-masing dan menggantikan nilai x untuk mendapatkan nilai ramalan y. Sekiranya set data mempunyai 100 pemerhatian, algoritma akan mengira 100 nilai yang diramalkan.

Kita dapat mengira ralat, yang dicatat dari model, yang merupakan perbezaan antara nilai yang diramalkan dan nilai sebenarnya. Kesalahan positif bermaksud model meremehkan ramalan y, dan ralat negatif bermaksud model terlalu tinggi meramalkan ramalan y.

Matlamat anda adalah untuk mengurangkan titik kesalahan. Algoritma mengira nilai ralat kuasa dua. Langkah ini dipanggil pengurangan ralat. Untuk regresi linear adalah Error Square Square , juga disebut MSE. Secara matematik, ia adalah:

Di mana:

  • merujuk kepada nilai yang diramalkan
  • y adalah nilai sebenar
  • m ialah bilangan pemerhatian

Perhatikan itu adalah notasi matematik bagi min.

Tujuannya adalah untuk mencari yang terbaik yang dapat mengurangkan MSE

Sekiranya ralat rata-rata besar, ini bermaksud model berkinerja buruk dan beratnya tidak dipilih dengan betul. Untuk membetulkan bobot, anda perlu menggunakan pengoptimum. Pengoptimum tradisional dipanggil Gradient Descent .

Keturunan kecerunan mengambil turunan dan menurunkan atau menambah berat. Sekiranya turunannya positif, berat badan akan menurun. Sekiranya turunannya negatif, berat badan akan meningkat. Model akan mengemas kini bobot dan mengira ralat. Proses ini diulang sehingga ralat tidak berubah lagi. Setiap proses disebut lelaran . Selain itu, kecerunan dikalikan dengan kadar pembelajaran. Ini menunjukkan kepantasan pembelajaran.

Sekiranya kadar pembelajaran terlalu kecil, algoritma akan memerlukan masa yang sangat lama untuk disatukan (iaitu memerlukan banyak lelaran). Sekiranya kadar pembelajaran terlalu tinggi, algoritma mungkin tidak akan berkumpul.

Anda dapat melihat dari gambar di atas, model mengulangi proses kira-kira 20 kali sebelumnya untuk mencari nilai yang stabil untuk berat, oleh itu mencapai ralat terendah.

Perhatikan bahawa , kesalahan tidak sama dengan sifar tetapi stabil sekitar 5. Ini bermaksud, model membuat kesalahan tipikal 5. Sekiranya anda ingin mengurangkan ralat, anda perlu menambahkan lebih banyak maklumat pada model seperti lebih banyak pemboleh ubah atau penggunaan penganggar yang berbeza.

Anda ingat persamaan pertama

Berat akhir ialah 3.8 dan 2.78. Video di bawah menunjukkan kepada anda bagaimana keturunan kecerunan mengoptimumkan fungsi kerugian untuk mencari bobot ini

Cara melatih Regresi Linear dengan TensorFlow

Sekarang anda mempunyai pemahaman yang lebih baik mengenai apa yang berlaku di belakang tudung, anda sudah bersedia untuk menggunakan API penganggar yang disediakan oleh TensorFlow untuk melatih regresi linier pertama anda menggunakan TensorFlow.

Anda akan menggunakan Dataset Boston, yang merangkumi pemboleh ubah berikut

kelim kadar jenayah per kapita mengikut bandar
zn bahagian tanah kediaman yang dizonkan untuk kawasan seluas lebih daripada 25,000 kaki persegi.
indus bahagian ekar perniagaan bukan runcit setiap bandar.
nox kepekatan oksida nitrat
rm jumlah bilik rata-rata setiap kediaman
umur bahagian unit yang diduduki oleh pemilik yang dibina sebelum tahun 1940
dis jarak berwajaran ke lima pusat pekerjaan di Boston
cukai kadar cukai harta tanah bernilai penuh setiap dolar 10,000
ptratio nisbah murid-guru mengikut bandar
medv Nilai median rumah yang diduduki oleh pemilik dalam ribuan dolar

Anda akan membuat tiga set data yang berbeza:

set data objektif bentuk
Latihan Latih model dan dapatkan berat 400, 10
Penilaian Nilai prestasi model pada data yang tidak dapat dilihat 100, 10
Meramalkan Gunakan model untuk meramalkan nilai rumah pada data baru 6, 10

Objektifnya adalah menggunakan ciri set data untuk meramalkan nilai rumah.

Semasa bahagian kedua tutorial, anda akan belajar bagaimana menggunakan TensorFlow dengan tiga cara berbeza untuk mengimport data:

  • Dengan Pandas
  • Dengan Numpy
  • TF sahaja

Perhatikan bahawa, semua pilihan memberikan hasil yang sama.

Anda akan belajar bagaimana menggunakan API peringkat tinggi untuk membina, melatih menilai model regresi linear TensorFlow. Sekiranya anda menggunakan API tahap rendah, anda harus menentukan sendiri:

  • Kehilangan fungsi
  • Optimumkan: Keturunan kecerunan
  • Pendaraban matriks
  • Graf dan tensor

Ini membosankan dan lebih rumit untuk pemula.

Panda

Anda perlu mengimport perpustakaan yang diperlukan untuk melatih model.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Langkah 1) Import data dengan panda.

Anda menentukan nama lajur dan menyimpannya dalam COLUMNS. Anda boleh menggunakan pd.read_csv () untuk mengimport 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, nama = COLUMNS)

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

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

Anda boleh mencetak bentuk data.

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

Pengeluaran

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

Perhatikan bahawa label, iaitu y anda, termasuk dalam set data. Oleh itu, anda perlu menentukan dua senarai lain. Satu hanya mengandungi ciri dan satu dengan nama label sahaja. Kedua-dua senarai ini akan memberitahu penganggar anda apa ciri-ciri dalam set data dan nama lajur apa labelnya

Ia dilakukan dengan kod di bawah.

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

Langkah 2) Tukarkan data

Anda perlu menukar pemboleh ubah berangka dalam format yang betul. Tensorflow menyediakan kaedah untuk menukar pemboleh ubah berterusan: tf.feature_column.numeric_column ().

Pada langkah sebelumnya, anda menentukan senarai ciri yang ingin anda sertakan dalam model. Sekarang anda boleh menggunakan senarai ini untuk mengubahnya menjadi data berangka. Sekiranya anda ingin mengecualikan ciri dalam model anda, silakan masukkan satu atau lebih pemboleh ubah dalam senarai CIRI-CIRI sebelum anda membina fitur_cols

Perhatikan bahawa anda akan menggunakan pemahaman senarai Python dengan CIRI-CIRI senarai untuk membuat senarai baru bernama feature_cols. Ini membantu anda mengelakkan menulis sembilan kali tf.feature_column.numeric_column (). Pemahaman senarai adalah cara yang lebih cepat dan bersih untuk membuat senarai baru

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

Langkah 3) Tentukan penganggar

Dalam langkah ini, anda perlu menentukan penganggar. Tensorflow kini menyediakan 6 penganggar pra-binaan, termasuk 3 untuk tugas klasifikasi dan 3 untuk tugas regresi TensorFlow:

  • Penyesal
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Pengelas
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

Dalam tutorial ini, anda akan menggunakan Linear Regressor. Untuk mengakses fungsi ini, anda perlu menggunakan tf.estimator.

Fungsi memerlukan dua argumen:

  • feature_columns: Mengandungi pemboleh ubah untuk disertakan dalam model
  • model_dir: jalan untuk menyimpan grafik, menyimpan parameter model, dll

Tensorflow secara automatik akan membuat fail bernama train di direktori kerja anda. Anda perlu menggunakan jalan ini untuk mengakses Tensorboard seperti yang ditunjukkan dalam contoh regresi TensorFlow di bawah.

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

Pengeluaran

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}

Bahagian yang sukar dengan TensorFlow adalah cara memberi makan kepada model. Tensorflow direka untuk berfungsi dengan pengkomputeran selari dan set data yang sangat besar. Oleh kerana keterbatasan sumber mesin, mustahil untuk memberi makan model dengan semua data sekaligus. Untuk itu, anda perlu memberi banyak data setiap kali. Perhatikan bahawa, kita bercakap mengenai set data yang besar dengan berjuta-juta atau lebih rekod. Sekiranya anda tidak menambah kumpulan, anda akan mengalami kesalahan ingatan.

Sebagai contoh, jika data anda mengandungi 100 pemerhatian dan anda menentukan ukuran kumpulan 10, ini bermaksud model akan melihat 10 pemerhatian untuk setiap lelaran (10 * 10).

Apabila model telah melihat semua data, ia akan menyelesaikan satu zaman . Zaman menentukan berapa kali anda mahu model melihat data. Lebih baik menetapkan langkah ini menjadi tidak ada dan membiarkan model melakukan berulang kali.

Maklumat kedua untuk ditambahkan adalah jika anda ingin mengubah data sebelum setiap lelaran. Semasa latihan, adalah penting untuk mengacak data agar model tidak mempelajari corak set data tertentu. Sekiranya model mengetahui perincian corak data yang mendasari, ia akan mengalami kesukaran untuk menggeneralisasikan ramalan untuk data yang tidak terlihat. Ini dipanggil overfitting . Model menunjukkan prestasi yang baik pada data latihan tetapi tidak dapat meramalkan data yang tidak dapat dilihat dengan betul.

TensorFlow menjadikan dua langkah ini mudah dilakukan. Apabila data menuju ke saluran paip, ia akan mengetahui berapa banyak pemerhatian yang diperlukan (batch) dan jika harus mengacak data.

Untuk mengarahkan Tensorflow bagaimana memberi makan model, anda boleh menggunakan pandas_input_fn. Objek ini memerlukan 5 parameter:

  • x: data ciri
  • y: data label
  • batch_size: kumpulan. Secara lalai 128
  • num_epoch: Bilangan zaman, secara lalai 1
  • shuffle: Rombak atau tidak data. Secara lalai, Tiada

Anda perlu memberi makan model berulang 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)

Kaedah biasa untuk menilai prestasi model adalah dengan:

  • Latih model
  • Nilaikan model dalam set data yang berbeza
  • Buat ramalan

Tensorflow estimator menyediakan tiga fungsi yang berbeza untuk melaksanakan tiga langkah ini dengan mudah.

Langkah 4) : Latih model

Anda boleh menggunakan kereta penganggar untuk menilai model. Penganggar kereta api memerlukan input_fn dan beberapa langkah. Anda boleh menggunakan fungsi yang anda buat di atas untuk memberi makan model. Kemudian, anda memerintahkan model itu berulang sebanyak 1000 kali. Perhatikan bahawa, anda tidak menentukan bilangan zaman, anda membiarkan model itu berulang sebanyak 1000 kali. Sekiranya anda menetapkan bilangan zaman menjadi 1, maka model akan berulang sebanyak 4 kali: Terdapat 400 rekod dalam set latihan, dan ukuran kumpulan 128

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

Oleh itu, lebih mudah untuk menetapkan bilangan zaman menjadi tidak ada dan menentukan bilangan lelaran seperti yang ditunjukkan dalam 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)

Pengeluaran

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 boleh menyemak Tensorboard dengan arahan berikut:

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

Langkah 5) Nilaikan model anda

Anda boleh menilai kesesuaian model anda pada set ujian dengan kod di bawah:

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

Pengeluaran

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 boleh mencetak kerugian dengan kod di bawah:

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

Pengeluaran

Loss: 3215.895996

Model ini mengalami kerugian 3215. Anda dapat memeriksa statistik ringkasan untuk mendapatkan idea tentang seberapa besar ralat tersebut.

training_set['medv'].describe()

Pengeluaran

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

Dari ringkasan statistik di atas, anda tahu bahawa harga purata untuk sebuah rumah adalah 22 ribu, dengan harga minimum 9 ribu dan maksimum 50 ribu. Model itu membuat kesalahan tipikal sebanyak 3k dolar.

Langkah 6) Buat ramalan

Akhirnya, anda boleh menggunakan perkiraan TensorFlow untuk menganggar nilai 6 rumah Boston.

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

Untuk mencetak nilai anggaran, anda boleh menggunakan kod ini:

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

Pengeluaran

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 meramalkan nilai berikut:

rumah

Ramalan

1

32.29

2

18.96

3

27.27

4

29.29

5

16.43

7

21.46

Perhatikan bahawa kami tidak mengetahui nilai sebenarnya. Dalam tutorial pembelajaran mendalam, anda akan cuba mengalahkan model linear

Penyelesaian Numpy

Bahagian ini menerangkan cara melatih model menggunakan penganggar yang tidak kemas untuk memberi makan data. Kaedahnya adalah sama seperti 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.

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

Langkah 1) Import data

Pertama sekali, anda perlu membezakan pemboleh ubah ciri dari label. Anda perlu melakukan ini untuk data dan penilaian latihan. Lebih cepat menentukan fungsi untuk membelah data.

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

Anda boleh menggunakan fungsi untuk memisahkan label dari ciri kereta api / menilai set data

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

Anda perlu mengecualikan lajur terakhir kumpulan data ramalan kerana hanya mengandungi NaN

x_predict = prediction_set_n[:, :-2]

Sahkan bentuk tatasusunan. Perhatikan bahawa label tidak boleh dimensi, maksudnya (400,).

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

Pengeluaran

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

Anda boleh membina lajur ciri seperti berikut:

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

Penganggar ditentukan seperti sebelumnya, anda mengarahkan lajur ciri dan tempat menyimpan grafik.

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

Pengeluaran

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 boleh menggunakan estimapor numpy untuk memasukkan data ke model dan kemudian melatih modelnya. Perhatikan bahawa, kami menentukan fungsi input_fn sebelum 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)

Pengeluaran

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 meniru langkah yang sama dengan penganggar yang berbeza untuk menilai 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)

Pengeluaran

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 boleh mengira ramalan. Ia 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)))

Pengeluaran

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

Penyelesaian Tensorflow

Bahagian terakhir dikhaskan untuk penyelesaian TensorFlow. Kaedah ini lebih rumit daripada yang lain.

Perhatikan bahawa jika anda menggunakan notebook Jupyter, anda perlu Memulakan Semula dan membersihkan kernel untuk menjalankan sesi ini.

TensorFlow telah membina alat yang hebat untuk menyebarkan data ke saluran paip. Di bahagian ini, anda akan membina fungsi input_fn sendiri.

Langkah 1) Tentukan jalan dan format data

Pertama sekali, anda menyatakan dua pemboleh ubah dengan jalur fail csv. Perhatikan bahawa, anda mempunyai dua fail, satu untuk set latihan dan satu untuk set ujian.

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

Kemudian, anda perlu menentukan lajur yang ingin anda gunakan dari fail csv. Kami akan menggunakan semua. Selepas itu, anda perlu menyatakan jenis pemboleh ubahnya.

Pemboleh ubah apungan ditakrifkan 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

Fungsi boleh dibahagikan kepada tiga bahagian:

  1. Import data
  2. Buat iterator
  3. Gunakan data

Di bawah ini adalah kod overal untuk menentukan fungsi. Kod akan dijelaskan selepas

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

** Import data **

Untuk fail csv, kaedah set data membaca satu baris pada satu masa. Untuk membina set data, anda perlu menggunakan objek TextLineDataset. Set data anda mempunyai tajuk sehingga anda perlu menggunakan langkau (1) untuk melangkau baris pertama. Pada ketika ini, anda hanya membaca data dan mengecualikan header dalam perancangan. Untuk memberi makan model, anda perlu memisahkan ciri dari label. Kaedah yang digunakan untuk menerapkan transformasi ke data adalah peta.

Kaedah ini memanggil fungsi yang akan anda buat untuk memberi petunjuk bagaimana mengubah data. Ringkasnya, anda perlu meneruskan data dalam objek TextLineDataset, mengecualikan tajuk dan menerapkan transformasi yang diarahkan oleh fungsi.

  • tf.data.TextLineDataset (data_file): Baris ini membaca fail csv
  • .skip (1): langkau pengepala
  • .map (parse_csv)): menguraikan rekod ke dalam tensorAnda perlu menentukan fungsi untuk mengarahkan objek peta. Anda boleh memanggil fungsi ini parse_csv.

Fungsi ini menguraikan fail csv dengan kaedah tf.decode_csv dan menyatakan ciri dan label. Ciri-ciri tersebut dapat dinyatakan sebagai kamus atau tuple. Anda menggunakan kaedah kamus kerana lebih senang. Penjelasan kod

  • tf.decode_csv (nilai, record_defaults = RECORDS_ALL): kaedah decode_csv menggunakan output TextLineDataset untuk membaca fail csv. record_defaults mengarahkan TensorFlow mengenai jenis lajur.
  • dict (zip (_CSV_COLUMNS, lajur)): Isi kamus dengan semua lajur yang diekstrak semasa pemprosesan data ini
  • features.pop ('median_house_value'): Kecualikan pemboleh ubah sasaran dari pemboleh ubah ciri dan buat pemboleh ubah label

Dataset memerlukan elemen lebih lanjut untuk memberi makan secara berkala Tensor. Sesungguhnya, anda perlu menambahkan kaedah berulang untuk membolehkan set data berterusan selama-lamanya untuk memberi makan model. Sekiranya anda tidak menambahkan kaedah, model hanya akan berulang sekali dan kemudian menimbulkan ralat kerana tidak ada lagi data yang dimasukkan.

Selepas itu, anda boleh mengawal ukuran kumpulan dengan kaedah kumpulan. Ini bermaksud anda memberitahu kumpulan data berapa banyak data yang ingin anda lalui dalam perancangan untuk setiap lelaran. Sekiranya anda menetapkan saiz kumpulan yang besar, modelnya akan perlahan.

Langkah 3) Buat iterator

Sekarang anda sudah bersedia untuk langkah kedua: buat iterator untuk mengembalikan elemen dalam set data.

Kaedah termudah untuk membuat pengendali adalah dengan kaedah make_one_shot_iterator.

Selepas itu, anda boleh membuat ciri dan label dari iterator.

Langkah 4) Gunakan data

Anda boleh memeriksa apa yang berlaku dengan fungsi input_fn. Anda perlu memanggil fungsi dalam sesi untuk menggunakan data. Anda mencuba dengan ukuran kumpulan sama dengan 1.

Perhatikan bahawa, ia mencetak ciri dalam kamus dan label sebagai tatasusunan.

Ia akan menunjukkan baris pertama fail csv. Anda boleh menjalankan kod ini berkali-kali dengan ukuran kumpulan yang berbeza.

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)

Pengeluaran

({'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 lajur ciri

Anda perlu menentukan lajur angka seperti 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 bahawa anda perlu menggabungkan semua pemboleh ubah dalam baldi

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

Langkah 5) Bina model

Anda boleh melatih model dengan pengukur LinearRegressor.

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

Pengeluaran

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 membenarkan menulis argumen dalam fungsi inpu_fn. Sekiranya anda tidak menggunakan 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))

Pengeluaran

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 boleh menilai kesesuaian model anda pada set ujian dengan kod di bawah:

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

Pengeluaran

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 meramalkan nilai berdasarkan nilai, matriks ciri. Anda boleh menulis kamus dengan nilai yang ingin anda ramalkan. Model anda mempunyai 9 ciri, jadi anda perlu memberikan nilai untuk masing-masing. Model tersebut akan memberikan ramalan bagi setiap mereka.

Dalam kod di bawah, anda menuliskan nilai setiap ciri yang terdapat dalam fail csv df_predict.

Anda perlu menulis fungsi input_fn baru kerana tidak ada label dalam set data. Anda boleh 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 ramalan.

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

Pengeluaran

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:

  • 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

Dalam tutorial ini, anda belajar bagaimana menggunakan API tahap tinggi untuk penaksir regresi linear TensorFlow. 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.LinearRegressor (ciri_kolom, model_dir)
  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 ()