Regresi Linear TensorFlow dengan Facet & Istilah Interaksi

Dalam tutorial ini, Anda akan belajar cara memeriksa data dan mempersiapkannya untuk membuat tugas regresi linier sederhana.

Tutorial ini dibagi menjadi dua bagian:

• Cari interaksi
• Uji modelnya

Di tutorial sebelumnya, Anda menggunakan kumpulan data Boston untuk memperkirakan harga median rumah. Dataset Boston berukuran kecil, hanya dengan 506 observasi. Dataset ini dianggap sebagai patokan untuk mencoba algoritma regresi linier baru.

Dataset terdiri dari:

Variabel	Deskripsi
zn	Proporsi tanah tempat tinggal yang dikategorikan untuk bidang lebih dari 25.000 kaki persegi.
indus	Proporsi hektar bisnis non-retail per kota.
nox	konsentrasi oksida nitrat
rm	jumlah rata-rata kamar per hunian
usia	proporsi unit yang ditempati pemilik yang dibangun sebelum 1940
dis	jarak tertimbang ke lima pusat kerja Boston
pajak	tarif pajak properti nilai penuh per dolar 10.000
ptratio.dll	rasio murid-guru dengan kota
medv	Nilai median rumah yang ditempati pemilik dalam ribuan dolar
kejahatan	tingkat kejahatan per kapita menurut kota
chas	Variabel dummy Charles River (1 jika membatasi sungai; 0 sebaliknya)
B	proporsi orang kulit hitam menurut kota

Dalam tutorial ini, kami akan memperkirakan harga median menggunakan regresi linier, tetapi fokusnya adalah pada satu proses pembelajaran mesin tertentu: "persiapan data".

Model menggeneralisasi pola dalam data. Untuk menangkap pola seperti itu, Anda perlu menemukannya terlebih dahulu. Praktik yang baik adalah melakukan analisis data sebelum menjalankan algoritme pembelajaran mesin apa pun.

Memilih fitur yang tepat membuat semua perbedaan dalam keberhasilan model Anda. Bayangkan Anda mencoba memperkirakan upah suatu orang, jika Anda tidak memasukkan jenis kelamin sebagai kovariat, Anda berakhir dengan perkiraan yang buruk.

Cara lain untuk memperbaiki model tersebut adalah dengan melihat korelasi antara variabel independen. Kembali ke contoh, Anda dapat menganggap pendidikan sebagai kandidat yang sangat baik untuk memprediksi upah, tetapi juga pekerjaan. Bisa dikatakan, pekerjaan tergantung pada tingkat pendidikan, pendidikan tinggi seringkali mengarah pada pekerjaan yang lebih baik. Jika kita menggeneralisasi ide ini, kita dapat mengatakan korelasi antara variabel dependen dan variabel penjelas dapat diperbesar dari variabel penjelas lainnya.

Untuk menangkap pengaruh terbatas pendidikan pada pekerjaan, kita dapat menggunakan istilah interaksi.

Jika Anda melihat persamaan upah, itu menjadi:

Jika positif, maka itu berarti bahwa tingkat pendidikan tambahan menghasilkan peningkatan nilai median rumah yang lebih tinggi untuk tingkat pekerjaan yang tinggi. Dengan kata lain, terdapat pengaruh 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 mengarah pada prediksi harga yang lebih baik.

Dalam tutorial ini, Anda akan belajar

• Statistik ringkasan
• Ikhtisar Faset
• Facets Deep Dive
• Pasang Facet
• Gambaran
• Grafik
• Facets Deep Dive
• TensorFlow
• Data persiapan
• Regresi dasar: Tolok ukur
• Tingkatkan model: Istilah interaksi

Statistik ringkasan

Ada beberapa langkah yang dapat Anda ikuti sebelum melanjutkan ke model. Seperti disebutkan sebelumnya, model adalah generalisasi data. Praktik terbaik yang sesuai adalah memahami data dan membuat prediksi. Jika Anda tidak mengetahui data Anda, Anda memiliki kesempatan kecil untuk meningkatkan model Anda.

Sebagai langkah pertama, muat data sebagai bingkai data pandas dan buat set pelatihan dan set pengujian.

