„TensorFlow“ linijinė regresija su briaunuote & Sąveikos terminas

Šioje pamokoje sužinosite, kaip patikrinti duomenis ir paruošti juos sukurti paprastą tiesinės regresijos užduotį.

Ši pamoka yra padalinta į dvi dalis:

• Ieškokite sąveikos
• Išbandykite modelį

Ankstesnėje pamokoje naudojote Bostono duomenų rinkinį, kad įvertintumėte vidutinę namo kainą. Bostono duomenų rinkinys yra nedidelis, tik su 506 stebėjimais. Šis duomenų rinkinys laikomas etalonu išbandyti naujus tiesinės regresijos algoritmus.

Duomenų rinkinį sudaro:

Šioje pamokoje mes įvertinsime vidutinę kainą naudodami tiesinį regresorių, tačiau dėmesys sutelktas į vieną konkretų mašininio mokymosi procesą: „duomenų paruošimas“.

Modelis apibendrina duomenų šabloną. Norėdami užfiksuoti tokį modelį, pirmiausia turite jį rasti. Gera praktika yra atlikti duomenų analizę prieš paleidžiant bet kurį mašininio mokymosi algoritmą.

Tinkamų funkcijų pasirinkimas lemia jūsų modelio sėkmę. Įsivaizduokite, kad bandote įvertinti žmonių darbo užmokestį, jei neįtraukiate lyties į kovariatą, galiausiai prastai įvertinsite.

Kitas būdas patobulinti modelį yra pažvelgti į koreliaciją tarp nepriklausomo kintamojo. Grįžtant prie pavyzdžio, jūs galite galvoti apie švietimą kaip apie puikų kandidatą, norint numatyti darbo užmokestį, bet ir užimtumą. Sąžininga sakyti, kad profesija priklauso nuo išsilavinimo lygio, būtent aukštasis mokslas dažnai lemia geresnį užsiėmimą. Jei apibendrinsime šią idėją, galime pasakyti, kad koreliacija tarp priklausomo kintamojo ir aiškinamojo kintamojo gali būti padidinta dar vienu paaiškinamuoju kintamuoju.

Norėdami užfiksuoti ribotą švietimo poveikį profesijai, galime naudoti sąveikos terminą.

Pažvelgus į darbo užmokesčio lygtį, ji tampa:

Jei teigiama, tai reiškia, kad dėl papildomo išsilavinimo padidėja vidutinė namo vertė už aukštą užimtumo lygį. Kitaip tariant, tarp švietimo ir profesijos yra sąveikos efektas.

Šioje pamokoje bandysime sužinoti, kurie kintamieji gali būti tinkami sąveikos terminų kandidatai. Mes išbandysime, ar pridėjus tokią informaciją galima geriau prognozuoti kainą.

Šioje pamokoje sužinosite

• Santraukos statistika
• „Facets“ apžvalga
• „Facets“ gilus nardymas
• Įdiekite „Facet“
• Apžvalga
• Grafikas
• „Facets“ gilus nardymas
• „TensorFlow“
• Paruošimo duomenys
• Pagrindinė regresija: etalonas
• Patobulinti modelį: Sąveikos terminas

Santraukos statistika

Prieš tęsdami modelį, galite atlikti kelis veiksmus. Kaip minėta anksčiau, modelis yra duomenų apibendrinimas. Tinkamiausia praktika yra suprasti duomenis ir numatyti. Jei nežinote savo duomenų, turite mažai galimybių patobulinti savo modelį.

Pirmiausia įkelkite duomenis kaip „pandos“ duomenų rėmą ir sukurkite treniruočių rinkinį ir testavimo rinkinį.

Patarimai: Norint gauti šią pamoką, „Python“ turite įdiegti matplotlit ir seaborn. „Python“ paketą galite įdiegti iš karto naudodami „Jupyter“. Jūs neturėtumėte to daryti

!conda install -- yes matplotlib

bet

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

Atkreipkite dėmesį, kad šis žingsnis nėra būtinas, jei turite matplotlibą ir jūrinį gyvūną.

