Linijinė regresija naudojant „TensorFlow“ (pavyzdžiai)

Kas yra tiesinė regresija?

Linijinė regresija yra statistikos metodas, skirtas modeliuoti ryšius tarp dviejų kintamųjų. Šis modeliavimas atliekamas tarp skaliarinio atsako ir vieno ar daugiau aiškinamųjų kintamųjų. Santykis su vienu aiškinamuoju kintamuoju vadinamas paprasta tiesine regresija, o daugiau nei vienam aiškinamuoju kintamuoju - daugine tiesine regresija.

„TensorFlow“ pateikia įrankius, leidžiančius visiškai kontroliuoti skaičiavimus. Tai daroma naudojant žemo lygio API. Be to, „TensorFlow“ yra aprūpintas daugybe API, kad būtų galima atlikti daugybę mašininio mokymosi algoritmų. Tai yra aukšto lygio API. „TensorFlow“ juos vadina vertintojais

  • Žemo lygio API: sukurkite architektūrą, modelio optimizavimą nuo nulio. Pradedantiesiems tai yra sudėtinga
  • Aukšto lygio API: apibrėžkite algoritmą. Tai patogiau. „TensorFlow“ teikia įrankių rinkinio skambučių įvertinimo priemonę, skirtą konstruoti, mokyti, įvertinti ir numatyti.

Šioje pamokoje naudosite tik įvertinimus . Skaičiavimai yra greitesni ir lengviau įgyvendinami. Pirmoje mokymo programos dalyje paaiškinta, kaip naudoti gradiento nusileidimo optimizavimo priemonę, norint išmokti tiesinę regresiją sistemoje „TensorFlow“. Antroje dalyje naudosite Bostono duomenų rinkinį, kad prognozuotumėte namo kainą naudodami „TensorFlow“ vertiklį.

Atsisiųskite Bostono duomenų rinkinį

Šioje „TensorFlow“ regresijos pamokoje sužinosite:

  • Kas yra tiesinė regresija?
  • Kaip išmokyti tiesinės regresijos modelį
  • Kaip treniruoti tiesinę regresiją naudojant „TensorFlow“
  • Pandos
  • Numpy sprendimas
  • Tensorflow tirpalas

Kaip išmokyti tiesinės regresijos modelį

Prieš pradėdami mokyti modelio, pažiūrėkime, kas yra tiesinė regresija.

Įsivaizduokite, kad turite du kintamuosius, x ir y, ir jūsų užduotis yra numatyti vertės žinojimo vertę. Jei braižote duomenis, galite pamatyti teigiamą ryšį tarp savo nepriklausomo kintamojo x ir priklausomo kintamojo y

Galite pastebėti, jei x = 1, y apytiksliai bus lygus 6, o jei x = 2, y bus maždaug 8,5.

Tai nėra labai tikslus metodas ir linkęs į klaidas, ypač naudojant duomenų rinkinį, kuriame yra šimtai tūkstančių taškų.

Linijinė regresija vertinama lygtimi. Kintamasis y paaiškinamas vienu ar daugeliu kovariatų. Jūsų pavyzdyje yra tik vienas priklausomas kintamasis. Jei turite parašyti šią lygtį, ji bus:

Su:

  • yra svoris, susietas su x
  • yra modelio likutis arba paklaida. Tai apima tai, ko modelis negali sužinoti iš duomenų

Įsivaizduokite, kad tinkate modeliui ir rasite tokį sprendimą:

  • = 3,8
  • = 2,78

Galite pakeisti tuos skaičius lygtyje ir ji tampa:

y = 3,8 + 2,78x

Dabar turite geresnį būdą rasti y reikšmes. Tai reiškia, kad x galite pakeisti bet kokia reikšme, kurią norite numatyti y. Žemiau esančiame paveikslėlyje lygtyje pakeitėme x visomis duomenų rinkinio reikšmėmis ir nubraižome rezultatą.

