Tutorial Regresi Linier dengan TensorFlow [Contoh]

⚡ Ringkasan Cerdas

Regresi Linier di TensorFlow memodelkan hubungan antara fitur numerik dan nilai target kontinu. Panduan ini melatih prediktor harga rumah di Boston dengan tiga cara berbeda, menggunakan Pandas, NumPy, dan pipeline input TensorFlow asli dengan estimator LinearRegressor.

  • 🔘 Bentuk model: Regresi linier sesuai dengan y = bias + bobot × x, yang diperluas dengan lebih banyak kovariat untuk masalah multivariat.
  • ☑️ Siklus pelatihan: Gradient descent menyesuaikan bobot pada setiap iterasi hingga Mean Square Error berhenti menurun.
  • ✅ API Estimator: LinearRegressor hanya membutuhkan kolom fitur, direktori model, dan fungsi input.
  • 🧪 Tiga jalur pipa: Dataset Pandas, NumPy, dan TensorFlow asli digunakan pada model yang sama dan menghasilkan prediksi yang identik.
  • ️ Contoh yang dikerjakan: Sembilan fitur Boston memprediksi nilai rumah rata-rata dan mencapai kerugian pengujian sebesar 3215.
  • ⚠️ Realita versi: Estimator sudah usang di TensorFlow 2.12 dan dihapus di 2.16, jadi pindahkan pekerjaan baru ke Keras.

Regresi Linier dengan TensorFlow

Apa itu Regresi Linier?

linear Regression Regresi linier adalah 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 dengan 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, dan TensorFlow menyebutnya sebagai estimator.

  • API tingkat rendahMembangun arsitektur dan optimasi model dari awal. Ini rumit bagi pemula.
  • API tingkat tinggiJelaskan algoritmanya. Algoritma ini mudah digunakan. TensorFlow menyediakan toolbox yang disebut... penduga untuk membangun, melatih, mengevaluasi dan membuat prediksi.

Dalam tutorial ini, Anda akan menggunakan estimator sajaPerhitungannya lebih cepat dan lebih mudah diimplementasikan. Bagian pertama menjelaskan cara menggunakan pengoptimal penurunan gradien untuk melatih regresi linier di TensorFlow. Pada bagian kedua, Anda akan menggunakan dataset Boston untuk memprediksi harga rumah menggunakan estimator TensorFlow.

Unduh Kumpulan Data Boston

Cara melatih model regresi linier

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

Bayangkan Anda memiliki dua variabel, x dan y, dan tugas Anda adalah memprediksi nilai y dengan mengetahui nilai x. Jika Anda memplot data tersebut, Anda dapat melihat hubungan positif antara variabel independen Anda, x, dan variabel dependen Anda, y, seperti yang ditunjukkan oleh diagram sebar di bawah ini.

Diagram sebaran x terhadap y menunjukkan hubungan linier positif.

Anda dapat mengamati bahwa jika x=1, maka y akan kurang lebih sama dengan 6, dan jika x=2, maka y akan sekitar 8.5.

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

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:

Persamaan regresi linier sederhana dengan bias, bobot, dan suku kesalahan.

Dengan:

  • Simbol koefisien bias adalah biasnya. Artinya, jika x=0, maka y=Nilai koefisien bias ketika x sama dengan nol
  • Simbol koefisien bobot yang terkait dengan x adalah berat yang terkait dengan x
  • Simbol istilah kesalahan residual Residual adalah kesalahan model. Ini mencakup apa yang tidak dapat dipelajari model dari data.

Bayangkan Anda cocok dengan model tersebut dan menemukan solusi berikut untuk:

  • Koefisien bias yang sesuai sama dengan 3.8 = 3.8
  • Koefisien bobot yang sesuai sama dengan 2.78 = 2.78

Anda dapat mengganti angka-angka tersebut dalam persamaan dan hasilnya menjadi:

kamu= 3.8 + 2.78x

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

Garis regresi yang sesuai digambar dengan warna merah melalui titik-titik data yang diplot.

Garis merah mewakili nilai yang sesuai, yaitu nilai y untuk setiap nilai x. Anda tidak perlu melihat nilai x untuk memprediksi y; untuk setiap x terdapat nilai yang sesuai dengan garis merah. Anda juga dapat memprediksi untuk nilai x yang lebih besar dari 2.

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