„Matplotlib“ yra biblioteka, sukurianti „Python“ grafiką. „Seaborn“ yra statistinės vizualizacijos biblioteka, pastatyta ant matplotlibo. Tai suteikia patrauklių ir gražių sklypų.

Žemiau pateiktas kodas importuoja reikiamas bibliotekas.

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

Bibliotekos sklearn apima Bostono duomenų rinkinį. Jei norite importuoti duomenis, galite paskambinti jo API.

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

Funkcijos pavadinimas saugomas masyvo objekte feature_names.

boston.feature_names

Rezultatas

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Stulpelius galite pervadinti.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Jūs konvertuosite kintamąjį CHAS kaip eilutės kintamąjį ir pažymėsite jį taip, jei CHAS = 1, ir ne, jei CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Su pandomis nesudėtinga padalyti duomenų rinkinį. Atsitiktinai padalijate duomenų rinkinį su 80 procentų treniruočių rinkiniu ir 20 procentų testavimo rinkiniu. Pandose yra įmontuota sąnaudų funkcija, skirta duomenų rėmelio dalijimui.


Pirmasis parametras frac yra vertė nuo 0 iki 1. Jūs nustatote jį į 0,8, kad atsitiktinai pasirinktumėte 80 procentų duomenų rėmelio.
„Random_state“ leidžia visiems grąžinti tą patį duomenų rėmą.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Galite gauti duomenų formą. Turėtų būti:

Traukinių komplektas: 506 * 0,8 = 405
Testo rinkinys: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Rezultatas 
(405, 14) (101, 14) 
 
df_test.head(5)
Rezultatas
 

 
 
 
 
NUSIKALTIMAS 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
AMŽIUS 
 
DIS 
 
RAD 
 
MOKESČIAI 
 
PTRATIO 
 
B 
 
LSTAT 
 
KAINA 
 

 
 
0 
 
0,00632 
 
18.0 
 
2.31 
 
ne 
 
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 
 
ne 
 
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 
 
ne 
 
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 
 
ne 
 
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 
 
ne 
 
0,524 
 
6.172 
 
96.1 
 
5.9505 
 
5.0 
 
311.0 
 
15.2 
 
396.90 
 
19.15 val 
 
27.1 
 

 

 

Duomenys netvarkingi; tai dažnai nesubalansuota ir apibarstyta išskirtinėmis vertybėmis, kurios atmeta analizės ir mašininio mokymosi mokymus.
Pirmasis žingsnis norint išvalyti duomenų rinkinį yra suprasti, kur jį reikia išvalyti. Duomenų rinkinio valymas gali būti sudėtingas, ypač bet kokiu apibendrinamu būdu
„Google“ tyrimų komanda sukūrė šiam darbui skirtą įrankį „ Facets“, kuris padeda vizualizuoti duomenis ir juos supjaustyti įvairiausiais būdais. Tai yra geras atspirties taškas norint suprasti, kaip duomenų rinkinys yra išdėstytas.
„Facets“ leidžia jums rasti vietą, kurioje duomenys atrodo ne taip, kaip galvojate.
Išskyrus jų žiniatinklio programą, „Google“ leidžia lengvai įterpti įrankių rinkinį į „Jupyter“ bloknotą.
Yra dvi „Facets“ dalys:

„Facets“ apžvalga


„Facets“ gilus nardymas


„Facets“ apžvalga
„Facets apžvalga“ pateikia duomenų rinkinio apžvalgą. „Facets Overview“ padalija duomenų stulpelius į rodomos svarbiausios informacijos eilutes

trūkstamo stebėjimo procentas
min ir max vertės
tokia statistika kaip vidurkis, mediana ir standartinis nukrypimas
Taip pat pridedamas stulpelis, kuriame rodoma reikšmių, kurios yra nuliai, procentinė dalis. Tai naudinga, kai dauguma reikšmių yra nuliai.
Šiuos paskirstymus galima pamatyti bandymo duomenų rinkinyje, taip pat kiekvienos funkcijos mokymo rinkinį. Tai reiškia, kad galite dar kartą patikrinti, ar testas yra panašiai paskirstytas kaip treniruotės duomenys.