Raudona linija reiškia pritaikytą vertę, ty y reikšmes kiekvienai x reikšmei. Norint prognozuoti y, nereikia matyti x vertės, kiekvienam x yra bet kuris, priklausantis raudonai linijai. Taip pat galite numatyti didesnes nei 2 reikšmes x!

Jei norite išplėsti linijinę regresiją į daugiau kovariatų, galite prie modelio pridėti daugiau kintamųjų. Skirtumas tarp tradicinės analizės ir tiesinės regresijos yra tiesinė regresija, kuria siekiama sužinoti, kaip y reaguos į kiekvieną kintamąjį x, imamą nepriklausomai.

Pažiūrėkime pavyzdį. Įsivaizduokite, kad norite numatyti ledų parduotuvės pardavimus. Duomenų rinkinyje yra skirtinga informacija, pvz., Oras (ty lietingas, saulėtas, debesuotas), klientų informacija (ty atlyginimas, lytis, šeiminė padėtis).

Tradicinės analizės metu bus bandoma numatyti pardavimą, tarkime, apskaičiuojant kiekvieno kintamojo vidurkį ir bandant įvertinti pardavimą pagal skirtingus scenarijus. Tai sukels blogas prognozes ir apribos analizę pasirinktu scenarijumi.

Jei naudojate tiesinę regresiją, galite parašyti šią lygtį:

Algoritmas ras geriausią svorių sprendimą; tai reiškia, kad bandys sumažinti išlaidas (skirtumas tarp sumontuotos linijos ir duomenų taškų).

Kaip veikia algoritmas

Algoritmas pasirinkti atsitiktinį skaičių kiekvienam ir pakeiskite X vertę gauti prognozuojamą reikšmę y. Jei duomenų rinkinyje yra 100 stebėjimų, algoritmas apskaičiuoja 100 numatytų verčių.

Mes galime apskaičiuoti klaidą, pastebėtą modelio, kuris yra skirtumas tarp numatomos vertės ir tikrosios vertės. Teigiama paklaida reiškia, kad modelis nepakankamai įvertina y prognozavimą, o neigiama klaida reiškia, kad modelis pervertina y prognozavimą.

Jūsų tikslas yra sumažinti klaidos kvadratą. Algoritmas apskaičiuoja kvadrato paklaidos vidurkį. Šis žingsnis vadinamas klaidos sumažinimu. Linijinei regresijai yra vidutinė kvadratinė paklaida , dar vadinama MSE. Matematiškai tai yra:

Kur:

  • nurodo numatomą vertę
  • y yra tikrosios vertės
  • m yra stebėjimų skaičius

Atminkite, kad matematinis vidurkio žymėjimas.

Tikslas yra rasti geriausius, kurie sumažintų MSE

Jei vidutinė paklaida yra didelė, tai reiškia, kad modelis veikia blogai, o svoriai nėra tinkamai parinkti. Norėdami ištaisyti svorius, turite naudoti optimizavimo priemonę. Tradicinis optimizatorius vadinamas „ Gradient Descent“ .

Gradientinis nusileidimas paima darinį ir sumažina arba padidina svorį. Jei darinys yra teigiamas, svoris mažėja. Jei darinys yra neigiamas, svoris didėja. Modelis atnaujins svorius ir iš naujo apskaičiuos klaidą. Šis procesas kartojamas tol, kol klaida nebesikeis. Kiekvienas procesas vadinamas iteracija . Be to, gradientai padauginami iš mokymosi greičio. Tai rodo mokymosi greitį.

Jei mokymosi greitis yra per mažas, užtruks labai daug laiko, kol algoritmas susilies (t. Y. Reikia daug kartojimų). Jei mokymosi greitis yra per didelis, algoritmas gali niekada nesutapti.

Iš aukščiau esančio paveikslėlio matote, kad modelis pakartojo procesą maždaug 20 kartų, kad surastų stabilią svorių vertę, taigi pasiekė mažiausią paklaidą.

