Regresi Linier TensorFlow dengan Istilah Faset & Interaksi
Evelyn Clarke
Dalam tutorial ini, Anda akan mempelajari cara memeriksa data dan mempersiapkannya untuk membuat tugas regresi linier sederhana.
Tutorial ini dibagi menjadi dua bagian:
- Carilah interaksi
- Uji modelnya
Dalam majalah tutorial sebelumnya, Anda menggunakan kumpulan data Boston untuk memperkirakan harga rata-rata sebuah rumah. Kumpulan data Boston berukuran kecil, hanya berisi 506 observasi. Kumpulan data ini dianggap sebagai tolok ukur untuk mencoba algoritme regresi linier baru.
Kumpulan data terdiri dari:
| Variabel | Uraian Teknis |
|---|---|
| zn | Proporsi lahan perumahan yang dikategorikan untuk lahan seluas lebih dari 25,000 kaki persegi. |
| indus | Proporsi hektar usaha 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 di suatu kota |
| medv | Nilai median rumah yang ditempati pemilik dalam ribuan dolar |
| kejahatan | tingkat kejahatan per kapita menurut kota |
| chas | Variabel dummy Sungai Charles (1 jika batas sungai; 0 jika tidak) |
| B | proporsi orang kulit hitam di kota |
Dalam tutorial ini, kita akan memperkirakan harga median menggunakan regressor linier, namun fokusnya adalah pada satu proses tertentu Mesin belajar: "persiapan data."
Sebuah model menggeneralisasi pola dalam data. Untuk menangkap pola seperti itu, Anda harus menemukannya terlebih dahulu. Praktik yang baik adalah melakukan analisis data sebelum menjalankan algoritma pembelajaran mesin apa pun.
Memilih fitur yang tepat akan menentukan kesuksesan model Anda. Bayangkan Anda mencoba memperkirakan upah suatu masyarakat, jika Anda tidak memasukkan gender sebagai kovariat, Anda akan mendapatkan perkiraan yang buruk.
Cara lain untuk menyempurnakan model adalah dengan melihat korelasi antar variabel independen. Kembali ke contoh, Anda bisa menganggap pendidikan sebagai kandidat yang tepat untuk memprediksi upah dan juga pekerjaan. Boleh dikatakan, pekerjaan bergantung pada tingkat pendidikan, yaitu pendidikan yang lebih tinggi sering kali menghasilkan pekerjaan yang lebih baik. Jika kita menggeneralisasi gagasan ini, kita dapat mengatakan bahwa korelasi antara variabel terikat dan variabel penjelas dapat diperbesar dengan variabel penjelas lainnya.
Untuk menangkap terbatasnya pengaruh pendidikan terhadap pekerjaan, kita dapat menggunakan istilah interaksi.
Jika dilihat persamaan upahnya menjadi:
If 
bernilai positif, maka hal ini berarti bahwa semakin tinggi tingkat pendidikan maka semakin tinggi pula peningkatan nilai median rumah pada tingkat pekerjaan yang tinggi. Dengan kata lain, terdapat efek interaksi antara pendidikan dan pekerjaan.
Dalam tutorial ini, kita akan mencoba melihat variabel mana yang bisa menjadi kandidat yang baik untuk istilah interaksi. Kami akan menguji apakah menambahkan informasi semacam ini menghasilkan prediksi harga yang lebih baik.
Statistik ringkasan
Ada beberapa langkah yang dapat Anda ikuti sebelum melanjutkan ke model. Seperti disebutkan sebelumnya, model merupakan generalisasi data. Praktik terbaik adalah memahami data dan membuat prediksi. Jika Anda tidak mengetahui data Anda, Anda memiliki peluang kecil untuk meningkatkan model Anda.
Sebagai langkah pertama, muat data sebagai kerangka data pandas dan buat set pelatihan dan set pengujian.
Tips: Untuk tutorial ini, Anda perlu menginstal matplotlit dan seaborn Python. Anda dapat menginstal Python paket dengan cepat Jupyter. Anda Jangan melakukan hal ini
!conda install -- yes matplotlib
tapi
import sys
!{sys.executable} -m pip install matplotlib # Already installed
!{sys.executable} -m pip install seaborn
Perhatikan bahwa langkah ini tidak diperlukan jika Anda telah menginstal matplotlib dan seaborn.
Matplotlib adalah perpustakaan untuk membuat grafik Python. Seaborn adalah perpustakaan visualisasi statistik yang dibangun di atas matplotlib. Ini memberikan plot yang menarik dan indah.
Kode di bawah ini mengimpor perpustakaan yang diperlukan.
import pandas as pd from sklearn import datasets import tensorflow as tf from sklearn.datasets import load_boston import numpy as np
Perpustakaan sklearn menyertakan kumpulan data Boston. Anda dapat memanggil API-nya untuk mengimpor data.
boston = load_boston() df = pd.DataFrame(boston.data)
Nama fitur disimpan dalam objek feature_names dalam array.
boston.feature_names
Keluaran
array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')
Anda dapat mengganti nama kolom.
df.columns = boston.feature_names df['PRICE'] = boston.target df.head(2)
Anda mengonversi variabel CHAS menjadi variabel string dan memberi label dengan ya jika CHAS = 1 dan tidak jika CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})
df['CHAS'].head(5)
0 no
1 no
2 no
3 no
4 no
Name: CHAS, dtype: object
Dengan panda, membagi kumpulan data sangatlah mudah. Anda membagi kumpulan data secara acak dengan 80 persen set pelatihan dan 20 persen set pengujian. Panda memiliki fungsi biaya bawaan untuk membagi sampel bingkai data.
Parameter pertama frac adalah nilai dari 0 hingga 1. Anda menyetelnya ke 0.8 untuk memilih 80 persen bingkai data secara acak.
Random_state memungkinkan kerangka data yang sama dikembalikan untuk semua orang.
### Create train/test set df_train=df.sample(frac=0.8,random_state=200) df_test=df.drop(df_train.index)
Anda bisa mendapatkan bentuk datanya. Harus:
- Set kereta: 506*0.8 = 405
- Set pengujian: 506*0.2 = 101
print(df_train.shape, df_test.shape)
Keluaran
(405, 14) (101, 14)
df_test.head(5)
Keluaran
| KEJAHATAN | ZN | INDUS | CHAS | NOx | RM | UMUR | DIS | RAD | PAJAK | PTRASI | B | LSTAT | HARGA | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0.00632 | 18.0 | 2.31 | tidak | 0.538 | 6.575 | 65.2 | 4.0900 | 1.0 | 296.0 | 15.3 | 396.90 | 4.98 | 24.0 |
| 1 | 0.02731 | 0.0 | 7.07 | tidak | 0.469 | 6.421 | 78.9 | 4.9671 | 2.0 | 242.0 | 17.8 | 396.90 | 9.14 | 21.6 |
| 3 | 0.03237 | 0.0 | 2.18 | tidak | 0.458 | 6.998 | 45.8 | 6.0622 | 3.0 | 222.0 | 18.7 | 394.63 | 2.94 | 33.4 |
| 6 | 0.08829 | 12.5 | 7.87 | tidak | 0.524 | 6.012 | 66.6 | 5.5605 | 5.0 | 311.0 | 15.2 | 395.60 | 12.43 | 22.9 |
| 7 | 0.14455 | 12.5 | 7.87 | tidak | 0.524 | 6.172 | 96.1 | 5.9505 | 5.0 | 311.0 | 15.2 | 396.90 | 19.15 | 27.1 |
Data berantakan; hal ini sering kali tidak seimbang dan dipenuhi dengan nilai-nilai outlier yang mengganggu analisis dan pelatihan pembelajaran mesin.
Langkah pertama untuk membersihkan kumpulan data adalah memahami bagian mana yang perlu dibersihkan. Membersihkan kumpulan data bisa jadi sulit dilakukan, terutama dengan cara yang dapat digeneralisasikan
Tim Riset Google telah mengembangkan alat untuk pekerjaan ini yang disebut Segi yang membantu memvisualisasikan data dan membaginya dengan berbagai cara. Ini adalah titik awal yang baik untuk memahami bagaimana kumpulan data disusun.
Aspek memungkinkan Anda menemukan data yang tidak sesuai dengan pemikiran Anda.
Kecuali untuk aplikasi webnya, Google memudahkan untuk menyematkan toolkit ke dalam a Jupyter buku catatan.
Ada dua bagian pada Aspek:
- Ikhtisar Aspek
- Aspek Penyelaman Mendalam
Ikhtisar Aspek
Ikhtisar Facet memberikan ikhtisar tentang kumpulan data. Ikhtisar Facet membagi kolom data menjadi baris informasi penting yang menunjukkan
- persentase observasi yang hilang
- nilai min dan maks
- statistik seperti mean, median, dan deviasi standar.
- Itu juga menambahkan kolom yang memperlihatkan persentase nilai nol, yang berguna ketika sebagian besar nilai adalah nol.
- Distribusi ini dapat dilihat pada set data pengujian dan set pelatihan untuk setiap fitur. Ini berarti Anda dapat memeriksa ulang bahwa pengujian memiliki distribusi yang serupa dengan data pelatihan.
Setidaknya ini adalah hal minimum yang harus dilakukan sebelum tugas pembelajaran mesin apa pun. Dengan alat ini, Anda tidak akan melewatkan langkah penting ini, dan alat ini akan menyoroti beberapa kelainan.
Aspek Penyelaman Mendalam
Facets Deep Dive adalah alat yang keren. Alat ini memungkinkan Anda untuk melihat dataset Anda dengan lebih jelas dan memperbesarnya untuk melihat bagian data secara individual. Ini berarti Anda dapat membagi data berdasarkan baris dan kolom di semua fitur dataset.
Kami akan menggunakan kedua alat ini dengan kumpulan data Boston.
Note: Anda tidak dapat menggunakan Ikhtisar Faset dan Penyelaman Mendalam Faset secara bersamaan. Anda perlu mengosongkan buku catatan terlebih dahulu untuk mengganti alat.
Instal Segi
Anda dapat menggunakan aplikasi web Facet untuk sebagian besar analisis. Dalam tutorial ini, Anda akan melihat cara menggunakannya dalam a Jupyter Buku catatan.
Pertama-tama, Anda perlu menginstal nbextensions. Caranya dengan kode ini. Anda menyalin dan menempelkan kode berikut di terminal komputer Anda.
pip install jupyter_contrib_nbextensions
Tepat setelah itu, Anda perlu mengkloning repositori di komputer Anda. Anda memiliki dua pilihan:
Opsi 1) Salin dan tempel kode ini di terminal (Disarankan)
Jika Anda belum menginstal Git di mesin Anda, silakan buka URL ini https://git-scm.com/download/win dan ikuti instruksinya. Setelah selesai, Anda dapat menggunakan perintah git di terminal untuk Pengguna Mac atau perintah Anaconda Windows pemakai
git clone https://github.com/PAIR-code/facets
Opsi 2) Pergi ke https://github.com/PAIR-code/facets dan unduh repositori.
Jika Anda memilih opsi pertama, file tersebut akan masuk ke file unduhan Anda. Anda dapat membiarkan file diunduh atau menyeretnya ke jalur lain.
Anda dapat memeriksa di mana Facets disimpan dengan baris perintah ini:
echo `pwd`/`ls facets`
Sekarang Anda telah menemukan Facets, Anda perlu menginstalnya Jupyter Buku catatan. Anda perlu mengatur direktori kerja ke jalur tempat faset berada.
Direktori kerja Anda saat ini dan lokasi zip Facets harus sama.
Anda perlu mengarahkan direktori kerja ke Facet:
cd facets
Untuk menginstal Aspek di Jupyter, Anda memiliki dua opsi. Jika Anda menginstal Jupyter dengan Conda untuk semua pengguna, salin kode ini:
dapat menggunakan jupyter nbextension install facets-dist/
jupyter nbextension install facets-dist/
Jika tidak, gunakan:
jupyter nbextension install facets-dist/ --user
Baiklah, Anda sudah siap. Mari kita buka Ikhtisar Segi.
Ringkasan
Ikhtisar menggunakan a Python skrip untuk menghitung statistik. Anda perlu mengimpor skrip yang disebut generic_feature_statistics_generator ke Jupyter. Jangan khawatir; skripnya terletak di file faset.
Anda perlu menemukan jalurnya. Hal ini mudah dilakukan. Anda membuka faset, buka file facets_overview dan kemudian python. Salin jalannya
Setelah itu, kembali ke Jupyter, dan tulis kode berikut. Ubah jalur '/Users/Thomas/facets/facets_overview/python' ke jalur Anda.
# Add the facets overview python code to the python path# Add t
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')
Anda dapat mengimpor skrip dengan kode di bawah ini.
from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Di windows, kode yang sama menjadi
import sys sys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python") from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Untuk menghitung statistik fitur, Anda perlu menggunakan fungsi GenericFeatureStatisticsGenerator(), dan Anda menggunakan objek ProtoFromDataFrames. Anda dapat meneruskan bingkai data dalam kamus. Misalnya, jika kita ingin membuat ringkasan statistik untuk rangkaian kereta, kita dapat menyimpan informasinya dalam kamus dan menggunakannya di objek `ProtoFromDataFrames“
-
'name': 'train', 'table': df_train
Nama adalah nama tabel yang ditampilkan, dan Anda menggunakan nama tabel yang ingin Anda hitung ringkasannya. Dalam contoh Anda, tabel yang berisi data adalah df_train
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overview
import base64
gfsg = GenericFeatureStatisticsGenerator()
proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},
{'name': 'test', 'table': df_test}])
#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])
protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")
Terakhir, Anda tinggal copy dan paste kode di bawah ini. Kode tersebut berasal langsung dari GitHub. Anda seharusnya dapat melihat ini:
# Display the facets overview visualization for this data# Displ
from IPython.core.display import display, HTML
HTML_TEMPLATE = """<link rel="import" href="/id/nbextensions/facets-dist/facets-jupyter.html" >
<facets-overview id="elem"></facets-overview>
<script>
document.querySelector("#elem").protoInput = "{protostr}";
</script>"""
html = HTML_TEMPLATE.format(protostr=protostr)
display(HTML(html))
Grafik
Setelah Anda memeriksa data dan distribusinya, Anda dapat membuat matriks korelasi. Matriks korelasi menghitung koefisien Pearson. Koefisien ini terikat antara -1 dan 1, nilai positif menunjukkan korelasi positif dan nilai negatif menunjukkan korelasi negatif.
Anda tertarik untuk melihat variabel mana yang bisa menjadi kandidat yang baik untuk istilah interaksi.
## Choose important feature and further check with Dive
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="ticks")
# Compute the correlation matrix
corr = df.corr('pearson')
# Generate a mask for the upper triangle
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(11, 9))
# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10, as_cmap=True)
# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,
square=True, linewidths=.5, cbar_kws={"shrink": .5})
Keluaran
<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>
png
Dari matriks tersebut terlihat:
- LSTAT
- RM
Sangat berkorelasi dengan HARGA. Fitur menarik lainnya adalah korelasi positif yang kuat antara NOX dan INDUS, yang berarti kedua variabel tersebut bergerak ke arah yang sama. Selain itu, keduanya juga berkorelasi dengan HARGA. DIS juga sangat berkorelasi dengan IND dan NOX.
Anda mempunyai petunjuk pertama bahwa IND dan NOX bisa menjadi kandidat yang baik untuk istilah intersep dan DIS mungkin juga menarik untuk difokuskan.
Anda dapat mempelajari lebih dalam dengan memplot grid berpasangan. Ini akan menggambarkan lebih detail peta korelasi yang Anda buat sebelumnya.
Grid pasangan yang kami susun sebagai berikut:
- Bagian atas: Plot sebar dengan garis pas
- Diagonal: Plot kepadatan kernel
- Bagian bawah: Plot kepadatan kernel multivariat
Anda memilih fokus pada empat variabel independen. Pilihan tersebut sesuai dengan variabel yang memiliki korelasi kuat dengan HARGA
- INDUS
- NOx
- RM
- LSTAT
apalagi HARGA.
Note bahwa kesalahan standar ditambahkan secara default ke plot sebar.
attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"] g = sns.PairGrid(df[attributes]) g = g.map_upper(sns.regplot, color="g") g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False) g = g.map_diag(sns.kdeplot)
Keluaran
Mari kita mulai dengan bagian atas:
- Harga berkorelasi negatif dengan INDUS, NOX, dan LSTAT; berkorelasi positif dengan RM.
- Ada sedikit non-linearitas dengan LSTAT dan PRICE
- Ada seperti garis lurus ketika harganya sama dengan 50. Dari gambaran dataset PRICE sudah terpotong pada nilai 50
Diagonal
- NOX tampaknya memiliki dua klaster, satu di sekitar 0.5 dan satu di sekitar 0.85.
Untuk memeriksanya lebih lanjut, Anda dapat melihat bagian bawah. Kepadatan Kernel Multivariat menarik karena mewarnai tempat sebagian besar titik berada. Perbedaannya dengan diagram sebar menggambarkan kepadatan probabilitas, meskipun tidak ada titik dalam kumpulan data untuk koordinat tertentu. Jika warnanya lebih kuat, ini menunjukkan konsentrasi titik yang tinggi di sekitar area ini.
Jika Anda memeriksa kerapatan multivariat untuk INDUS dan NOX, Anda dapat melihat korelasi positif dan kedua klaster tersebut. Ketika pangsa industri di atas 18, konsentrasi oksida nitrat di atas 0.6.
Anda dapat memikirkan untuk menambahkan interaksi antara INDUS dan NOX dalam hubungan linier.
Terakhir, Anda dapat menggunakan alat kedua yang dibuat oleh Google, Facets Deep Dive. Antarmuka dibagi menjadi empat bagian utama. Area tengah di bagian tengah adalah tampilan data yang dapat diperbesar. Di bagian atas panel, terdapat menu tarik-turun tempat Anda dapat mengubah susunan data untuk mengontrol faceting, positioning, dan warna. Di sebelah kanan, terdapat tampilan terperinci dari baris data tertentu. Artinya, Anda dapat mengeklik titik data mana pun di visualisasi tengah untuk melihat detail tentang titik data tertentu tersebut.
Selama tahap visualisasi data, Anda tertarik untuk mencari korelasi berpasangan antara variabel independen dengan harga rumah. Namun, hal ini melibatkan setidaknya tiga variabel, dan plot 3D rumit untuk digunakan.
Salah satu cara untuk mengatasi masalah ini adalah dengan membuat variabel kategori. Artinya, kita bisa membuat plot 2D dengan mewarnai titik tersebut. Anda dapat membagi variabel PRICE menjadi empat kategori, dengan masing-masing kategori berbentuk kuartil (yaitu, 0.25, 0.5, 0.75). Anda menyebut variabel baru ini Q_PRICE.
## Check non linearity with important features df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"]) ## Show non linearity between RM and LSTAT ax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")
Aspek Penyelaman Mendalam
Untuk membuka Deep Dive, Anda perlu mengubah data ke dalam format json. Panda sebagai objek untuk itu. Anda dapat menggunakan to_json setelah kumpulan data Pandas.
Baris kode pertama menangani ukuran kumpulan data.
df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"]) sprite_size = 32 if len(df.index)>50000 else 64 jsonstr = df.to_json(orient='records')
Kode di bawah ini berasal dari Google GitHub. Setelah Anda menjalankan kode, Anda akan melihat ini:
# Display thde Dive visualization for this data
from IPython.core.display import display, HTML
# Create Facets template
HTML_TEMPLATE = """<link rel="import" href="/id/nbextensions/facets-dist/facets-jupyter.html">
<facets-dive sprite-image-width="{sprite_size}" sprite-image-height="{sprite_size}" id="elem" height="600"></facets-dive>
<script>
document.querySelector("#elem").data = {jsonstr};
</script>"""
# Load the json dataset and the sprite_size into the template
html = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)
# Display the template
display(HTML(html))
Anda tertarik untuk melihat apakah ada hubungan antara tingkat industri, konsentrasi oksida, jarak ke pusat pekerjaan dan harga rumah.
Untuk itu, pertama-tama Anda membagi data berdasarkan rentang industri dan warna dengan kuartil harga:
- Pilih faceting X dan pilih INDUS.
- Pilih Tampilan dan pilih DIS. Ini akan mewarnai titik-titik dengan kuartil harga rumah
disini warna yang lebih gelap berarti jarak ke pusat pekerjaan pertama jauh.
Sejauh ini, hal ini menunjukkan kembali apa yang Anda ketahui, tingkat industri yang lebih rendah, harga yang lebih tinggi. Sekarang Anda dapat melihat rinciannya berdasarkan INDUX, berdasarkan NOX.
- Pilih faceting Y dan pilih NOX.
Sekarang Anda dapat melihat rumah yang jauh dari pusat pekerjaan pertama memiliki pangsa industri terendah dan karenanya memiliki konsentrasi oksida terendah. Jika Anda memilih untuk menampilkan jenis dengan Q_PRICE dan memperbesar sudut kiri bawah, Anda dapat melihat jenis harganya.
Anda mempunyai petunjuk lain bahwa interaksi antara IND, NOX, dan DIS dapat menjadi kandidat yang baik untuk menyempurnakan model.
TensorFlow
Di bagian ini, Anda akan memperkirakan pengklasifikasi linier dengan API estimator TensorFlow. Anda akan melanjutkan sebagai berikut:
- Siapkan datanya
- Perkirakan model tolok ukur: Tidak ada interaksi
- Perkirakan model dengan interaksi
Ingat, tujuan pembelajaran mesin adalah meminimalkan kesalahan. Dalam hal ini, model dengan mean square error terendah akan menang. Estimator TensorFlow secara otomatis menghitung metrik ini.
Data persiapan
Dalam sebagian besar kasus, Anda perlu mengubah data Anda. Itulah mengapa Ikhtisar Aspek sangat menarik. Dari ringkasan statistik, Anda melihat terdapat outlier. Nilai tersebut mempengaruhi perkiraan karena tidak terlihat seperti populasi yang Anda analisis. Pencilan biasanya membuat hasil menjadi bias. Misalnya, outlier positif cenderung melebih-lebihkan koefisiennya.
Solusi yang baik untuk mengatasi masalah ini adalah dengan melakukan standarisasi variabel. Standardisasi berarti deviasi standar satu dan rata-rata nol. Proses standardisasi melibatkan dua langkah. Pertama-tama, ini mengurangi nilai rata-rata variabel. Kedua, membaginya dengan simpangan baku sehingga distribusinya mempunyai satuan simpangan baku.
Perpustakaan sklearn berguna untuk membakukan variabel. Anda dapat menggunakan modul preprocessing dengan skala objek untuk tujuan ini.
Anda dapat menggunakan fungsi di bawah ini untuk menskalakan kumpulan data. Perhatikan bahwa Anda tidak menskalakan kolom label dan variabel kategori.
from sklearn import preprocessing
def standardize_data(df):
X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
'TAX', 'PTRATIO', 'B', 'LSTAT']])
X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
'TAX', 'PTRATIO', 'B', 'LSTAT'])
df_scale = pd.concat([X_scaled_df,
df['CHAS'],
df['PRICE']],axis=1, join='inner')
return df_scale
Anda dapat menggunakan fungsi ini untuk membuat set kereta/pengujian berskala.
df_train_scale = standardize_data(df_train) df_test_scale = standardize_data(df_test)
Regresi dasar: Tolok Ukur
Pertama-tama, Anda melatih dan menguji model tanpa interaksi. Tujuannya adalah untuk melihat metrik performa model.
Cara melatih model sama persis dengan tutorial di atas API tingkat tinggi. Anda akan menggunakan estimator TensorFlow LinearRegressor.
Sebagai pengingat, Anda harus memilih:
- fitur yang akan dimasukkan ke dalam model
- mengubah fiturnya
- membangun regresi linier
- buat fungsi input_fn
- melatih modelnya
- menguji modelnya
Anda menggunakan semua variabel dalam kumpulan data untuk melatih model. Secara total, ada satu tingkat variabel kontinu dan satu variabel kategori
## Add features to the bucket: ### Define continuous list CONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'] CATE_FEATURES = ['CHAS']
Anda mengonversi fitur menjadi kolom numerik atau kolom kategorikal
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]
#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)
categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]
Anda membuat model dengan linearRegressor. Anda menyimpan model di folder train_Boston
model = tf.estimator.LinearRegressor(
model_dir="train_Boston",
feature_columns=categorical_features + continuous_features)
Keluaran
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_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 0x1a19e76ac8>, '_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}
Setiap kolom dalam data latih atau pengujian diubah menjadi Tensor dengan fungsi get_input_fn
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']
LABEL= 'PRICE'
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Anda memperkirakan model pada data kereta.
model.train(input_fn=get_input_fn(df_train_scale,
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_Boston/model.ckpt. INFO:tensorflow:loss = 56417.703, step = 1 INFO:tensorflow:global_step/sec: 144.457 INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec) INFO:tensorflow:global_step/sec: 258.392 INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec) INFO:tensorflow:global_step/sec: 227.998 INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec) INFO:tensorflow:global_step/sec: 210.739 INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec) INFO:tensorflow:global_step/sec: 234.237 INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec) INFO:tensorflow:global_step/sec: 238.1 INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec) INFO:tensorflow:global_step/sec: 237.934 INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec) INFO:tensorflow:global_step/sec: 220.687 INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec) INFO:tensorflow:global_step/sec: 232.702 INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec) INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt. INFO:tensorflow:Loss for final step: 23228.568. <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a19e76320>
Terakhir, Anda memperkirakan performa model pada set pengujian
model.evaluate(input_fn=get_input_fn(df_test_scale,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
Keluaran
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43
INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785
{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}
Hilangnya model adalah 1650. Ini adalah metrik yang harus dikalahkan di bagian selanjutnya
Tingkatkan model: Istilah interaksi
Selama bagian pertama tutorial, Anda melihat hubungan yang menarik antara variabel-variabel tersebut. Berbagai teknik visualisasi mengungkapkan bahwa INDUS dan NOS saling terkait dan berubah untuk memperbesar efek pada harga. Interaksi antara INDUS dan NOS tidak hanya memengaruhi harga, tetapi juga efek ini lebih kuat saat berinteraksi dengan DIS.
Sekarang saatnya untuk menggeneralisasi ide ini dan melihat apakah Anda dapat meningkatkan model prediksi model.
Anda perlu menambahkan dua kolom baru ke setiap kumpulan data: train + test. Untuk itu, Anda membuat satu fungsi untuk menghitung suku interaksi dan fungsi lainnya untuk menghitung suku interaksi rangkap tiga. Setiap fungsi menghasilkan satu kolom. Setelah variabel baru dibuat, Anda dapat menggabungkannya ke himpunan data pelatihan dan himpunan data pengujian.
Pertama-tama, Anda perlu membuat variabel baru untuk interaksi antara INDUS dan NOX.
Fungsi di bawah ini mengembalikan dua kerangka data, latih dan uji, dengan interaksi antara var_1 dan var_2, dalam kasus Anda INDUS dan NOX.
def interaction_term(var_1, var_2, name):
t_train = df_train_scale[var_1]*df_train_scale[var_2]
train = t_train.rename(name)
t_test = df_test_scale[var_1]*df_test_scale[var_2]
test = t_test.rename(name)
return train, test
Anda menyimpan dua kolom baru
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')
interation_ind_ns_train.shape
(325,)
Kedua, Anda membuat fungsi kedua untuk menghitung suku interaksi rangkap tiga.
def triple_interaction_term(var_1, var_2,var_3, name):
t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]
train = t_train.rename(name)
t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]
test = t_test.rename(name)
return train, test
interation_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Sekarang setelah Anda memiliki semua kolom yang diperlukan, Anda dapat menambahkannya ke kumpulan data pelatihan dan pengujian. Beri nama dua kerangka data baru ini:
- df_train_new
- df_test_baru
df_train_new = pd.concat([df_train_scale,
interation_ind_ns_train,
interation_ind_ns_dis_train],
axis=1, join='inner')
df_test_new = pd.concat([df_test_scale,
interation_ind_ns_test,
interation_ind_ns_dis_test],
axis=1, join='inner')
df_train_new.head(5)
Keluaran
Hanya itu saja; Anda dapat memperkirakan model baru dengan persyaratan interaksi dan melihat bagaimana metrik kinerjanya.
CONTI_FEATURES_NEW = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT',
'INDUS_NOS', 'INDUS_NOS_DIS']
### Define categorical list
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]
model = tf.estimator.LinearRegressor(
model_dir="train_Boston_1",
feature_columns= categorical_features + continuous_features_new)
Keluaran
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_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 0x1a1a5d5860>, '_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}
KODE
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']
LABEL= 'PRICE'
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)
model.train(input_fn=get_input_fn(df_train_new,
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_Boston_1/model.ckpt. INFO:tensorflow:loss = 56417.703, step = 1 INFO:tensorflow:global_step/sec: 124.844 INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec) INFO:tensorflow:global_step/sec: 182.704 INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec) INFO:tensorflow:global_step/sec: 208.189 INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec) INFO:tensorflow:global_step/sec: 213.855 INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec) INFO:tensorflow:global_step/sec: 209.758 INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec) INFO:tensorflow:global_step/sec: 196.618 INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec) INFO:tensorflow:global_step/sec: 196.472 INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec) INFO:tensorflow:global_step/sec: 172.82 INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec) INFO:tensorflow:global_step/sec: 168.916 INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec) INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt. INFO:tensorflow:Loss for final step: 19598.387. <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1a5d5e10>
model.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
Keluaran
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14
INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863
{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}
Kerugian barunya adalah 1515. Hanya dengan menambahkan dua variabel baru, Anda dapat mengurangi kerugian tersebut. Artinya, Anda dapat membuat prediksi yang lebih baik dibandingkan dengan model benchmark.