Mari kita lihat sebuah contoh. Bayangkan Anda ingin memprediksi penjualan toko es krim. Dataset tersebut berisi berbagai informasi seperti cuaca (hujan, cerah, berawan) dan informasi pelanggan (gaji, jenis kelamin, status perkawinan).

Analisis tradisional akan mencoba memprediksi penjualan dengan, misalnya, menghitung rata-rata untuk setiap variabel dan mencoba memperkirakan penjualan untuk berbagai skenario. Hal ini akan menghasilkan prediksi yang kurang akurat dan membatasi analisis pada skenario yang dipilih.

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

Persamaan regresi linier berganda yang menggabungkan beberapa kovariat berbobot.

Algoritma akan menemukan solusi terbaik untuk bobot; artinya algoritma akan mencoba meminimalkan biaya, yaitu selisih antara garis yang dipasang dan titik data.

Cara kerja algoritma

Diagram di bawah ini merangkum siklus yang diulang oleh algoritma: memilih bobot, memprediksi y, mengukur kesalahan, dan mengoreksi bobot.

Diagram alur dari siklus pelatihan regresi linier dari bobot acak hingga kesalahan yang diminimalkan.

Algoritme akan memilih nomor acak untuk masing-masingnya Koefisien bias yang diinisialisasi secara acak ke Koefisien bobot yang diinisialisasi secara acak 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 Istilah kesalahan model yang digunakan dalam perhitungan kerugian, dari model tersebut, yang merupakan perbedaan antara nilai prediksi dan nilai sebenarnya. Kesalahan positif berarti model meremehkan prediksi y, dan kesalahan negatif berarti model melebih-lebihkan prediksi y.

Tujuan minimisasi kesalahan kuadrat yang ditulis dalam notasi matematika.

Tujuan Anda adalah meminimalkan kuadrat kesalahan. Algoritma menghitung rata-rata kuadrat kesalahan. Langkah ini disebut minimisasi kesalahan. Untuk regresi linier, ini adalah Kesalahan Kuadrat Rata-rata, juga disebut UMK. Secara matematis, itu adalah:

Rumus Mean Square Error yang ditulis dalam notasi matriks

Dimana:

  • Simbol vektor bobot yang digunakan dalam rumus MSE adalah bobotnya, jadi Notasi nilai prediksi yang digunakan dalam rumus MSE mengacu pada nilai prediksi
  • y adalah nilai sebenarnya
  • m adalah jumlah pengamatan

Perhatikan bahwa Notasi matriks bobot yang ditransposkan berarti menggunakan transpos matriks. Itu Notasi penjumlahan dan rata-rata yang digunakan dalam rumus MSE. adalah notasi matematika dari mean.

Tujuannya adalah untuk menemukan yang terbaik Simbol bobot optimal yang meminimalkan MSE. yang meminimalkan MSE.

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.

Gradient descent mengambil turunan dan mengurangi atau menambah bobot. Jika turunannya positif, bobot dikurangi. Jika turunannya negatif, bobot ditambah. Model akan memperbarui bobot dan menghitung ulang kesalahan. Proses ini diulang sampai kesalahan tidak berubah lagi. Setiap tahapan disebut satu siklus. perulanganSelain itu, gradien dikalikan dengan laju pembelajaran, yang menunjukkan kecepatan pembelajaran.

Jika laju pembelajaran terlalu kecil, algoritma akan membutuhkan waktu yang sangat lama untuk konvergen, karena memerlukan lebih banyak iterasi. Jika laju pembelajaran terlalu tinggi, algoritma mungkin tidak akan pernah konvergen. Kurva kerugian di bawah ini memplot kesalahan terhadap jumlah iterasi untuk dataset ini.

Kurva kerugian menunjukkan kesalahan menurun dan stabil setelah sekitar dua puluh iterasi.

Anda dapat melihat dari gambar di atas bahwa model tersebut mengulangi proses sekitar 20 kali sebelum menemukan nilai stabil untuk bobot, sehingga mencapai kesalahan terendah.

Perhatikan bahwa kesalahan tidak sama dengan nol tetapi stabil di sekitar 5. Ini berarti model tersebut membuat kesalahan tipikal sebesar 5. Jika Anda ingin mengurangi kesalahan, Anda perlu menambahkan lebih banyak informasi ke model, seperti lebih banyak variabel, atau menggunakan estimator yang berbeda.