Atkreipkite dėmesį , kad paklaida nėra lygi nuliui, bet stabilizuojasi apie 5. Tai reiškia, kad modelis daro tipinę 5 klaidą. Jei norite sumažinti klaidą, turite į modelį įtraukti daugiau informacijos, pvz., Daugiau kintamųjų, arba naudoti skirtingi vertintojai.

Prisimenate pirmąją lygtį

Galutinis svoris yra 3,8 ir 2,78. Žemiau pateiktame vaizdo įraše parodyta, kaip gradientinis nusileidimas optimizuoja nuostolių funkciją, kad surastų šiuos svorius

Kaip treniruoti tiesinę regresiją naudojant „TensorFlow“

Dabar, kai geriau suprantate, kas vyksta už gaubto, esate pasirengę naudoti „TensorFlow“ pateiktą sąmatos API, kad mokytumėte savo pirmąją tiesinę regresiją naudodami „TensorFlow“.

Naudosite Bostono duomenų rinkinį, kuriame yra šie kintamieji

krimas vienam gyventojui nusikalstamumas pagal miestus
zn gyvenamojo žemės dalis, skirta zonoms, viršijančioms 25 000 kv.
indas mažmeninės prekybos hektarų dalis mieste.
Nr azoto oksidų koncentracija
rm vidutinis kambarių skaičius viename būste
amžiaus dalis savininkų užimtų vienetų, pastatytų iki 1940 m
dis svertiniai atstumai iki penkių Bostono įdarbinimo centrų
mokestis visos vertės nekilnojamojo turto mokesčio tarifas už 10 000 dolerių
ptratio mokinių ir mokytojų santykis pagal miestus
medv Vidutinė savininkų gyvenamų namų vertė tūkstančiais dolerių

Sukursite tris skirtingus duomenų rinkinius:

duomenų rinkinys objektyvus figūra
Mokymai Mokykite modelį ir gaukite svorius 400, 10
Įvertinimas Įvertinkite modelio našumą pagal nematytus duomenis 100, 10
Numatyti Norėdami apskaičiuoti namo vertę pagal naujus duomenis, naudokite modelį 6, 10

Tikslai yra naudoti duomenų rinkinio ypatybes namo vertei nuspėti.

Per antrąją mokymo programos dalį sužinosite, kaip naudoti „TensorFlow“ trimis skirtingais būdais importuoti duomenis:

  • Su Pandomis
  • Su Numpy
  • Tik TF

Atminkite, kad visos parinktys suteikia tuos pačius rezultatus.

Sužinosite, kaip naudoti aukšto lygio API, kuriant, mokant įvertinti „TensorFlow“ linijinės regresijos modelį. Jei naudojote žemo lygio API, turėjote rankomis apibrėžti:

  • Nuostolių funkcija
  • Optimizuoti: gradiento nusileidimas
  • Matricų daugyba
  • Grafikas ir tensorius

Tai varginantis ir sudėtingesnis pradedantiesiems.

Pandos

Norėdami mokyti modelį, turite importuoti reikiamas bibliotekas.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

1 žingsnis) Importuokite duomenis su panda.

Jūs apibrėžiate stulpelių pavadinimus ir saugote juos stulpeliuose. Norėdami importuoti duomenis, galite naudoti pd.read_csv ().

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

training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = True, skiprows = 1, vardai = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, vardai = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, vardai = COLUMNS)

Galite išspausdinti duomenų formą.

print(training_set.shape, test_set.shape, prediction_set.shape)

Rezultatas

(400, 10) (100, 10) (6, 10)

Atkreipkite dėmesį, kad etiketė, ty jūsų y, yra įtraukta į duomenų rinkinį. Taigi reikia apibrėžti dar du sąrašus. Viename yra tik etiketės funkcijos ir vienas su etiketės pavadinimu. Šie du sąrašai įvertintojui nurodys, kokios yra duomenų rinkinio ypatybės ir koks stulpelio pavadinimas yra etiketė

