Regresi Linear TensorFlow dengan Facet & Istilah Interaksi

Isi kandungan:

Anonim

Dalam tutorial ini, anda akan belajar bagaimana memeriksa data dan menyiapkannya untuk membuat tugas regresi linear sederhana.

Tutorial ini terbahagi kepada dua bahagian:

  • Cari interaksi
  • Uji model

Dalam tutorial sebelumnya, anda menggunakan set data Boston untuk menganggarkan harga rata-rata sebuah rumah. Set data Boston mempunyai ukuran kecil, dengan hanya 506 pemerhatian. Set data ini dianggap sebagai penanda aras untuk mencuba algoritma regresi linier baru.

Set data terdiri daripada:

Pembolehubah Penerangan
zn Bahagian tanah kediaman yang dizonkan untuk kawasan lebih dari 25,000 kaki persegi.
indus Bahagian ekar perniagaan bukan runcit setiap bandar.
nox kepekatan oksida nitrat
rm jumlah bilik rata-rata setiap kediaman
umur bahagian unit yang diduduki oleh pemilik yang dibina sebelum tahun 1940
dis jarak berwajaran ke lima pusat pekerjaan di Boston
cukai kadar cukai harta tanah bernilai penuh setiap dolar 10,000
ptratio nisbah murid-guru mengikut bandar
medv Nilai median rumah yang diduduki oleh pemilik dalam ribuan dolar
kelim kadar jenayah per kapita mengikut bandar
chas Pemboleh ubah dummy Charles River (1 jika menghadap sungai; 0 sebaliknya)
B bahagian orang kulit hitam mengikut bandar

Dalam tutorial ini, kami akan menganggarkan harga median menggunakan regresor linier, tetapi fokusnya adalah pada satu proses pembelajaran mesin tertentu: "penyediaan data."

Model menggeneralisasikan corak dalam data. Untuk menangkap corak sedemikian, anda perlu mencarinya terlebih dahulu. Amalan yang baik adalah melakukan analisis data sebelum menjalankan algoritma pembelajaran mesin.

Memilih ciri yang tepat menjadikan semua perbezaan kejayaan model anda. Bayangkan anda cuba mengira gaji orang, jika anda tidak memasukkan jantina sebagai kovariat, anda akan berakhir dengan anggaran yang buruk.

Kaedah lain untuk memperbaiki model adalah dengan melihat hubungan antara pemboleh ubah bebas. Kembali ke contoh, anda boleh menganggap pendidikan sebagai calon yang baik untuk meramalkan gaji tetapi juga pekerjaan. Adalah adil untuk mengatakan, pekerjaan bergantung pada tahap pendidikan, iaitu pendidikan tinggi sering membawa kepada pekerjaan yang lebih baik. Sekiranya kita menggeneralisasikan idea ini, kita dapat mengatakan bahawa korelasi antara pemboleh ubah bersandar dan pemboleh ubah penjelasan dapat diperbesar dengan pemboleh ubah penjelasan yang lain.

Untuk menangkap kesan terhad pendidikan terhadap pekerjaan, kita dapat menggunakan istilah interaksi.

Sekiranya anda melihat persamaan upah, ia menjadi:

Sekiranya positif, maka ini menyiratkan bahawa tahap pendidikan tambahan menghasilkan peningkatan yang lebih tinggi dalam nilai median rumah untuk tahap pekerjaan yang tinggi. Dengan kata lain, terdapat kesan interaksi antara pendidikan dan pekerjaan.

Dalam tutorial ini, kita akan cuba melihat pemboleh ubah mana yang boleh menjadi calon yang baik untuk istilah interaksi. Kami akan menguji jika menambahkan maklumat seperti ini membawa kepada ramalan harga yang lebih baik.

Dalam tutorial ini, anda akan belajar

  • Ringkasan statistik
  • Gambaran Keseluruhan Faset
  • Facets Deep Dive
  • Pasang Faset
  • Gambaran keseluruhan
  • Grafik
  • Facets Deep Dive
  • TensorFlow
  • Data penyediaan
  • Regresi asas: Tanda Aras
  • Perbaiki model: Istilah interaksi