Tai bent jau minimalus dalykas, kurį reikia atlikti prieš bet kokias mašininio mokymosi užduotis. Naudodamiesi šia priemone nepraleisite šio svarbaus žingsnio ir jis išryškina kai kuriuos nukrypimus.

„Facets“ gilus nardymas
„Facets Deep Dive“ yra šauni priemonė. Tai leidžia šiek tiek paaiškinti jūsų duomenų rinkinį ir iki galo priartinti, kad pamatytumėte atskirą duomenų dalį. Tai reiškia, kad galite išskaidyti duomenis pagal eilutes ir stulpelius bet kurioje duomenų rinkinio ypatybėje.
Šiuos du įrankius naudosime kartu su Bostono duomenų rinkiniu.
Pastaba : tuo pačiu metu negalite naudoti „Facets Overview“ ir „Facets Deep Dive“. Pirmiausia turite išvalyti bloknotą, kad pakeistumėte įrankį.

Įdiekite „Facet“
Didžiąją analizės dalį galite naudoti „Facet“ žiniatinklio programą. Šioje pamokoje pamatysite, kaip ją naudoti „Jupyter Notebook“.
Visų pirma turite įdiegti nbextensions. Tai daroma naudojant šį kodą. Nukopijuojate ir įklijuojate šį kodą į savo kompiuterio terminalą.
pip install jupyter_contrib_nbextensions 
Iškart po to turite klonuoti saugyklas savo kompiuteryje. Turite du pasirinkimus:
1 variantas: Nukopijuokite ir įklijuokite šį kodą į terminalą (rekomenduojama)
Jei jūsų kompiuteryje nėra įdiegta „Git“, eikite į šį URL https://git-scm.com/download/win ir vykdykite instrukcijas. Baigę galite naudoti „git“ komandą terminale, skirtame „Mac“ vartotojui, arba „Anaconda“ raginimą, skirtą „Windows“ vartotojui
git clone https://github.com/PAIR-code/facets 
2 variantas) Eikite į https://github.com/PAIR-code/facets ir atsisiųskite saugyklas.

Jei pasirenkate pirmąją parinktį, failas patenka į atsisiuntimo failą. Galite leisti atsisiųsti failą arba nuvilkti jį į kitą kelią.
Galite patikrinti, kur „Facets“ saugomi, naudodami šią komandų eilutę:
echo `pwd`/`ls facets` 
Dabar, kai radote „Facets“, turite ją įdiegti į „Jupyter Notebook“. Darbiniame kataloge turite nustatyti kelią, kuriame yra aspektai.
Dabartinis jūsų darbo katalogas ir „Facets“ pašto adreso vieta turėtų būti vienodi.

Darbinį katalogą turite nukreipti į „Facet“:
cd facets
Norėdami įdiegti „Facets“ į „Jupyter“, turite dvi parinktis. Jei „Jupyter“ su „Conda“ įdiegėte visiems vartotojams, nukopijuokite šį kodą:
gali naudoti jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
Kitu atveju naudokite:
jupyter nbextension install facets-dist/ --user
Gerai, jūs viskas pasiruošę. Atidarykime „Facet Overview“.

Apžvalga
Apžvalga statistikai apskaičiuoti naudoja „Python“ scenarijų. Į „Jupyter“ turite importuoti scenarijų, pavadintą generic_feature_statistics_generator. Nesijaudink; scenarijus yra aspektų failuose.
Turite rasti jo kelią. Tai lengva padaryti. Atidarote aspektus, atidarote failą facets_overview ir tada python. Nukopijuokite kelią

Po to grįžkite į „Jupyter“ ir parašykite šį kodą. Pakeiskite savo kelio kelią „/ Users / Thomas / facets / facets_overview / python“.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Galite importuoti scenarijų naudodami žemiau esantį kodą.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
Languose tas pats kodas tampa
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Norėdami apskaičiuoti funkcijų statistiką, turite naudoti funkciją GenericFeatureStatisticsGenerator () ir naudoti objektą ProtoFromDataFrames. Duomenų rėmelį galite perduoti žodyne. Pvz., Jei norime sukurti traukinių rinkinio suvestinę statistiką, informaciją galime išsaugoti žodyne ir naudoti objekte „ProtoFromDataFrames“.


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