Tips: Untuk tutorial ini, Anda harus menginstal matplotlit dan seaborn dengan Python. Anda dapat menginstal paket Python dengan cepat dengan Jupyter. Anda seharusnya tidak melakukan 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 memasang matplotlib dan seaborn.

Matplotlib adalah library untuk membuat grafik dengan Python. Seaborn adalah pustaka visualisasi statistik yang dibangun di atas matplotlib. Ini memberikan plot yang menarik dan indah.

Kode di bawah ini mengimpor pustaka yang diperlukan.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tffrom sklearn.datasets import load_bostonimport numpy as np

Sklearn perpustakaan menyertakan kumpulan data Boston. Anda dapat memanggil API-nya untuk mengimpor data.

boston = load_boston()df = pd.DataFrame(boston.data) 

Nama fitur disimpan di objek feature_names dalam array.

boston.feature_names

Keluaran

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Anda dapat mengganti nama kolom.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Anda mengonversi variabel CHAS sebagai variabel string dan menandainya dengan ya jika CHAS = 1 dan tidak jika CHAS = 0


df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Dengan panda, sangat mudah untuk membagi kumpulan data. Anda membagi set data secara acak dengan 80 persen set pelatihan dan 20 persen set pengujian. Panda memiliki fungsi biaya bawaan untuk membagi sampel bingkai data.
Frac parameter pertama adalah nilai dari 0 hingga 1. Anda menetapkannya ke 0,8 untuk memilih 80 persen bingkai data secara acak.
Random_state memungkinkan untuk memiliki dataframe yang sama dikembalikan untuk semua orang.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Anda bisa mendapatkan bentuk datanya. Harus:

Set kereta api: 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
 

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
USIA 
 
DIS 
 
RAD 
 
PAJAK 
 
PTRATIO 
 
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; sering kali tidak seimbang dan bertaburan dengan nilai-nilai pencilan yang membuat analisis dan pelatihan pembelajaran mesin tidak bisa berjalan.
Langkah pertama untuk membersihkan set data adalah memahami di mana ia perlu dibersihkan. Membersihkan set data bisa jadi sulit dilakukan, terutama dengan cara yang dapat digeneralisasikan
Tim Riset Google telah mengembangkan alat untuk pekerjaan ini yang disebut Facet yang membantu memvisualisasikan data dan mengirisnya dengan berbagai cara. Ini adalah titik awal yang baik untuk memahami bagaimana kumpulan data disusun.
Faset memungkinkan Anda menemukan di mana data tidak terlihat seperti yang Anda pikirkan.
Kecuali untuk aplikasi web mereka, Google mempermudah untuk menyematkan toolkit ke notebook Jupyter.
Ada dua bagian untuk Faset:

Ikhtisar Faset


Facets Deep Dive


Ikhtisar Faset
Facets Overview memberikan gambaran dari dataset. Ikhtisar Faset membagi kolom data menjadi beberapa baris informasi penting yang ditampilkan

persentase observasi yang hilang
nilai min dan maks
statistik seperti mean, median, dan deviasi standar.
Itu juga menambahkan kolom yang menunjukkan persentase nilai yang nol, yang berguna ketika sebagian besar nilai adalah nol.
Distribusi ini dapat dilihat pada set data pengujian serta set pelatihan untuk setiap fitur. Artinya, Anda dapat memeriksa ulang apakah pengujian tersebut memiliki distribusi yang mirip dengan data pelatihan.

Ini setidaknya hal minimum yang harus dilakukan sebelum tugas pembelajaran mesin apa pun. Dengan alat ini, Anda tidak melewatkan langkah penting ini, dan ini menyoroti beberapa ketidaknormalan.

Facets Deep Dive
Facets Deep Dive adalah alat yang keren. Ini memungkinkan Anda memiliki beberapa kejelasan pada dataset Anda dan memperbesar seluruhnya untuk melihat satu bagian data. Ini berarti Anda dapat mem-facet data dengan baris dan kolom di semua fitur set data.
Kami akan menggunakan dua alat ini dengan kumpulan data Boston.
Catatan : Anda tidak dapat menggunakan Ikhtisar Faset dan Penyelaman Mendalam Faset secara bersamaan. Anda perlu menghapus buku catatan terlebih dahulu untuk mengganti alat.