Tai daroma naudojant žemiau esantį kodą.

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

2 žingsnis) Konvertuokite duomenis

Skaitmeninius kintamuosius turite konvertuoti tinkamu formatu. „Tensorflow“ pateikia metodą, kaip konvertuoti tęstinį kintamąjį: tf.feature_column.numeric_column ().

Atlikdami ankstesnį veiksmą, nurodote funkciją, kurią norite įtraukti į modelį, sąrašą. Dabar galite naudoti šį sąrašą, kad paverstumėte juos skaitmeniniais duomenimis. Jei norite išskirti savo modelio ypatybes, prieš sukurdami „feature_cols“, nedvejodami palikite vieną ar daugiau kintamųjų sąraše FEATURES.

Atminkite, kad naudosite „Python“ sąrašo supratimą su sąrašu FEATURES, kad sukurtumėte naują sąrašą, pavadintą „feature_cols“. Tai padeda išvengti devynis kartus rašančių tf.feature_column.numeric_column (). Sąrašo supratimas yra greitesnis ir švaresnis būdas kurti naujus sąrašus

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

3 žingsnis. Apibrėžkite įvertiklį

Šiame žingsnyje turite apibrėžti įvertiklį. Šiuo metu „Tensorflow“ pateikia 6 iš anksto sukurtus įvertintuvus, iš jų 3 - klasifikavimo užduočiai ir 3 - „TensorFlow“ regresijos užduočiai:

  • Regresorius
    • DNNRegistratorius
    • LinijinisRegresorius
    • „DNNLineaCombinedRegressor“
  • Klasifikatorius
    • DNN klasifikatorius
    • Linijinis klasifikatorius
    • DNNLineaCombinedClasizer

Šioje pamokoje naudosite tiesinį regresorių. Norėdami pasiekti šią funkciją, turite naudoti tf.estimator.

Funkcijai reikia dviejų argumentų:

  • feature_columns: Yra kintamieji, kuriuos reikia įtraukti į modelį
  • model_dir: kelias grafikui išsaugoti, modelio parametrams išsaugoti ir kt

„Tensorflow“ jūsų darbo kataloge automatiškai sukurs failą pavadinimu „traukinys“. Turite naudoti šį kelią norėdami patekti į „Tensorboard“, kaip parodyta toliau pateiktame „TensorFlow“ regresijos pavyzdyje.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")

Rezultatas

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_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}

Kebli dalis naudojant „TensorFlow“ yra būdas maitinti modelį. „Tensorflow“ sukurtas dirbti su lygiagrečiu skaičiavimu ir labai dideliu duomenų rinkiniu. Dėl mašinų išteklių ribotumo neįmanoma modelio pateikti iš karto su visais duomenimis. Tam kiekvieną kartą reikia pateikti duomenų paketą. Atkreipkite dėmesį, kad mes kalbame apie didžiulį duomenų rinkinį, kuriame yra milijonai ar daugiau įrašų. Jei nepridėsite paketo, atsiras atminties klaida.

Pavyzdžiui, jei jūsų duomenyse yra 100 stebėjimų, o jūs nustatote partijos dydį 10, tai reiškia, kad modelis matys 10 kiekvienos iteracijos stebėjimų (10 * 10).

Kai modelis pamatys visus duomenis, jis baigs vieną epochą . Epocha apibrėžia, kiek kartų norite, kad modelis matytų duomenis. Geriau nenustatyti šio veiksmo ir leisti modeliui atlikti kartojimo laiką.

Antroji informacija, kurią reikia pridėti, yra tai, jei norite maišyti duomenis prieš kiekvieną kartojimą. Mokymų metu svarbu sumaišyti duomenis, kad modelis neišmoktų konkretaus duomenų rinkinio modelio. Jei modelis sužinos pagrindinio duomenų modelio detales, jam bus sunku apibendrinti nematytų duomenų prognozavimą. Tai vadinama pervarstymu . Modelis gerai veikia treniruotės duomenis, tačiau negali teisingai numatyti nematytų duomenų.