Ringkasan statistik

Terdapat beberapa langkah yang dapat anda ikuti sebelum meneruskan ke model. Seperti disebutkan sebelumnya, model ini adalah generalisasi data. Amalan yang paling sesuai ialah memahami data dan membuat ramalan. Sekiranya anda tidak mengetahui data anda, anda mempunyai peluang tipis untuk memperbaiki model anda.

Sebagai langkah pertama, muatkan data sebagai kerangka data panda dan buat set latihan dan set pengujian.

Petua: Untuk tutorial ini, anda perlu memasang matplotlit dan seaborn di Python. Anda boleh memasang pakej Python dengan Jupyter. Anda Tidak Boleh melakukan ini

!conda install -- yes matplotlib

tetapi

import sys!{sys.executable} -m pip install matplotlib # Already installed!{sys.executable} -m pip install seaborn

Perhatikan bahawa langkah ini tidak diperlukan jika anda telah memasang matplotlib dan seaborn.

Matplotlib adalah perpustakaan untuk membuat grafik di Python. Seaborn adalah perpustakaan visualisasi statistik yang dibina di atas matplotlib. Ia menyediakan petak yang menarik dan indah.

Kod di bawah mengimport perpustakaan yang diperlukan.

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

Sklearn perpustakaan merangkumi dataset Boston. Anda boleh memanggil APInya untuk mengimport data.

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

Nama ciri disimpan dalam nama_pemerhatian objek dalam array.

boston.feature_names

Pengeluaran 

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='

Anda boleh menamakan semula lajur.


df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)




Anda menukar pemboleh ubah CHAS sebagai pemboleh ubah rentetan dan melabelkannya 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, mudah untuk membagi set data. Anda membahagikan kumpulan data secara rawak dengan set latihan 80 peratus dan set ujian 20 peratus. Pandas mempunyai fungsi biaya terpadu untuk membagi sampel bingkai data.


Parameter pertama frac adalah nilai dari 0 hingga 1. Anda menetapkannya ke 0.8 untuk memilih secara rawak 80 peratus kerangka data.


Random_state membolehkan bingkai data 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 boleh mendapatkan bentuk data. Ia harus:


    

  • Set kereta api: 506 * 0.8 = 405
    • 

  • Set ujian: 506 * 0.2 = 101
    • 



print(df_train.shape, df_test.shape)


Pengeluaran 


(405, 14) (101, 14) 
 

df_test.head(5)


Pengeluaran


 

 

   JENAYAH  ZN  INDUS  CHAS  NOX  RM  UMUR  DIS  RAD  CUKAI  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 tidak kemas; ia sering tidak seimbang dan ditaburkan dengan nilai-nilai luar yang membuang analisis dan latihan pembelajaran mesin.


Langkah pertama untuk membersihkan dataset adalah memahami di mana ia perlu dibersihkan. Membersihkan set data boleh menjadi sukar untuk dilakukan, terutama dengan cara umum


Pasukan Penyelidik Google telah mengembangkan alat untuk pekerjaan ini yang disebut Facets yang membantu untuk memvisualisasikan data dan memotongnya dengan pelbagai cara. Ini adalah titik permulaan yang baik untuk memahami bagaimana set data disusun.


Faset membolehkan anda mencari di mana data tidak kelihatan seperti yang anda fikirkan.


Kecuali untuk aplikasi web mereka, Google mempermudah untuk memasukkan toolkit ke dalam notebook Jupyter.


Terdapat dua bahagian untuk Facets:


    

  • Gambaran Keseluruhan Faset
    • 



    

  • Facets Deep Dive
    • 




Gambaran Keseluruhan Faset