Pasang Facet
Anda dapat menggunakan aplikasi web Facet untuk sebagian besar analisis. Dalam tutorial ini, Anda akan melihat cara menggunakannya dalam Notebook Jupyter.
Pertama-tama, Anda perlu menginstal nbextensions. Itu dilakukan dengan kode ini. Anda menyalin dan menempelkan kode berikut di terminal mesin 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, buka URL ini https://git-scm.com/download/win dan ikuti instruksinya. Setelah Anda selesai, Anda dapat menggunakan perintah git di terminal untuk Pengguna Mac atau prompt Anaconda untuk pengguna Windows
git clone https://github.com/PAIR-code/facets 
Opsi 2) Buka https://github.com/PAIR-code/facets dan unduh repositori.

Jika Anda memilih opsi pertama, file tersebut berakhir di file unduhan Anda. Anda dapat membiarkan file diunduh atau menyeretnya ke jalur lain.
Anda dapat memeriksa di mana Facet disimpan dengan baris perintah ini:
echo `pwd`/`ls facets` 
Sekarang Anda telah menemukan Facets, Anda perlu menginstalnya di Notebook Jupyter. Anda perlu menyetel 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 Facet 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 buka Ringkasan Faset.

Gambaran
Tinjauan menggunakan skrip Python untuk menghitung statistik. Anda perlu mengimpor skrip yang disebut generic_feature_statistics_generator ke Jupyter. Jangan khawatir; skrip terletak di file facets.
Anda perlu menemukan jalannya. Itu mudah dilakukan. Anda membuka facets, 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 timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Anda dapat mengimpor skrip dengan kode di bawah ini.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
Di windows, kode yang sama menjadi
import syssys.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 bisa melewatkan bingkai data dalam kamus. Misalnya, jika kita ingin membuat statistik ringkasan untuk set kereta, kita dapat menyimpan informasi 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 overviewimport base64gfsg = 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 menyalin dan menempelkan kode di bawah ini. Kode tersebut berasal langsung dari GitHub. Anda seharusnya bisa melihat ini:

# Display the facets overview visualization for this data# Displfrom IPython.core.display import display, HTMLHTML_TEMPLATE = """
"""html = HTML_TEMPLATE.format(protostr=protostr)display(HTML(html))
 
Grafik
Setelah Anda memeriksa data dan distribusinya, Anda bisa memplot matriks korelasi. Matriks korelasi menghitung koefisien Pearson. Koefisien ini terikat antara -1 dan 1, dengan 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 inlineimport matplotlib.pyplot as pltimport seaborn as snssns.set(style="ticks")# Compute the correlation matrixcorr = df.corr('pearson')# Generate a mask for the upper trianglemask = np.zeros_like(corr, dtype=np.bool)mask[np.triu_indices_from(mask)] = True# Set up the matplotlib figuref, ax = plt.subplots(figsize=(11, 9))# Generate a custom diverging colormapcmap = sns.diverging_palette(220, 10, as_cmap=True)# Draw the heatmap with the mask and correct aspect ratiosns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,square=True, linewidths=.5, cbar_kws={"shrink": .5})
Keluaran 

png

Dari matriks tersebut, Anda dapat melihat:

LSTAT
RM

Berkorelasi kuat dengan PRICE. Fitur menarik lainnya adalah korelasi positif yang kuat antara NOX dan INDUS, yang berarti kedua variabel tersebut bergerak ke arah yang sama. Disamping itu juga ada korelasinya dengan PRICE. DIS juga sangat berkorelasi dengan IND dan NOX.
Anda memiliki beberapa petunjuk pertama bahwa IND dan NOX bisa menjadi kandidat yang baik untuk istilah intersep dan DIS mungkin juga menarik untuk difokuskan.
Anda bisa melangkah lebih dalam dengan memplot sepasang grid. Ini akan mengilustrasikan lebih detail peta korelasi yang Anda gambarkan sebelumnya.
Grid pasangan yang kami susun sebagai berikut:

Bagian atas: Sebar plot dengan garis pas
Diagonal: Plot kepadatan kernel
Bagian bawah: Plot kepadatan kernel multivariat

Anda memilih fokus pada empat variabel independen. Pilihan sesuai dengan variabel dengan korelasi kuat dengan PRICE

INDUS
NOX
RM
LSTAT

apalagi, PRICE.
Perhatikan bahwa kesalahan standar ditambahkan secara default ke plot pencar.
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 yang seperti garis lurus padahal harganya sama dengan 50. Dari uraian dataset, PRICE sudah terpotong pada nilai 50

Diagonal

NOX tampaknya memiliki dua kelompok, satu sekitar 0,5 dan satu lagi sekitar 0,85.

Untuk mengecek lebih lanjut, Anda bisa melihat di bagian bawah. Kepadatan Kernel Multivariasi menarik dalam arti warnanya di mana sebagian besar titik berada. Perbedaan dengan plot pencar menggambarkan kepadatan probabilitas, meskipun tidak ada titik dalam kumpulan data untuk koordinat tertentu. Ketika 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 kluster. Ketika pangsa industri di atas 18, konsentrasi oksida nitrat di atas 0,6.
Anda dapat memikirkan tentang 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 pusat di tengah adalah tampilan data yang dapat diperbesar. Di bagian atas panel, terdapat menu drop-down di mana Anda dapat mengubah pengaturan data untuk mengontrol faceting, positioning, dan color. Di sebelah kanan, ada tampilan mendetail dari baris data tertentu. Artinya, Anda dapat mengklik titik data mana pun di visualisasi tengah untuk melihat detail tentang titik data tersebut.
Pada tahap visualisasi data, Anda tertarik untuk mencari korelasi berpasangan antara variabel independen terhadap harga rumah. Namun, ini melibatkan setidaknya tiga variabel, dan plot 3D rumit untuk dikerjakan.
Salah satu cara untuk mengatasi masalah ini adalah dengan membuat variabel kategorikal. Artinya, kita dapat membuat plot 2D dengan warna titik. Anda dapat membagi variabel HARGA menjadi empat kategori, dengan setiap kategori adalah kuartil (yaitu, 0,25, 0,5, 0,75). Anda menyebut variabel baru ini Q_PRICE.
## Check non linearity with important featuresdf['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])## Show non linearity between RM and LSTATax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")


Facets Deep Dive
Untuk membuka Deep Dive, Anda perlu mengubah data menjadi 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 64jsonstr = df.to_json(orient='records')
Kode di bawah ini berasal dari Google GitHub. Setelah Anda menjalankan kode, Anda seharusnya dapat melihat ini:

# Display thde Dive visualization for this datafrom IPython.core.display import display, HTML# Create Facets templateHTML_TEMPLATE = """
"""# Load the json dataset and the sprite_size into the templatehtml = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)# Display the templatedisplay(HTML(html))
Anda tertarik untuk melihat apakah ada hubungan antara tingkat industri, konsentrasi oksida, jarak ke pusat kerja dan harga rumah.
Untuk itu, Anda terlebih dahulu 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

Di sini, warna yang lebih gelap berarti jarak ke pusat kerja pertama jauh.
Sejauh ini, ini menunjukkan lagi apa yang Anda ketahui, tingkat industri yang lebih rendah, harga yang lebih tinggi. Sekarang Anda dapat melihat pengelompokan menurut INDUX, oleh NOX.

Pilih faceting Y dan pilih NOX.

Sekarang Anda dapat melihat rumah yang jauh dari pusat pekerjaan pertama memiliki pangsa industri terendah dan oleh karena itu memiliki konsentrasi oksida terendah. Jika Anda memilih untuk menampilkan jenis dengan Q_PRICE dan memperbesar sudut kiri bawah, Anda dapat melihat jenis harganya.
Anda memiliki petunjuk lain bahwa interaksi antara IND, NOX, dan DIS dapat menjadi kandidat yang baik untuk meningkatkan model.

TensorFlow
Di bagian ini, Anda akan memperkirakan pengklasifikasi linier dengan TensorFlow estimators API. Anda akan melanjutkan sebagai berikut:

Siapkan datanya
Memperkirakan model tolok ukur: Tanpa interaksi
Perkirakan model dengan interaksi

Ingat, tujuan pembelajaran mesin adalah meminimalkan kesalahan. Dalam kasus ini, model dengan kesalahan kuadrat rata-rata terendah akan menang. Estimator TensorFlow secara otomatis menghitung metrik ini.
Data persiapan
Dalam kebanyakan kasus, Anda perlu mengubah data Anda. Itulah mengapa Ringkasan Faset menarik. Dari ringkasan statistik, Anda melihat ada pencilan. Nilai tersebut memengaruhi perkiraan karena tidak terlihat seperti populasi yang Anda analisis. Pencilan biasanya membuat hasil menjadi bias. Misalnya, pencilan positif cenderung melebih-lebihkan koefisien.
Solusi yang baik untuk mengatasi masalah ini adalah dengan melakukan standarisasi variabel. Standarisasi berarti deviasi standar satu dan berarti nol. Proses standardisasi melibatkan dua langkah. Pertama-tama, ini mengurangi nilai rata-rata variabel. Kedua, ia membagi dengan varian sehingga distribusinya memiliki varian satuan
Sklearn perpustakaan sangat membantu untuk menstandarisasi 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 preprocessingdef 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 tersebut untuk membuat set kereta / pengujian yang diskalakan.
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 kinerja model.
Cara untuk melatih model persis seperti tutorial di API tingkat tinggi . Anda akan menggunakan TensorFlow estimator LinearRegressor.
Sebagai pengingat, Anda harus memilih:

fitur untuk dimasukkan ke dalam model
ubah fiturnya
buat regressor linier
membangun fungsi input_fn
latih modelnya
uji modelnya

Anda menggunakan semua variabel dalam kumpulan data untuk melatih model. Secara total, ada variabel kontinu tingkat dan satu variabel kategori
## Add features to the bucket:### Define continuous listCONTI_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': , '_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 train 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 = 1INFO:tensorflow:global_step/sec: 144.457INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)INFO:tensorflow:global_step/sec: 258.392INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)INFO:tensorflow:global_step/sec: 227.998INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)INFO:tensorflow:global_step/sec: 210.739INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)INFO:tensorflow:global_step/sec: 234.237INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)INFO:tensorflow:global_step/sec: 238.1INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)INFO:tensorflow:global_step/sec: 237.934INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)INFO:tensorflow:global_step/sec: 220.687INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)INFO:tensorflow:global_step/sec: 232.702INFO: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.
Terakhir, Anda memperkirakan performa model di 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:43INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43INFO: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}
Model yang hilang 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. Teknik visualisasi yang berbeda mengungkapkan bahwa INDUS dan NOS saling terkait dan ternyata memperbesar pengaruhnya terhadap harga. Tidak hanya interaksi antara INDUS dan NOS yang mempengaruhi harga tetapi juga efek ini lebih kuat ketika berinteraksi dengan DIS.
Saatnya untuk menggeneralisasi ide ini dan melihat apakah Anda dapat meningkatkan model prediksi model.
Anda perlu menambahkan dua kolom baru ke setiap set dataset: train + test. Untuk itu, Anda membuat satu fungsi untuk menghitung istilah interaksi dan satu lagi untuk menghitung istilah interaksi rangkap tiga. Setiap fungsi menghasilkan satu kolom. Setelah variabel baru dibuat, Anda dapat menggabungkannya ke set data pelatihan dan menguji set data.
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 istilah 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, testinteration_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Sekarang Anda memiliki semua kolom yang diperlukan, Anda dapat menambahkannya untuk melatih dan menguji kumpulan data. Sebutkan dua kerangka data baru ini:

df_train_new
df_test_new

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 istilah 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 listcontinuous_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': , '_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 = 1INFO:tensorflow:global_step/sec: 124.844INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)INFO:tensorflow:global_step/sec: 182.704INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)INFO:tensorflow:global_step/sec: 208.189INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)INFO:tensorflow:global_step/sec: 213.855INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)INFO:tensorflow:global_step/sec: 209.758INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)INFO:tensorflow:global_step/sec: 196.618INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)INFO:tensorflow:global_step/sec: 196.472INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)INFO:tensorflow:global_step/sec: 172.82INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)INFO:tensorflow:global_step/sec: 168.916INFO: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.
 
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:14INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14INFO: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 baru adalah 1515. Hanya dengan menambahkan dua variabel baru, Anda sudah dapat mengurangi kerugian. Artinya, Anda dapat membuat prediksi yang lebih baik daripada dengan model benchmark.