Anda ingat persamaan pertama:

Persamaan regresi linier akhir yang sesuai dengan bobot yang telah dipecahkan.

Bobot akhirnya adalah 3.8 dan 2.78. Video di bawah ini menunjukkan 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.

Catatan versi: Alur kerja estimator yang ditunjukkan di bawah ini ditulis berdasarkan TensorFlow 1.x dan rilis awal 2.x. TensorFlow menandai tf.estimator ke tf.feature_column API sepenuhnya dihentikan penggunaannya di versi 2.12 dan Estimator dihilangkan di versi 2.16. Pada instalasi terbaru, jalankan kode ini di dalam TensorFlow 1.15 atau 2.x-with-tf.compat.v1 lingkungan, atau memindahkannya ke Keras, di mana tf.keras.layers.Dense(1) Selain itu, lapisan pra-pemrosesan menggantikan LinearRegressor dan kolom fitur. Konsep-konsepnya — fitur, label, batch, epoch, MSE, dan penurunan gradien — tetap sama.

Anda akan menggunakan Boston Dataset, yang mencakup variabel-variabel berikut.

Variabel Deskripsi
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

Tujuan dari metode ini adalah menggunakan fitur-fitur dalam dataset untuk memprediksi nilai rumah.

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

  • Dengan Panda
  • Dengan JumlahPy
  • Hanya TensorFlow

Perhatikan bahwa ketiga opsi tersebut 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
  • Pengoptimal: penurunan gradien
  • perkalian matriks
  • Grafik dan tensor

Ini membosankan dan lebih rumit bagi pemula.

Solusi Pandas

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 dalam variabel COLUMNS. Anda dapat menggunakan pd.read_csv() untuk mengimpor data.

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

Arahkan setiap panggilan ke file CSV yang telah Anda unduh sebelumnya.

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 data.

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 dataset. Jadi Anda perlu mendefinisikan dua daftar lain: satu hanya berisi fitur, dan satu lagi hanya berisi nama label. Kedua daftar ini akan memberi tahu estimator Anda fitur apa saja yang ada dalam dataset dan nama kolom mana yang merupakan label.

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 mengkonversi variabel numerik ke format yang tepat. TensorFlow menyediakan metode untuk mengkonversi variabel kontinu: tf.feature_column.numeric_column().

Pada langkah sebelumnya, Anda telah mendefinisikan daftar fitur yang ingin Anda sertakan dalam model. Sekarang Anda dapat menggunakan daftar ini untuk mengubahnya menjadi data numerik. Jika Anda ingin mengecualikan fitur dari model Anda, silakan hapus satu atau lebih variabel dari daftar FEATURES sebelum Anda membuat feature_cols.

Perhatikan bahwa Anda akan menggunakan Python Gunakan list comprehension dengan list FEATURES untuk membuat list baru bernama feature_cols. Ini membantu Anda menghindari penulisan tf.feature_column.numeric_column() sebanyak sembilan kali. List comprehension adalah cara yang lebih cepat dan lebih rapi untuk membuat list baru.

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

Langkah 3) Tentukan penduganya

Pada langkah ini, Anda perlu mendefinisikan estimator. TensorFlow menyediakan enam estimator bawaan, tiga untuk tugas klasifikasi dan tiga untuk tugas regresi TensorFlow:

  • Regresor
    • Regresor DNN
    • Regresor Linier
    • DNNLinearCombinedRegressor
  • menggolongkan
    • Pengklasifikasi DNN
    • Pengklasifikasi Linier
    • Pengklasifikasi Gabungan DNNLinear

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-variabel yang akan disertakan dalam model.
  • model_dir: jalur untuk menyimpan grafik, menyimpan parameter model, dan sebagainya.

TensorFlow akan secara otomatis membuat folder bernama train di direktori kerja Anda. Anda perlu menggunakan jalur ini untuk mengaksesnya. Papan Tensor, 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': <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 yang rumit dengan TensorFlow adalah cara memasukkan data ke model. TensorFlow dirancang untuk bekerja dengan komputasi paralel dan kumpulan data yang sangat besar. Karena keterbatasan sumber daya mesin, tidak mungkin untuk memasukkan semua data ke model sekaligus. Untuk itu, Anda perlu memasukkan sejumlah data setiap kali. Perhatikan bahwa kita berbicara tentang kumpulan data yang sangat besar dengan jutaan atau lebih catatan. Jika Anda tidak menambahkan data secara bertahap, 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).