Gambaran Keseluruhan Facets memberikan gambaran keseluruhan kumpulan data. Gambaran Keseluruhan Facets membahagikan lajur data menjadi baris yang menunjukkan maklumat penting


    

  1. peratusan pemerhatian yang hilang
    2. 

  2. nilai min dan maksimum
    3. 

  3. statistik seperti min, median, dan sisihan piawai.
    4. 

  4. Ia juga menambahkan lajur yang menunjukkan peratusan nilai yang merupakan nol, yang berguna apabila kebanyakan nilai adalah nol.
    5. 

  5. Adalah mungkin untuk melihat sebaran ini pada set data ujian serta set latihan untuk setiap ciri. Ini bermaksud anda boleh memeriksa semula bahawa ujian mempunyai taburan yang serupa dengan data latihan.
    6. 



Ini sekurang-kurangnya minimum yang harus dilakukan sebelum sebarang tugas pembelajaran mesin. Dengan alat ini, anda tidak akan melewatkan langkah penting ini, dan ia menyoroti beberapa kelainan.



Facets Deep Dive


Facets Deep Dive adalah alat yang sejuk. Ini memungkinkan untuk mempunyai beberapa kejelasan pada set data anda dan zoom sehingga masuk untuk melihat satu bahagian data. Ini bermaksud anda dapat memasukkan data mengikut baris dan lajur di mana-mana ciri set data.


Kami akan menggunakan dua alat ini dengan dataset Boston.


Catatan : Anda tidak dapat menggunakan Gambaran Keseluruhan Facets dan Facets Deep Dive pada masa yang sama. Anda perlu membersihkan buku nota terlebih dahulu untuk menukar alat.



Pasang Faset


Anda boleh menggunakan aplikasi web Facet untuk sebahagian besar analisis. Dalam tutorial ini, anda akan melihat cara menggunakannya dalam Notebook Jupyter.


Pertama sekali, anda perlu memasang nbextensions. Ia dilakukan dengan kod ini. Anda menyalin dan menampal kod berikut di terminal mesin anda.


pip install jupyter_contrib_nbextensions 


Sejurus selepas itu, anda perlu mengklon repositori di komputer anda. Anda mempunyai dua pilihan:


Pilihan 1) Salin dan tampal kod ini di terminal (Disyorkan)


Sekiranya anda tidak memasang Git pada mesin anda, sila pergi ke URL ini https://git-scm.com/download/win dan ikuti arahannya. Setelah selesai, anda boleh menggunakan perintah git di terminal untuk pengguna Mac atau permintaan Anaconda untuk pengguna Windows


git clone https://github.com/PAIR-code/facets 


Pilihan 2) Pergi ke https://github.com/PAIR-code/facets dan muat turun repositori.




Sekiranya anda memilih pilihan pertama, fail tersebut akan berakhir di fail muat turun anda. Anda boleh membiarkan fail dimuat turun atau menyeretnya ke jalan lain.


Anda boleh memeriksa di mana Facets disimpan dengan baris arahan ini:


echo `pwd`/`ls facets` 


Sekarang setelah anda menemui Facets, anda perlu memasangnya di Jupyter Notebook. Anda perlu menetapkan direktori kerja ke jalan di mana faset berada.


Direktori kerja semasa anda dan lokasi zip Facets harus sama.




Anda perlu menunjukkan direktori yang berfungsi ke Facet:


cd facets


Untuk memasang Facets di Jupyter, anda mempunyai dua pilihan. Sekiranya anda memasang Jupyter dengan Conda untuk semua pengguna, salin kod ini:


boleh menggunakan jupyter nbextension install facets-dist /


jupyter nbextension install facets-dist/


Jika tidak, gunakan:


jupyter nbextension install facets-dist/ --user


Baiklah, anda sudah bersedia. Mari buka Gambaran Keseluruhan Facet.



Gambaran keseluruhan


Gambaran keseluruhan menggunakan skrip Python untuk mengira statistik. Anda perlu mengimport skrip yang dipanggil generic_feature_statistics_generator ke Jupyter. Jangan bimbang; skrip terletak di fail faset.


Anda perlu mencari jalannya. Ia mudah dilakukan. Anda membuka faset, membuka fail facets_overview dan kemudian python. Salin jalan




Selepas itu, kembali ke Jupyter, dan tulis kod berikut. Tukar jalan '/ Pengguna / Thomas / faset / facets_overview / python' ke jalan anda.


# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')