„TensorFlow“ leidžia lengvai atlikti šiuos du veiksmus. Kai duomenys eina į dujotiekį, jie žino, kiek stebėjimų jiems reikia (paketo) ir ar jie turi maišyti duomenis.

Norėdami nurodyti „Tensorflow“, kaip tiekti modelį, galite naudoti pandas_input_fn. Šiam objektui reikia 5 parametrų:

  • x: ypatybių duomenys
  • y: etiketės duomenys
  • batch_size: partija. Pagal numatytuosius nustatymus 128
  • num_epoch: epochos skaičius pagal numatytuosius nustatymus 1
  • Maišyti: Maišyti duomenis ar ne. Pagal numatytuosius nustatymus nėra

Jums reikia tiekti modelį daug kartų, kad apibrėžtumėte funkciją, kad pakartotumėte šį procesą. visa ši funkcija get_input_fn.

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Įprastas modelio našumo vertinimo metodas yra:

  • Mokykite modelį
  • Įvertinkite modelį kitame duomenų rinkinyje
  • Padarykite numatymą

Tensorflow įvertintuvas pateikia tris skirtingas funkcijas, kad lengvai atliktumėte šiuos tris veiksmus.

4 žingsnis) : mokykite modelį

Norėdami įvertinti modelį, galite naudoti sąmatos traukinį. Traukinio įvertintojui reikia įvesties_fn ir kelių žingsnių. Norėdami naudoti modelį, galite naudoti anksčiau sukurtą funkciją. Tada nurodote modeliui kartoti 1000 kartų. Atminkite, kad nenurodote epochų skaičiaus, jūs leidžiate modeliui pasikartoti 1000 kartų. Jei nustatysite epochos skaičių į 1, modelis kartosis 4 kartus: mokymo rinkinyje yra 400 įrašų, o partijos dydis yra 128

  1. 128 eilutės
  2. 128 eilutės
  3. 128 eilutės
  4. 16 eilučių

Todėl lengviau nustatyti epochos skaičių į jokį ir apibrėžti iteracijos skaičių, kaip parodyta žemiau esančiame „TensorFlow“ klasifikavimo pavyzdyje.

estimator.train(input_fn=get_input_fn(training_set,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/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.

Galite patikrinti, ar „Tensorboard“ atliks šią komandą:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

5 žingsnis) Įvertinkite savo modelį

Galite įvertinti savo modelio tinkamumą bandymų rinkinyje naudodami toliau pateiktą kodą:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))

Rezultatas

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Nuostolį galite atsispausdinti naudodami žemiau esantį kodą:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))

Rezultatas

Loss: 3215.895996

Modelio nuostolis yra 3215. Galite sužinoti suvestinės statistiką, kad suprastumėte, kokia yra klaida.

training_set['medv'].describe()

Rezultatas

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

Iš aukščiau pateiktos suvestinės statistikos žinote, kad vidutinė namo kaina yra 22 tūkst., O mažiausia kaina yra 9 tūkst., O didžiausia - 50 tūkst. Modelis daro tipišką 3 tūkstančių dolerių klaidą.

6 žingsnis) Padarykite numatymą

Galiausiai galite naudoti įvertintuvą „TensorFlow prognozuoti“, kad įvertintumėte 6 Bostono namų vertę.

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

Norėdami atsispausdinti apskaičiuotas reikšmes, galite naudoti šį kodą:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Rezultatas

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Modelis prognozuoja šias vertes:

Namas

Spėjimas

1

32.29

2

18.96

3

27.27

4

29.29

5

16.43

7

21.46

Atkreipkite dėmesį, kad mes nežinome tikrosios vertės. Gilaus mokymosi pamokoje bandysite įveikti linijinį modelį

Numpy sprendimas

Šiame skyriuje paaiškinta, kaip mokyti modelį naudojant „Numpy“ įvertiklį duomenims tiekti. Metodas yra tas pats, išskyrus tai, kad naudosite numpy_input_fn įvertiklį.