Setelah model melihat semua data, ia menyelesaikan satu epoch. Epoch mendefinisikan berapa kali Anda ingin model melihat data. Lebih baik mengatur langkah ini menjadi "none" dan membiarkan model melakukan sejumlah iterasi yang telah ditentukan.

Informasi kedua yang perlu ditambahkan adalah apakah Anda ingin mengacak data sebelum setiap iterasi. Selama pelatihan, penting untuk mengacak data agar model tidak mempelajari pola spesifik dari dataset. Jika model mempelajari detail pola data yang mendasarinya, model akan kesulitan menggeneralisasi prediksi untuk data yang belum pernah dilihat sebelumnya. Ini disebut overfitting. Model berkinerja baik pada data pelatihan tetapi tidak dapat memprediksi dengan benar untuk data yang belum pernah dilihat sebelumnya.

TensorFlow mempermudah kedua langkah ini. Saat data masuk ke pipeline, ia mengetahui berapa banyak observasi yang dibutuhkan (batch) dan apakah data tersebut perlu diacak.

Untuk memberi tahu TensorFlow cara memasukkan data ke model, Anda dapat menggunakan pandas_input_fn. Objek ini membutuhkan lima parameter:

  • x: data fitur
  • y: data label
  • ukuran_batch: kumpulan. Secara default 128
  • num_epoch: jumlah epoch, secara default 1
  • shuffle: mengacak data atau tidak. Secara default, None

Anda perlu memasukkan data ke model berkali-kali, jadi Anda mendefinisikan sebuah fungsi untuk mengulangi proses ini. Sebut 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 tersebut pada dataset yang berbeda.
  • Buatlah prediksi

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

Langkah 4) Latih modelnya

Anda dapat menggunakan metode pelatihan estimator untuk menyesuaikan model. Estimator pelatihan membutuhkan input_fn dan sejumlah langkah. Anda dapat menggunakan fungsi yang Anda buat di atas untuk memasukkan data ke model. Kemudian Anda menginstruksikan model untuk melakukan iterasi sebanyak 1000 kali. Perhatikan bahwa Anda tidak menentukan jumlah epoch; Anda membiarkan model melakukan iterasi sebanyak 1000 kali. Jika Anda mengatur jumlah epoch menjadi 1, maka model akan melakukan iterasi empat kali, karena ada 400 data 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 mengatur jumlah epoch menjadi nol 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 tersebut memiliki 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 statistik ringkasan di atas, Anda tahu bahwa harga rata-rata rumah adalah 22 ribu, dengan harga minimum 5 ribu dan maksimum 50 ribu. Karena kerugian yang dilaporkan adalah kesalahan kuadrat rata-rata, kesalahan tipikal dalam satuan aslinya kira-kira akar kuadrat dari 32.16, yaitu sekitar 5.7 ribu dolar.

Langkah 6) Buatlah prediksinya

Terakhir, Anda dapat menggunakan metode estimasi TensorFlow predict untuk memperkirakan nilai enam rumah di Boston.

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

Untuk mencetak nilai estimasi, 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 ini memprediksi nilai-nilai berikut:

Rumah Ramalan
1 32.29
2 18.96
3 27.27
4 29.29
5 16.43
6 21.46

Perlu dicatat bahwa kita tidak mengetahui nilai sebenarnya dari keenam rumah ini. 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.

Baca ketiga file CSV yang sama, tetapi hanya simpan array NumPy mentah dengan akhiran .values.

training_set_n = pd.read_csv("E:/boston_train.csv").values
test_set_n = pd.read_csv("E:/boston_test.csv").values
prediction_set_n = pd.read_csv("E:/boston_predict.csv").values

Langkah 1) Impor data

Pertama-tama, Anda perlu membedakan variabel fitur dari label. Anda perlu melakukan ini untuk data pelatihan dan data evaluasi. Akan lebih cepat jika Anda mendefinisikan fungsi untuk memisahkan 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-fitur dataset pelatihan dan 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 dataset prediksi karena kolom tersebut hanya berisi NaN.