Pavadinimas yra rodomos lentelės pavadinimas, o jūs norite naudoti lentelės pavadinimą, norėdami apskaičiuoti suvestinę. Jūsų pavyzdyje lentelė, kurioje yra duomenys, yra 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")
Galiausiai tiesiog nukopijuokite ir įklijuokite žemiau esantį kodą. Kodas gaunamas tiesiai iš „GitHub“. Turėtumėte tai pamatyti:

# 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))
 
Grafikas
Patikrinę duomenis ir jų pasiskirstymą, galite nubrėžti koreliacijos matricą. Koreliacijos matrica apskaičiuoja Pearsono koeficientą. Šis koeficientas yra susietas tarp -1 ir 1, o teigiama reikšmė rodo teigiamą koreliaciją, o neigiama vertė - neigiamą koreliaciją.
Jus domina, kurie kintamieji gali būti tinkami sąveikos terminų kandidatai.
## 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})
Rezultatas 

png

Iš matricos galite pamatyti:

LSTAT
RM

Yra stipriai susiję su PRICE. Kitas įdomus bruožas yra stipri teigiama koreliacija tarp NOX ir INDUS, o tai reiškia, kad šie du kintamieji juda ta pačia kryptimi. Be to, jie taip pat yra susiję su KAINA. DIS taip pat labai koreliuoja su IND ir NOX.
Turite pirmąją užuominą, kad IND ir NOX gali būti geri kandidatai perėmimo laikotarpiui, o DIS taip pat gali būti įdomu sutelkti dėmesį.
Galite šiek tiek giliau nubrėžti porų tinklelį. Tai išsamiau iliustruos jūsų anksčiau pateiktą koreliacijos žemėlapį.
Mūsų sudarytas porų tinklelis yra toks:

Viršutinė dalis: Sklaidos diagrama su pritvirtinta linija
Įstriža: branduolio tankio diagrama
Apatinė dalis: Daugiamandžių branduolių tankio diagrama

Jūs pasirenkate dėmesį į keturis nepriklausomus kintamuosius. Pasirinkimas atitinka kintamuosius, glaudžiai susijusius su PRICE

INDUS
NOX
RM
LSTAT

be to, KAINA.
Atkreipkite dėmesį , kad standartinė klaida pagal numatytuosius nustatymus pridedama prie sklaidos diagramos.
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)
Rezultatas 

Pradėkime nuo viršutinės dalies:

Kaina neigiamai koreliuoja su INDUS, NOX ir LSTAT; teigiamai koreliuoja su RM.
LSTAT ir PRICE yra šiek tiek nelinijiniai
Yra lygia linija, kai kaina lygi 50. Pagal duomenų rinkinio aprašą PRICE buvo sutrumpinta 50 verte.

Įstrižai

Atrodo, kad NOX turi du klasterius, vieną apie 0,5 ir kitą apie 0,85.