mokymo_set_n = pd.read_csv ("E: /boston_train.csv") vertės.

test_set_n = pd.read_csv ("E: /boston_test.csv"). reikšmės

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). reikšmės

1 žingsnis) Importuokite duomenis

Visų pirma, jūs turite atskirti funkcijų kintamuosius nuo etiketės. Tai turite padaryti mokymų duomenims ir vertinimui atlikti. Greičiau apibrėžti funkciją duomenims suskaidyti.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train

Galite naudoti funkciją norėdami atskirti etiketę nuo traukinio funkcijų / įvertinti duomenų rinkinį

X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)

Turite neįtraukti paskutinio prognozavimo duomenų rinkinio stulpelio, nes jame yra tik NaN

x_predict = prediction_set_n[:, :-2]

Patvirtinkite masyvo formą. Atminkite, kad etiketėje neturėtų būti matmenų, tai reiškia (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Rezultatas

(400, 9) (400,) (6, 9)

Funkcijų stulpelius galite susikurti taip:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Įvertiklis yra apibrėžtas kaip ir anksčiau, nurodote funkcijų stulpelius ir vietą, kur išsaugoti diagramą.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Rezultatas

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_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}

Norėdami naudoti duomenis modeliui ir paskui mokyti modelį, galite naudoti „numpy estapor“. Atkreipkite dėmesį, kad mes anksčiau apibrėžėme „input_fn“ funkciją, kad būtų lengviau skaityti.

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_train},y=y_train,batch_size=128,shuffle=False,num_epochs=None)estimator.train(input_fn = train_input,steps=5000)

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 train1/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.INFO:tensorflow:Loss for final step: 5925.985.Out[23]:

Norėdami įvertinti savo modelį, pakartokite tą patį veiksmą su kitu vertikliu

eval_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_test},y=y_test,shuffle=False,batch_size=128,num_epochs=1)estimator.evaluate(eval_input,steps=None)

Rezultatas

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Galiausiai, galite apskaičiuoti prognozę. Tai turėtų būti panaši į pandas.

test_input = tf.estimator.inputs.numpy_input_fn(x={"x": x_predict},batch_size=128,num_epochs=1,shuffle=False)y = estimator.predict(test_input)predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Rezultatas

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Tensorflow tirpalas

Paskutinis skyrius skirtas „TensorFlow“ sprendimui. Šis metodas yra šiek tiek sudėtingesnis nei kitas.

Atminkite, kad jei naudojate „Jupyter“ nešiojamąjį kompiuterį, turite paleisti iš naujo ir išvalyti branduolį, kad paleistumėte šią sesiją.

„TensorFlow“ sukūrė puikų įrankį duomenims perduoti į dujotiekį. Šiame skyriuje patys sukursite „input_fn“ funkciją.

1 žingsnis. Apibrėžkite duomenų kelią ir formatą

Visų pirma, jūs deklaruojate du kintamuosius su csv failo keliu. Atkreipkite dėmesį, kad turite dvi bylas: vieną treniruočių rinkiniui ir kitą testavimo rinkiniui.

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

Tada turite apibrėžti stulpelius, kuriuos norite naudoti iš csv failo. Mes panaudosime viską. Po to turite deklaruoti kintamojo tipą.

Plūduriuojantis kintamasis apibrėžiamas [0.]

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

2 žingsnis. Apibrėžkite „input_fn“ funkciją

Funkciją galima suskirstyti į tris dalis:

  1. Importuokite duomenis
  2. Sukurkite iteratorių
  3. Vartokite duomenis

Žemiau yra bendras kodas, apibrėžiantis funkciją. Kodas bus paaiškintas po

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def parse_csv(value):columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)features = dict(zip(COLUMNS, columns))#labels = features.pop('median_house_value')labels = features.pop('medv')return features, labels# Extract lines from input files using theDataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file.skip(1) # Skip header row.map(parse_csv))dataset = dataset.repeat(num_epoch)dataset = dataset.batch(batch_size)# Step 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Importuoti duomenis **