x_predict = prediction_set_n[:, :-2]

Konfirmasikan bentuk array. Perhatikan bahwa label tidak boleh memiliki dimensi kedua, yang 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 menentukan 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 estimator NumPy untuk memasukkan data ke dalam model dan kemudian melatih model tersebut. Perhatikan bahwa kami mendefinisikan fungsi input_fn terlebih dahulu untuk memudahkan pembacaan.

# Train the estimator
train_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 mengulangi langkah yang sama dengan fungsi input yang 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. Hasilnya seharusnya mirip dengan hasil Pandas.

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 dikhususkan untuk sesuatu yang murni. TensorFlow solusi. Metode ini sedikit lebih rumit daripada dua metode lainnya.

Perhatikan bahwa jika Anda menggunakan Jupyter buku catatanAnda perlu memulai ulang dan membersihkan kernel untuk menjalankan sesi ini.

TensorFlow telah membangun alat yang hebat untuk memasukkan data ke dalam 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 untuk set pengujian.

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

Kemudian, Anda perlu menentukan kolom-kolom yang ingin Anda gunakan dari file CSV. Kita akan menggunakan semuanya. Setelah itu, Anda perlu mendeklarasikan tipe setiap variabel.

Variabel float didefinisikan 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 tersebut dapat dibagi menjadi tiga bagian:

  1. Impor data
  2. Buat iteratornya
  3. Konsumsi datanya

Berikut adalah kode keseluruhan untuk mendefinisikan fungsi tersebut. Kode tersebut akan dijelaskan selanjutnya.

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 dataset membaca satu baris dalam satu waktu. Untuk membangun dataset, Anda perlu menggunakan objek tersebut. TextLineDataset. Dataset Anda memiliki header, jadi Anda perlu menggunakan skip(1) untuk melewati baris pertama. Pada titik ini, Anda hanya membaca data dan mengecualikan header dalam pipeline. Untuk memasukkan data ke model, Anda perlu memisahkan fitur dari label. Metode yang digunakan untuk menerapkan transformasi apa pun pada data adalah map.

Metode ini memanggil fungsi yang akan Anda buat untuk memberi instruksi tentang cara mentransformasi data. Singkatnya, Anda perlu memasukkan data ke dalam TextLineObjek dataset, kecualikan header, dan terapkan transformasi yang diinstruksikan oleh sebuah fungsi.

Code penjelasan

  • tf.data.TextLineDataset(data_file): baris ini membaca file CSV
  • .skip(1): melewati header
  • .map(parse_csv)): mengurai data menjadi tensor

Anda perlu mendefinisikan sebuah fungsi untuk memberikan instruksi pada objek map. Anda dapat menamai fungsi ini parse_csv.

Fungsi ini mengurai file CSV dengan metode tf.decode_csv dan mendeklarasikan fitur serta labelnya. Fitur dapat dideklarasikan sebagai kamus (dictionary) atau tuple. Anda menggunakan metode kamus karena lebih praktis.

Code penjelasan

  • tf.decode_csv(value, record_defaults= RECORDS_ALL): metode decode_csv menggunakan output dari TextLineDataset yang akan dibaca dari file CSV. `record_defaults` memberi tahu TensorFlow tentang tipe kolom. Di TensorFlow 2.x, simbol ini berada di `tf.io.decode_csv`.
  • dict(zip(COLUMNS, columns)): mengisi kamus dengan semua kolom extracted selama pemrosesan data ini
  • features.pop('medv'): mengecualikan variabel target dari variabel fitur dan membuat variabel label.

Dataset membutuhkan elemen tambahan untuk secara iteratif memasukkan tensor. Anda perlu menambahkan metode `repeat` agar dataset dapat terus memasukkan data ke model tanpa batas. Jika Anda tidak menambahkan metode ini, model hanya akan berulang satu kali dan kemudian akan menampilkan kesalahan karena tidak ada lagi data yang dimasukkan ke dalam pipeline.

Setelah itu, Anda dapat mengontrol ukuran batch dengan metode batch. Artinya, Anda memberi tahu dataset berapa banyak data yang ingin Anda masukkan ke dalam pipeline untuk setiap iterasi. Jika Anda menetapkan ukuran batch yang besar, model akan menjadi 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 tersebut dalam sebuah sesi untuk mengonsumsi data. Anda dapat mencoba dengan ukuran batch sama dengan 1.

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