Norėdami daugiau sužinoti apie tai, galite pažvelgti į apatinę dalį. Daugiamatė branduolio tankis tam tikra prasme yra įdomus, nes jis nuspalvina daugumą taškų. Skirtumas su sklaidos diagrama nubrėžia tikimybės tankį, nors duomenų rinkinyje nėra tam tikros koordinatės taško. Kai spalva yra stipresnė, tai rodo didelę taško koncentraciją aplink šią sritį.
Jei patikrinsite daugialypį INDUS ir NOX tankį, galite pamatyti teigiamą koreliaciją ir du klasterius. Kai pramonės dalis viršija 18, azoto oksidų koncentracija viršija 0,6.
Galite pagalvoti apie sąveikos tarp INDUS ir NOX įtraukimą tiesiniame santykyje.
Galiausiai galite naudoti antruosius „Google“ sukurtus įrankius „Facets Deep Dive“. Sąsaja suskirstyta į keturias pagrindines dalis. Centrinė sritis centre yra priartinamas duomenų rodymas. Skydelio viršuje yra išskleidžiamasis meniu, kuriame galite pakeisti duomenų išdėstymą valdydami briaunojimą, padėties nustatymą ir spalvas. Dešinėje yra išsamus konkrečios duomenų eilutės vaizdas. Tai reiškia, kad galite spustelėti bet kurį duomenų tašką centre esančioje vizualizacijoje, kad pamatytumėte išsamią informaciją apie konkretų duomenų tašką.
Duomenų vizualizavimo metu jus domina porinės koreliacijos ryšys tarp nepriklausomo kintamojo ir namo kainos. Tačiau tai apima bent tris kintamuosius, o 3D diagramas yra sudėtinga dirbti.
Vienas iš būdų išspręsti šią problemą yra sukurti kategorinį kintamąjį. Tai yra, mes galime sukurti 2D siužetą spalvoti tašką. Galite suskirstyti kintamąjį PRICE į keturias kategorijas, kurių kiekviena yra kvartilis (ty 0,25, 0,5, 0,75). Jūs vadinate šį naują kintamąjį 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“ gilus nardymas
Norėdami atidaryti „Deep Dive“, turite transformuoti duomenis į „Json“ formatą. Pandos kaip to objektas. Galite naudoti „to_json“ po duomenų rinkinio „Pandas“.
Pirmoji kodo eilutė tvarko duomenų rinkinio dydį.
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')
Žemiau pateiktas kodas gaunamas iš „Google GitHub“. Paleidę kodą turėtumėte tai pamatyti:

# 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))
Jus domina, ar yra ryšys tarp pramonės normos, oksido koncentracijos, atstumo iki darbo centro ir namo kainos.
Norėdami tai padaryti, pirmiausia padalykite duomenis pagal pramonės sritį ir spalvas pagal kainos kvartilį:

Pasirinkite briauną X ir pasirinkite INDUS.
Pasirinkite Ekranas ir DIS. Taškus nuspalvins namo kainos kvartile

čia tamsesnės spalvos reiškia, kad atstumas iki pirmojo darbo centro yra toli.
Kol kas tai vėl parodo tai, ką žinai, mažesnį pramonės tarifą, aukštesnę kainą. Dabar galite pažvelgti į suskirstymą pagal INDUX, pagal NOX.

Pasirinkite briaunuotą Y ir NOX.

Dabar galite pamatyti, kad toli nuo pirmojo darbo centro esančiame name yra mažiausia pramonės dalis ir todėl mažiausia oksido koncentracija. Jei nuspręsite rodyti tipą su Q_PRICE ir priartinsite apatinį kairįjį kampą, pamatysite, kokia tai kaina.
Turite dar vieną užuominą, kad sąveika tarp IND, NOX ir DIS gali būti geri kandidatai tobulinti modelį.

„TensorFlow“
Šiame skyriuje įvertinsite tiesinį klasifikatorių naudodami „TensorFlow“ vertintojų API. Jūs elgsitės taip:

Paruoškite duomenis
Įvertinkite etalono modelį: nėra sąveikos
Įvertinkite modelį su sąveika

Atminkite, kad mašininio mokymosi tikslas yra sumažinti klaidą. Tokiu atveju laimės modelis, kurio paklaida yra mažiausia vidutinė kvadrato klaida. „TensorFlow“ įvertis automatiškai apskaičiuoja šią metriką.
Paruošimo duomenys
Daugeliu atvejų turite transformuoti savo duomenis. Štai kodėl „Facets“ apžvalga yra patraukli. Iš suvestinės statistikos matėte, kad yra pašalinių. Šios vertės daro įtaką įvertinimams, nes jos nėra panašios į jūsų analizuojamą populiaciją. Neįprasti rezultatai dažniausiai buvo šališki. Pavyzdžiui, teigiamas pašalinis koeficientas yra linkęs pervertinti koeficientą.
Geras sprendimas šiai problemai spręsti yra kintamojo standartizavimas. Standartizavimas reiškia standartinį vieno ir vidutinio nulio nuokrypį. Standartizavimo procesas apima du etapus. Visų pirma, ji atima kintamojo vidutinę vertę. Antra, jis dalijasi iš dispersijos taip, kad skirstinys turėtų vienetinį dispersiją
Bibliotekos sklearn yra naudinga standartizuoti kintamuosius. Tam tikslui galite naudoti išankstinį modulio apdorojimą su objekto skale.
Norėdami naudoti mastelį duomenų rinkinyje, galite naudoti toliau pateiktą funkciją. Atminkite, kad etiketės stulpelio ir kategorinių kintamųjų nedidinate.
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
Galite naudoti funkciją, norėdami sukonstruoti pakeistą traukinį / bandymų rinkinį.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Pagrindinė regresija: etalonas
Visų pirma, jūs mokote ir išbandote modelį be sąveikos. Tikslas - pamatyti modelio našumo metriką.
Modelio mokymas yra toks pats kaip aukšto lygio API pamoka . Jūs naudosite „TensorFlow“ vertiklį „LinearRegressor“.
Primename, kad turite pasirinkti:

ypatybės, kurias reikia įdėti į modelį
transformuoti ypatybes
sukonstruoti tiesinį regresorių
sukonstruokite funkciją input_fn
mokyti modelį
išbandyti modelį

Norėdami mokyti modelį, naudojate visus duomenų rinkinio kintamuosius. Iš viso yra ištisiniai kintamieji ir vienas kategorinis kintamasis
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Jūs konvertuojate funkcijas į skaitinį stulpelį arba kategorinį stulpelį
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'])]
Jūs sukuriate modelį naudodami „linearRegressor“. Modelį saugote aplanke „train_Boston“
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Rezultatas 
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}
Kiekvienas traukinio ar bandymo duomenų stulpelis yra konvertuojamas į „Tensor“ su funkcija 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)
Jūs apskaičiuojate modelį pagal traukinio duomenis.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Rezultatas 
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.
Pagaliau jūs įvertinate modelio našumą bandymų rinkinyje
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Rezultatas 
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}
Modelio nuostolis yra 1650. Tai yra metrika, kurią reikia įveikti kitame skyriuje

Patobulinti modelį: Sąveikos terminas
Per pirmąją mokymo programos dalį pamatėte įdomų ryšį tarp kintamųjų. Skirtingi vizualizavimo metodai atskleidė, kad INDUS ir NOS yra tarpusavyje susiję ir sukasi, kad padidintų poveikį kainai. Kainą veikia ne tik INDUS ir NOS sąveika, bet ir šis poveikis yra stipresnis, kai jis sąveikauja su DIS.
Atėjo laikas apibendrinti šią idėją ir sužinoti, ar galite patobulinti numatytą modelio modelį.
Prie kiekvieno duomenų rinkinio turite pridėti du naujus stulpelius: traukinys + testas. Tam sukuriate vieną funkciją sąveikos terminui apskaičiuoti, o kitą - trigubos sąveikos terminui apskaičiuoti. Kiekviena funkcija sukuria vieną stulpelį. Sukūrę naujus kintamuosius, galite juos susieti su mokymo duomenų rinkiniu ir bandomuoju duomenų rinkiniu.
Visų pirma reikia sukurti naują kintamąjį, skirtą INDUS ir NOX sąveikai.
Žemiau pateikta funkcija pateikia du duomenų kadrus, traukinį ir testą, sąveikaujant var_1 ir var_2, jūsų atveju INDUS ir 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
Jūs saugote du naujus stulpelius
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Antra, jūs sukuriate antrą funkciją trigubos sąveikos terminui apskaičiuoti.
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')
Dabar, kai turite visus reikalingus stulpelius, galite juos pridėti prie mokymų ir bandymų duomenų rinkinio. Pavadinate šiuos du naujus duomenų rėmelius:

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

Viskas; galite įvertinti naują modelį su sąveikos terminais ir sužinoti, kaip veikia našumo metrika.
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)
Rezultatas 
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}
KODAS
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)
Rezultatas 
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)
Rezultatas 
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}
Naujas nuostolis yra 1515. Tiesiog pridėję du naujus kintamuosius, sugebėjote sumažinti nuostolius. Tai reiškia, kad galite geriau prognozuoti nei naudodamiesi etalonu.
                    


                    

                      

                        
                          
Share on Facebook
                            

                          
                        
                      
                      

                        
                          
Share on Twitter