CSV failo duomenų rinkinio metodas nuskaito po vieną eilutę. Norėdami sukurti duomenų rinkinį, turite naudoti objektą „TextLineDataset“. Duomenų rinkinyje yra antraštė, todėl norint praleisti pirmąją eilutę, reikia naudoti skip (1). Šiuo metu jūs skaitote tik duomenis ir išskiriate antraštę dujotiekyje. Norėdami maitinti modelį, turite atskirti funkcijas nuo etiketės. Metodas, naudojamas bet kokiai duomenų transformacijai, yra žemėlapis.

Šis metodas iškviečia funkciją, kurią sukursite, kad nurodytumėte, kaip transformuoti duomenis. Trumpai tariant, turite perduoti duomenis „TextLineDataset“ objekte, neįtraukti antraštės ir pritaikyti transformaciją, kurią nurodo funkcija.

  • tf.data.TextLineDataset (data_file): Ši eilutė nuskaito csv failą
  • .skip (1): praleiskite antraštę
  • .map (parse_csv)): išanalizuokite įrašus į tenzorus. Norėdami nurodyti žemėlapio objektą, turite apibrėžti funkciją. Šią funkciją galite vadinti parse_csv.

Ši funkcija analizuoja csv failą metodu tf.decode_csv ir deklaruoja ypatybes bei etiketę. Funkcijos gali būti deklaruojamos kaip žodynas ar paketas. Žodyno metodą naudojate, nes jis yra patogesnis. Kodo paaiškinimas

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): metodas decode_csv naudoja „TextLineDataset“ išvestį skaityti csv failą. „record_defaults“ nurodo „TensorFlow“ apie stulpelių tipą.
  • dict (zip (_CSV_COLUMNS, stulpeliai)): užpildykite žodyną su visais šio duomenų apdorojimo metu ištrauktais stulpeliais
  • features.pop ('median_house_value'): Išskirkite tikslinį kintamąjį iš objekto kintamojo ir sukurkite etiketės kintamąjį

Duomenų rinkiniui reikia papildomų elementų, kad iteratyviai būtų maitinami tenzorai. Iš tiesų, jūs turite pridėti metodo pakartojimą, kad duomenų rinkinys galėtų tęsti neribotą laiką, kad tiektų modelį. Jei nepridėsite metodo, modelis kartos tik vieną kartą ir tada sukels klaidą, nes daugiau duomenų nepateikiama.

Po to galite valdyti partijos dydį paketiniu metodu. Tai reiškia, kad jūs nurodote duomenų rinkiniui, kiek duomenų norite perduoti kiekvienoje iteracijoje. Jei nustatysite didelį partijos dydį, modelis bus lėtas.

3 žingsnis) Sukurkite iteratorių

Dabar esate pasirengę antram žingsniui: sukurkite iteratorių, kad grąžintumėte duomenų rinkinio elementus.

Paprasčiausias būdas sukurti operatorių yra metodas make_one_shot_iterator.

Po to jūs galite sukurti funkcijas ir etiketes iš iteratoriaus.

4 žingsnis) sunaudokite duomenis

Galite patikrinti, kas vyksta su input_fn funkcija. Norėdami suvartoti duomenis, turite iškviesti funkciją sesijos metu. Bandote su partijos dydžiu, lygiu 1.

Atminkite, kad jis spausdina žodyno ypatybes ir etiketę kaip masyvą.

Tai parodys pirmąją csv failo eilutę. Galite daug kartų pabandyti paleisti šį kodą su skirtingu partijos dydžiu.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)with tf.Session() as sess:first_batch = sess.run(next_batch)print(first_batch)

Rezultatas

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

4 žingsnis. Apibrėžkite funkcijų stulpelį

Skaitinius stulpelius turite apibrėžti taip:

X1= tf.feature_column.numeric_column('crim')X2= tf.feature_column.numeric_column('zn')X3= tf.feature_column.numeric_column('indus')X4= tf.feature_column.numeric_column('nox')X5= tf.feature_column.numeric_column('rm')X6= tf.feature_column.numeric_column('age')X7= tf.feature_column.numeric_column('dis')X8= tf.feature_column.numeric_column('tax')X9= tf.feature_column.numeric_column('ptratio')

Atminkite, kad visus kintamuosius turite sujungti į grupę

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

5 žingsnis) Sukurkite modelį

Galite mokyti modelį naudodami įvertintuvą „LinearRegressor“.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Rezultatas

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_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}

Norėdami leisti argumentą įrašyti į funkciją inpu_fn, turite naudoti lambda funkciją. Jei nenaudojate lambda funkcijos, negalite mokyti modelio.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

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 train3/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.Out[8]:

Galite įvertinti savo modelio tinkamumą bandymų rinkinyje naudodami toliau pateiktą kodą:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))for key in results:print(" {}, was: {}".format(key, results[key]))

Rezultatas

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

Paskutinis žingsnis yra vertės numatymas, remiantis funkcijų matricų verte. Galite parašyti žodyną su vertėmis, kurias norite nuspėti. Jūsų modelis turi 9 ypatybes, todėl kiekvienam iš jų turite pateikti vertę. Modelis pateiks kiekvieno iš jų prognozę.

Žemiau esančiame kode įrašėte kiekvieno objekto, esančio df_predict csv faile, vertes.

Turite parašyti naują funkciją input_fn, nes duomenų rinkinyje nėra etiketės. Galite naudoti API from_tensor iš duomenų rinkinio.

prediction_input = {'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],'zn': [75.0,0.0,25.0,33.0,0.0,0.0],'indus': [2.95,18.10,5.13,2.18,18.10,9.90],'nox': [0.428,0.713,0.453,0.472,0.700,0.544],'rm': [7.024,6.297,6.762,7.236,5.390,5.782],'age': [15.8,91.8,43.4,41.1,98.9,71.7],'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],'tax': [252,666,284,222,666,304],'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]}def test_input_fn():dataset = tf.data.Dataset.from_tensors(prediction_input)return dataset# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)

Galiausiai, jūs atspausdinate prognozes.

for pred in enumerate(pred_results):print(pred)

Rezultatas

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.(0, {'predictions': array([32.297546], dtype=float32)})(1, {'predictions': array([18.96125], dtype=float32)})(2, {'predictions': array([27.270979], dtype=float32)})(3, {'predictions': array([29.299236], dtype=float32)})(4, {'predictions': array([16.436684], dtype=float32)})(5, {'predictions': array([21.460876], dtype=float32)})INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

Santrauka

Norėdami mokyti modelį, turite:

  • Apibrėžkite ypatybes: Nepriklausomi kintamieji: X
  • Apibrėžkite etiketę: Priklausomas kintamasis: y
  • Sukurkite traukinį / bandymų komplektą
  • Apibrėžkite pradinį svorį
  • Apibrėžkite nuostolių funkciją: MSE
  • Optimizuokite modelį: gradiento nusileidimas
  • Apibrėžti:
    • Mokymosi greitis
    • Epochos skaičius
    • Partijos dydis

Šioje pamokoje sužinojote, kaip naudoti aukšto lygio API linijinės regresijos „TensorFlow“ vertintojui. Turite apibrėžti:

  1. Funkcijos stulpeliai. Jei nenutrūkstamas: tf.feature_column.numeric_column (). Galite užpildyti sąrašą suprasdami python sąrašą
  2. Įvertiklis: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Duomenų, paketo dydžio ir epochos importavimo funkcija: input_fn ()

Po to jūs esate pasirengęs treniruotis, įvertinti ir prognozuoti su traukiniu (), įvertinti () ir numatyti ()

Įdomios straipsniai...