Anda boleh mengimport skrip dengan kod di bawah.


from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator


Di tingkap, kod 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 mengira statistik ciri, anda perlu menggunakan fungsi GenericFeatureStatisticsGenerator (), dan anda menggunakan objek ProtoFromDataFrames. Anda boleh menyampaikan kerangka data dalam kamus. Contohnya, jika kita ingin membuat statistik ringkasan untuk set kereta api, kita dapat menyimpan informasi tersebut dalam kamus dan menggunakannya dalam objek `ProtoFromDataFrames '


    

  • 

    'name': 'train', 'table': df_train 
    • 



Nama adalah nama jadual yang dipaparkan, dan anda menggunakan nama jadual yang ingin anda hitungkan ringkasannya. Dalam contoh anda, jadual yang mengandungi 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")


Akhir sekali, anda hanya menyalin dan menampal kod di bawah. Kodnya datang terus dari GitHub. Anda seharusnya dapat 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


Selepas anda memeriksa data dan sebarannya, anda dapat membuat matriks korelasi. Matriks korelasi mengira pekali Pearson. Pekali ini terikat antara -1 dan 1, dengan nilai positif menunjukkan korelasi positif dan nilai negatif korelasi negatif.


Anda berminat untuk melihat pemboleh ubah mana yang boleh menjadi calon 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})


Pengeluaran 




png




Dari matriks, anda dapat melihat:


    

  • LSTAT
    • 

  • RM
    • 



Sangat berkaitan dengan HARGA. Ciri menarik lain adalah korelasi positif yang kuat antara NOX dan INDUS, yang bermaksud kedua-dua pemboleh ubah bergerak ke arah yang sama. Selain itu, ada juga yang berkaitan dengan HARGA. DIS juga sangat berkaitan dengan IND dan NOX.


Anda mempunyai petunjuk pertama bahawa IND dan NOX boleh menjadi calon yang baik untuk penggantungan dan DIS mungkin juga menarik untuk difokuskan.


Anda boleh masuk lebih jauh dengan membuat grid pasangan. Ia akan menggambarkan dengan lebih terperinci peta korelasi yang anda buat sebelumnya.


Gandingan pasangan yang kami susun adalah seperti berikut:


    

  • Bahagian atas: Petak penyebaran dengan garisan yang dipasang
    • 

  • Diagonal: Plot ketumpatan kernel
    • 

  • Bahagian bawah: Plot kepadatan kernel multivariate
    • 



Anda memilih fokus pada empat pemboleh ubah bebas. Pilihannya sesuai dengan pemboleh ubah dengan korelasi kuat dengan HARGA


    

  • INDUS
    • 

  • NOX
    • 

  • RM
    • 

  • LSTAT
    • 



lebih-lebih lagi, HARGA.


Perhatikan bahawa kesalahan standard ditambahkan secara lalai ke plot penyebaran.


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)


Pengeluaran 




Mari kita mulakan dengan bahagian atas:


    

  • Harga berkorelasi negatif dengan INDUS, NOX, dan LSTAT; berkorelasi positif dengan RM.
    • 

  • Terdapat sedikit ketidaksesuaian dengan LSTAT dan HARGA
    • 

  • Terdapat seperti garis lurus ketika harganya sama dengan 50. Dari keterangan set data, PRICE telah dipotong pada nilai 50
    • 



Diagonal


    

  • NOX nampaknya mempunyai dua kelompok, satu sekitar 0,5 dan satu sekitar 0,85.
    • 



Untuk memeriksa lebih lanjut, anda boleh melihat bahagian bawahnya. Kepadatan Kernel Multivariate menarik dari segi warnanya di mana kebanyakan titik. Perbezaan dengan plot penyebaran menarik kepadatan kebarangkalian, walaupun tidak ada titik dalam set data untuk koordinat tertentu. Apabila warnanya lebih kuat, ini menunjukkan kepekatan titik yang tinggi di sekitar kawasan ini.


Sekiranya anda memeriksa ketumpatan multivariate untuk INDUS dan NOX, anda dapat melihat korelasi positif dan dua kelompok. Apabila bahagian industri melebihi 18, kepekatan oksida nitrat melebihi 0.6.


Anda boleh berfikir untuk menambahkan interaksi antara INDUS dan NOX dalam hubungan linear.


Akhirnya, anda boleh menggunakan alat kedua yang dibuat oleh Google, Facets Deep Dive. Antaramuka dibahagikan kepada empat bahagian utama. Kawasan pusat di tengah adalah paparan data yang boleh diperbesar. Di bahagian atas panel, ada menu drop-down di mana anda dapat mengubah susunan data untuk mengendalikan aspek, posisi, dan warna. Di sebelah kanan, terdapat paparan terperinci mengenai deretan data tertentu. Ini bermaksud anda boleh mengklik titik data dalam visualisasi pusat untuk melihat perincian mengenai titik data tertentu.


Semasa langkah visualisasi data, anda berminat untuk mencari korelasi berpasangan antara pemboleh ubah tidak bersandar pada harga rumah. Walau bagaimanapun, ia melibatkan sekurang-kurangnya tiga pemboleh ubah, dan plot 3D rumit untuk dikerjakan.


Salah satu cara untuk mengatasi masalah ini adalah dengan membuat pemboleh ubah kategori. Maksudnya, kita boleh membuat plot 2D dengan warna titik. Anda boleh membahagikan PRICE pemboleh ubah menjadi empat kategori, dengan setiap kategori adalah kuartil (iaitu, 0,25, 0,5, 0,75). Anda memanggil pemboleh ubah 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. Pandas sebagai objek untuk itu. Anda boleh menggunakan to_json selepas set data Pandas.


Baris pertama kod menangani ukuran set 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')


Kod di bawah berasal dari Google GitHub. Selepas anda menjalankan kod, anda seharusnya dapat melihatnya:




# 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 berminat untuk melihat apakah ada hubungan antara kadar industri, kepekatan oksida, jarak ke pusat pekerjaan dan harga rumah.


Untuk itu, anda terlebih dahulu membahagikan data mengikut julat dan warna industri dengan kuartil harga:


    

  • Pilih segi X dan pilih INDUS.
    • 

  • Pilih Paparan dan pilih DIS. Ia akan mewarnai titik dengan kuartil harga rumah
    • 



di sini, warna yang lebih gelap bermaksud jarak ke pusat pekerjaan pertama adalah jauh.


Setakat ini, ia menunjukkan lagi apa yang anda tahu, kadar industri yang lebih rendah, harga yang lebih tinggi. Sekarang anda dapat melihat perincian mengikut INDUX, dengan NOX.


    

  • Pilih muka Y dan pilih NOX.
    • 



Sekarang anda dapat melihat rumah yang jauh dari pusat pekerjaan pertama mempunyai bahagian industri yang paling rendah dan oleh itu kepekatan oksida terendah. Sekiranya anda memilih untuk memaparkan jenis dengan Q_PRICE dan mengezum sudut kiri bawah, anda dapat melihat jenis harganya.


Anda mempunyai petunjuk lain bahawa interaksi antara IND, NOX, dan DIS boleh menjadi calon yang baik untuk memperbaiki model.



TensorFlow


Di bahagian ini, anda akan menganggar pengkelasan linear dengan TensorFlow estimators API. Anda akan meneruskan seperti berikut:


    

  • Sediakan data
    • 

  • Anggarkan model penanda aras: Tidak ada interaksi
    • 

  • Anggarkan model dengan interaksi
    • 



Ingat, tujuan pembelajaran mesin adalah mengurangkan kesalahan. Dalam kes ini, model dengan ralat kuasa dua min terendah akan menang. Penganggar TensorFlow mengira metrik ini secara automatik.


Data penyediaan


Dalam kebanyakan kes, anda perlu mengubah data anda. Itulah sebabnya Gambaran Keseluruhan Facets menarik. Dari statistik ringkasan, anda melihat terdapat garis besar. Nilai tersebut mempengaruhi anggaran kerana tidak seperti populasi yang anda analisis. Outliers biasanya berat sebelah hasilnya. Sebagai contoh, hasil positif cenderung terlalu tinggi menilai pekali.


Penyelesaian yang baik untuk mengatasi masalah ini adalah menyeragamkan pemboleh ubah. Standardisasi bermaksud sisihan piawai satu dan bermaksud sifar. Proses penyeragaman melibatkan dua langkah. Pertama sekali, ia mengurangkan nilai min bagi pemboleh ubah. Kedua, ia dibahagi dengan varians sehingga pembahagian mempunyai varians unit


Sklearn perpustakaan berguna untuk menyeragamkan pemboleh ubah. Anda boleh menggunakan proses pra-proses dengan skala objek untuk tujuan ini.


Anda boleh menggunakan fungsi di bawah untuk menskalakan set data. Perhatikan bahawa anda tidak menimbang skala label dan pemboleh ubah 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 boleh menggunakan fungsi untuk membina set keretapi / ujian berskala.


df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 


Regresi asas: Tanda Aras


Pertama sekali, anda melatih dan menguji model tanpa interaksi. Tujuannya adalah untuk melihat metrik prestasi model.


Cara untuk melatih model ini sama seperti tutorial API Tingkat Tinggi . Anda akan menggunakan TensorFlow estimator LinearRegressor.


Sebagai peringatan, anda perlu memilih:


    

  • ciri-ciri untuk dimasukkan ke dalam model
    • 

  • mengubah ciri
    • 

  • bina regresor linear
    • 

  • bina fungsi input_fn
    • 

  • melatih model
    • 

  • menguji model
    • 



Anda menggunakan semua pemboleh ubah dalam set data untuk melatih model. Secara keseluruhannya, terdapat satu pemboleh ubah selanjar dan satu pemboleh ubah 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 menukar ciri menjadi lajur numerik atau lajur kategori


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)


Pengeluaran 


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 lajur dalam kereta atau data ujian 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 menganggarkan model pada data kereta api.


model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)


Pengeluaran 


INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train_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.


Akhirnya, anda menganggarkan prestasi model pada set ujian


model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)


Pengeluaran 


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}


Kehilangan model adalah 1650. Ini adalah metrik untuk dikalahkan di bahagian seterusnya



Perbaiki model: Istilah interaksi


Semasa bahagian pertama tutorial, anda melihat hubungan yang menarik antara pemboleh ubah. Teknik visualisasi yang berbeza menunjukkan bahawa INDUS dan NOS dihubungkan bersama dan bergilir-gilir untuk meningkatkan kesan pada harga. Bukan sahaja interaksi antara INDUS dan NOS mempengaruhi harga tetapi juga kesan ini lebih kuat apabila berinteraksi dengan DIS.


Sudah tiba masanya untuk menggeneralisasikan idea ini dan melihat apakah anda dapat memperbaiki model yang diramalkan.


Anda perlu menambahkan dua lajur baru pada setiap set data: train + test. Untuk itu, anda membuat satu fungsi untuk menghitung istilah interaksi dan satu lagi untuk mengira istilah interaksi tiga kali ganda. Setiap fungsi menghasilkan satu lajur. Setelah pemboleh ubah baru dibuat, anda boleh menggabungkannya ke set data latihan dan set data ujian.


Pertama sekali, anda perlu membuat pemboleh ubah baru untuk interaksi antara INDUS dan NOX.


Fungsi di bawah mengembalikan dua kerangka data, melatih dan menguji, dengan interaksi antara var_1 dan var_2, dalam kes 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 lajur 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 mengira istilah interaksi tiga kali ganda.


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


Setelah semua lajur diperlukan, anda boleh menambahkannya untuk melatih dan menguji set data. Anda namakan 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)


Pengeluaran 




Iaitu ia; anda dapat menganggar model baru dengan istilah interaksi dan melihat bagaimana metrik prestasi.


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)


Pengeluaran 


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}


KOD


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)


Pengeluaran 


INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train_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)


Pengeluaran 


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 pemboleh ubah baru, anda dapat mengurangkan kerugian. Ini bermaksud anda boleh membuat ramalan yang lebih baik daripada model penanda aras.