Kode 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 5) 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 wadah.

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

Langkah 6) 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 memungkinkan Anda menulis argumen untuk fungsi input_fn. Jika Anda tidak menggunakan fungsi lambda, Anda tidak dapat melatih model.

# Train the estimator
model.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 target berdasarkan nilai matriks fitur. Anda dapat menulis kamus dengan nilai-nilai yang ingin Anda prediksi. Model Anda memiliki sembilan fitur, jadi Anda perlu memberikan nilai untuk masing-masing fitur. Model akan memberikan prediksi untuk setiap fitur tersebut.

Pada kode di bawah ini, Anda menuliskan nilai-nilai dari setiap fitur yang terdapat dalam file CSV df_predict.

Anda perlu menulis fungsi input_fn baru karena tidak ada label dalam dataset. Anda dapat menggunakan API from_tensors dari objek 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_input
     pred_results = model.predict(input_fn=test_input_fn)

Terakhir, Anda mencetak prediksi tersebut.

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

Ketiga pipeline tersebut menghasilkan enam prediksi yang sama, yang menegaskan bahwa pilihan antara Pandas, NumPy, dan dataset TensorFlow asli adalah masalah kenyamanan, bukan akurasi.

Pertanyaan Umum Demo Slot

Tidak. TensorFlow menandai Estimator dan kolom fitur sebagai sepenuhnya usang pada rilis 2.12 dan menghapusnya pada 2.16. Tetapkan TensorFlow 1.15 atau 2.15 untuk menjalankan kode ini tanpa perubahan, atau tulis ulang model dengan lapisan Keras, yang sekarang direkomendasikan oleh tim TensorFlow.

Muat file CSV dengan Panda, skalakan sembilan fitur dengan lapisan Normalisasi, lalu tumpuk satu unit Dense(1). Kompilasi dengan pengoptimal dan kerugian mean_squared_error, lalu panggil fit. Satu unit Dense tanpa aktivasi adalah regresi linier.

Mulailah sekitar 0.01 dan sesuaikan dengan faktor sepuluh. Tingkat yang terlalu kecil membutuhkan lebih banyak iterasi untuk konvergen, sementara tingkat yang terlalu besar membuat kerugian berosilasi. Gambarkan kurva kerugian dan pertahankan tingkat terbesar yang masih menurun dengan mulus.

scikit-learn menghapus load_boston di versi 1.2 karena kekhawatiran etis tentang variabel rasial yang direkayasa. Tutorial ini membaca file CSV biasa, jadi tautan unduhan masih berfungsi, tetapi proyek baru sebaiknya menggunakan dataset perumahan California atau perumahan Ames sebagai gantinya.

Root Mean Square Error (RMSE) mengembalikan satuan asli, Mean Absolute Error (MEA) menahan outlier, dan R-squared melaporkan bagian varians yang dijelaskan. Laporkan metrik kesalahan absolut bersamaan dengan R-squared, karena R-squared yang tinggi masih dapat menyembunyikan kesalahan prediksi individual yang besar.

Regresi linier memprediksi angka kontinu, seperti harga rumah. A pengklasifikasi linier memprediksi label kelas diskrit. Keduanya menyesuaikan jumlah tertimbang dari fitur-fitur tersebut, tetapi pengklasifikasi meneruskan jumlah tersebut melalui ambang batas keputusan.

Pipeline otomatis memberi skor pada fitur dengan regularisasi Lasso, informasi timbal balik, atau kepentingan permutasi, lalu menghilangkan fitur yang paling lemah. Alat AutoML mencari opsi pra-pemrosesan dan model secara bersamaan, sehingga Anda menghabiskan lebih sedikit waktu untuk memilih kolom mana yang termasuk dalam feature_cols secara manual.

Copilot membuat draf kode standar dengan cepat, termasuk fungsi input, daftar kolom fitur, dan perulangan evaluasi. Perlakukan setiap saran sebagai draf, karena sering kali menghasilkan panggilan Estimator yang sudah usang. Periksa setiap simbol yang dihasilkan terhadap API TensorFlow saat ini sebelum Anda menjalankannya.

Ringkaslah postingan ini dengan: