Bināra klasifikācija TensorFlow: Lineārā klasifikatora piemērs

Divi visbiežāk uzraugāmie mācību uzdevumi ir lineārā regresija un lineārais klasifikators. Lineārā regresija paredz vērtību, bet lineārais klasifikators - klasi. Šī apmācība ir koncentrēta uz lineāro klasifikatoru.

Kas ir lineārais klasifikators?

Linear klasifikators ir mašīnmācīšanos ir metode, lai atrastu objekta klasi, pamatojoties uz tās īpašībām Statistisko klasifikāciju. Tas pieņem klasifikācijas lēmumu, pamatojoties uz objekta raksturlielumu lineāras kombinācijas vērtību. Lineāro klasifikatoru izmanto tādās praktiskās problēmās kā dokumentu klasifikācija un problēmas ar daudziem mainīgajiem.

Klasifikācijas problēmas veido aptuveni 80 procentus mašīnmācīšanās uzdevuma. Klasifikācijas mērķis ir paredzēt katras klases varbūtību, ņemot vērā izejvielu kopumu. Etiķete (ti, atkarīgais mainīgais) ir diskrēta vērtība, ko sauc par klasi.

1. Ja etiķetē ir tikai divas klases, mācību algoritms ir binārs klasifikators.
2. Daudzklases klasifikators izmanto uzlīmes ar vairāk nekā divām klasēm.

Piemēram, tipiska binārā klasifikācijas problēma ir paredzēt varbūtību, ka klients veiks otro pirkumu. Paredzēt, ka uz attēla redzamā dzīvnieka tips ir daudzklasīgu klasifikācijas problēma, jo pastāv vairāk nekā divas dzīvnieku šķirnes.

Šīs apmācības teorētiskajā daļā galvenā uzmanība tiek pievērsta binārajai klasei. Nākamajā apmācībā uzzināsiet vairāk par daudzklases izvades funkciju.

Šajā apmācībā jūs uzzināsiet

• Kas ir lineārais klasifikators?
• Kā darbojas binārs klasifikators?
• Kā izmērīt lineārā klasifikatora veiktspēju?
• Precizitāte
• Apjukuma matrica
• Precizitāte un jutīgums
• Lineārais klasifikators ar TensorFlow
• 1. darbība. Importējiet datus
• 2. solis) Datu konvertēšana
• 3. solis. Apmāciet klasifikatoru
• 4. solis. Uzlabojiet modeli
• 5. solis) hiperparametrs: Lasso & Ridge

Kā darbojas binārs klasifikators?

Iepriekšējā apmācībā jūs uzzinājāt, ka funkcija sastāv no divu veidu mainīgajiem, atkarīgā mainīgā un pazīmju kopas (neatkarīgi mainīgie). Lineārajā regresijā atkarīgais mainīgais ir reāls skaitlis bez diapazona. Galvenais mērķis ir paredzēt tā vērtību, samazinot vidējo kļūdu kvadrātā.

TensorFlow binārā klasifikatora etiķetei var būt divas iespējamās veselā skaitļa vērtības. Vairumā gadījumu tas ir vai nu [0,1], vai [1,2]. Piemēram, mērķis ir paredzēt, vai klients iegādāsies produktu. Etiķete ir definēta šādi:

• Y = 1 (klients iegādājās produktu)
• Y = 0 (klients nepērk produktu)

Modelis izmanto X pazīmes, lai klasificētu katru klientu visticamākajā klasē, kurai viņš pieder, proti, potenciālo pircēju vai ne.

Panākumu varbūtība tiek aprēķināta ar loģistisko regresiju . Algoritms aprēķinās varbūtību, pamatojoties uz pazīmi X, un paredz veiksmi, ja šī varbūtība ir virs 50 procentiem. Oficiāli varbūtību aprēķina, kā parādīts zemāk esošajā TensorFlow binārās klasifikācijas piemērā:

kur 0 ir svaru kopa, pazīmes un b novirze.

Funkciju var sadalīt divās daļās:

• Lineārais modelis
• Loģistikas funkcija

Lineārais modelis

Jūs jau esat iepazinies ar svaru aprēķināšanas veidu. Svarus aprēķina, izmantojot punktu punktu: Y ir visu pazīmju x _i lineārā funkcija . Ja modelim nav pazīmju, prognoze ir vienāda ar aizspriedumiem, b.

Svari norāda korelācijas virzienu starp pazīmēm x _i un etiķeti y. Pozitīva korelācija palielina pozitīvās klases varbūtību, savukārt negatīvā korelācija noved varbūtību tuvāk 0 (ti, negatīva klase).

Lineārais modelis atgriež tikai reālo skaitli, kas nav saderīgs ar diapazona [0,1] varbūtības mēru. Loģistikas funkcija ir nepieciešama, lai pārveidotu lineārā modeļa izvadi ar varbūtību,

Loģistikas funkcija

Loģistikas funkcijai jeb sigmoīdajai funkcijai ir S forma, un šīs funkcijas izeja vienmēr ir no 0 līdz 1.

Loģistikas funkciju piemērs

Lineārās regresijas iznākumu ir viegli aizstāt ar sigmoīdo funkciju. Tā rezultātā tiek iegūts jauns skaitlis ar varbūtību no 0 līdz 1.

Klasifikators var pārveidot varbūtību klasē

• Vērtības no 0 līdz 0,49 kļūst par 0 klasi
• Vērtības no 0,5 līdz 1 kļūst par 1. klasi

Kā izmērīt lineārā klasifikatora veiktspēju?

Precizitāte

Klasifikatora kopējo veiktspēju mēra ar precizitātes metriku. Precizitāte apkopo visas pareizās vērtības, dalītas ar kopējo novērojumu skaitu. Piemēram, 80 procentu precizitātes vērtība nozīmē, ka 80 procentos gadījumu modelis ir pareizs.

Novērtējiet lineārā klasifikatora veiktspēju, izmantojot metriku Precizitāte

Izmantojot šo metriku, jūs varat atzīmēt trūkumu, īpaši attiecībā uz nelīdzsvarotības klasi. Nelīdzsvarotības datu kopa rodas, ja novērojumu skaits vienā grupā nav vienāds. Teiksim; jūs mēģināt klasificēt retu notikumu ar loģistikas funkciju. Iedomājieties, ka klasifikators mēģina novērtēt pacienta nāvi pēc slimības. Datos 5 procenti pacientu mirst. Varat apmācīt klasifikatoru, lai prognozētu nāves gadījumu skaitu, un, lai novērtētu veiktspēju, izmantojiet precizitātes metriku. Ja klasifikators paredz 0 nāves gadījumu visai datu kopai, tas būs pareizi 95 procentos gadījumu.

Apjukuma matrica

Labāks veids, kā novērtēt klasifikatora veiktspēju, ir aplūkot neskaidrības matricu.

Izmēra lineārā klasifikatora veiktspēju, izmantojot sajaukšanas matricu

Apjukuma matrica vizualizē klasifikatora precizitāti, salīdzinot faktiskās un prognozētās klases, kā parādīts iepriekš minētajā lineārā klasifikatora piemērā. Binārā sajaukšanas matrica sastāv no kvadrātiem:

• TP: Patiesi pozitīvs: Paredzētās vērtības ir pareizi paredzētas kā faktiskas pozitīvas
• FP: Paredzētās vērtības nepareizi paredzēja faktisko pozitīvo. ti, negatīvās vērtības tiek prognozētas kā pozitīvas
• FN: Viltus negatīvs: pozitīvas vērtības tiek prognozētas kā negatīvas
• TN: patiess negatīvs: pareģotās vērtības ir pareizi paredzētas kā faktiskās negatīvās

No neskaidrības matricas ir viegli salīdzināt faktisko klasi un paredzamo klasi.

Precizitāte un jutīgums

Apjukuma matrica sniedz labu ieskatu patiesajā pozitīvajā un viltus pozitīvajā. Dažos gadījumos ieteicams izmantot precīzāku metriku.

Precizitāte

Precizitātes metrika parāda pozitīvās klases precizitāti. Tas mēra, cik iespējams, ka pozitīvās klases prognoze ir pareiza.

Maksimālais punktu skaits ir 1, kad klasifikators perfekti klasificē visas pozitīvās vērtības. Tikai precizitāte nav īpaši noderīga, jo tā ignorē negatīvo klasi. Metrika parasti tiek savienota pārī ar atsaukšanas metriku. Atsaukšanu sauc arī par jutīgumu vai patieso pozitīvo līmeni.

Jutīgums

Jutīgums aprēķina pareizi noteikto pozitīvo klašu attiecību. Šī metrika norāda, cik labs modelis ir pozitīvas klases atpazīšanai.

Lineārais klasifikators ar TensorFlow

Šajā apmācībā mēs izmantosim tautas skaitīšanas datu kopu. Mērķis ir izmantot skaitīšanas datu kopas mainīgos lielumus, lai prognozētu ienākumu līmeni. Ņemiet vērā, ka ienākumi ir binārs mainīgais

• ar vērtību 1, ja ienākumi> 50 tūkst
• 0, ja ienākumi <50k.

Šis mainīgais ir jūsu iezīme

Šajā datu kopā ir astoņi kategoriski mainīgie:

• darbavietā
• izglītība
• laulības
• nodarbošanās
• attiecības
• sacīkstes
• dzimums
• dzimtā valsts

turklāt seši nepārtraukti mainīgie:

• vecums
• fnlwgt
• izglītība_num
• kapitāla pieaugums
• kapitāla zaudējums
• stundas_nedēļa

Izmantojot šo TensorFlow klasifikācijas piemēru, jūs sapratīsit, kā apmācīt lineāros TensorFlow klasifikatorus ar TensorFlow novērtētāju un kā uzlabot precizitātes metriku.

Mēs rīkosimies šādi:

• 1. darbība. Importējiet datus
• 2. solis) Datu konvertēšana
• 3. solis. Apmāciet klasifikatoru
• 4. solis. Uzlabojiet modeli
• 5. solis) hiperparametrs: Lasso & Ridge

1. darbība. Importējiet datus

Vispirms jūs importējat apmācības laikā izmantotās bibliotēkas.

import tensorflow as tfimport pandas as pd 

Pēc tam importējat datus no UCI arhīva un definējat kolonnu nosaukumus. Kolonnu nosaukumam pandas datu rāmī izmantosiet slejas.

Ņemiet vērā, ka klasifikatoru apmācīsit, izmantojot Pandas datu ietvaru.

## Define path dataCOLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss','hours_week', 'native_country', 'label']PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

Tiešsaistē saglabātie dati jau ir sadalīti starp vilcienu sastāvu un testa komplektu.

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

Vilcienu komplektā ir 32 561 novērojums un testa komplektā - 16 281

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

Tensorflow klasifikatora apmācībai ir nepieciešama Būla vērtība. Vērtības jāpārskaita no virknes uz veselu skaitli. Etiķete ir veikals kā objekts, tomēr tā jāpārvērš skaitliskā vērtībā. Zemāk esošais kods izveido vārdnīcu ar vērtībām, kuras jāpārvērš un jāpāriet uz kolonnas vienumu. Ņemiet vērā, ka jūs veicat šo darbību divas reizes, vienu vilciena pārbaudei, otru testa kopai

label = {'<=50K': 0,'>50K': 1}df_train.label = [label[item] for item in df_train.label]label_t = {'<=50K.': 0,'>50K.': 1}df_test.label = [label_t[item] for item in df_test.label]

Vilciena datos ir 24 720 ienākumi, kas ir mazāki par 50 000 un 7841 virs. Pārbaudes kopai attiecība ir gandrīz vienāda. Lūdzu, skatiet šo apmācību vietnē Facets, lai iegūtu vairāk.

print(df_train["label"].value_counts())### The model will be correct in atleast 70% of the caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

2. solis) Datu konvertēšana

Lai apmācītu lineāro klasifikatoru ar Tensorflow, jāveic dažas darbības. Jums jāsagatavo funkcijas, kuras iekļaut modelī. Etalona regresijā jūs izmantosiet sākotnējos datus, nepiemērojot nekādas transformācijas.

Novērtētājam jābūt modeļa apmācības pazīmju sarakstam. Tādējādi kolonnas dati jāpārvērš par tenzoru.

Laba prakse ir definēt divus pazīmju sarakstus, pamatojoties uz to tipu, un pēc tam nodot tos aprēķinātāja funkciju_kolonnās.

Sākumā pārveidosiet nepārtrauktas funkcijas, pēc tam definējiet segmentu ar kategoriskajiem datiem.

Datu kopas funkcijām ir divi formāti:

• Vesels skaitlis
• Objekts

Katra funkcija ir norādīta nākamajos divos mainīgajos pēc to veida.

## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']### Define the categorical listCATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

Funkcija_kolonna ir aprīkota ar objekta skaitlisko kolonnu, kas palīdz nepārtraukto mainīgo lielumu pārveidošanā tenzorā. Tālāk esošajā kodā jūs visus konvertētājus no CONTI_FEATURES pārveidojat par tenzoru ar skaitlisku vērtību. Tas ir obligāti, lai izveidotu modeli. Visi neatkarīgie mainīgie ir jāpārvērš pareizajā tenzora tipā.

Zemāk mēs uzrakstām kodu, lai jūs varētu redzēt, kas notiek aiz feature_column.numeric_column. Mēs izdrukāsim konvertēto vecuma vērtību. Tas ir skaidrojošs, tāpēc nav nepieciešams saprast pitona kodu. Lai saprastu kodus, varat atsaukties uz oficiālo dokumentāciju.

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif continuous == True:c = tf.feature_column.numeric_column(feature)feature_columns = [c]else:c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size)c_indicator = tf.feature_column.indicator_column(c)feature_columns = [c_indicator]## Use input_layer to print the valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(sess.run(input_layer))print_transformation(feature = "age", continuous = True)[[39.][50.][38.]… [58.][22.][52.]]

Vērtības ir tieši tādas pašas kā df_train

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES] 

Saskaņā ar TensorFlow dokumentāciju, kategorisko datu konvertēšanai ir dažādi veidi. Ja objekta vārdu krājuma saraksts ir zināms un tam nav daudz vērtību, kategorisko kolonnu ir iespējams izveidot ar kategorisko_kolonnu_apjomu_vārdnīcas_sarakstu. Visiem unikālo vārdu krājumu sarakstiem tas piešķirs ID.

Piemēram, ja mainīgā statusam ir trīs atšķirīgas vērtības:

• Vīrs
• Sieva
• Viens

Tad tiks piešķirts trīs ID. Piemēram, vīram būs ID 1, sievai ID 2 un tā tālāk.

Ilustratīvam nolūkam varat izmantot šo kodu, lai objekta mainīgo pārveidotu par kategorisku kolonnu TensorFlow.

Īpašības dzimumam var būt tikai divas vērtības: vīrietis vai sieviete. Kad mēs pārveidosim iezīmju dzimumu, Tensorflow izveidos 2 jaunas kolonnas - vienu vīriešiem un otru sievietēm. Ja dzimums ir vienāds ar vīrieti, tad jaunā slejas vīrietis būs vienāds ar 1 un sieviete ar 0. Šis piemērs ir parādīts zemāk esošajā tabulā:

rindas	dzimums	pēc transformācijas	vīrietis	sieviete
1	vīrietis	=>	1	0
2	vīrietis	=>	1	0
3	sieviete	=>	0	1

Tensorflow:

print_transformation(feature = "sex", continuous = False, size = 2)[[1. 0.][1. 0.][1. 0.]… [0. 1.][1. 0.][0. 1.]]relationship = tf.feature_column.categorical_column_with_vocabulary_list('relationship', ['Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried','Other-relative'])

Zemāk mēs pievienojām Python kodu, lai izdrukātu kodējumu. Atkal jums nav jāsaprot kods, mērķis ir redzēt transformāciju

Tomēr ātrāks veids, kā pārveidot datus, ir izmantot kategoriju_kolonna_ar_hash_bucket. Noderēs virknes mainīgo mainīšana retā matricā. Retā matrica ir matrica, kuras pārsvarā ir nulle. Metode rūpējas par visu. Jums jānorāda tikai kopu skaits un kolonnu atslēga. Grupu skaits ir maksimālais grupu skaits, ko Tensorflow var izveidot. Galvenā kolonna ir vienkārši konvertējamās kolonnas nosaukums.

Zemāk esošajā kodā jūs izveidojat visu kategorisko funkciju loku.

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

3. solis. Apmāciet klasifikatoru

TensorFlow pašlaik nodrošina lineārās regresijas un lineārās klasifikācijas novērtētāju.

• Lineārā regresija: LinearRegressor
• Lineārā klasifikācija: LinearClassifier

Lineārā klasifikatora sintakse ir tāda pati kā lineārās regresijas apmācībā, izņemot vienu argumentu n_class. Jums jādefinē funkciju kolonna, modeļu katalogs un jāsalīdzina ar lineāro regresoru; jums ir jādefinē klases numurs. Logit regresijas gadījumā klases skaits ir vienāds ar 2.

Modelis aprēķinās kolonnu svarus, kas ietverti nepārtrauktajās un kategoriskajās īpašībās.

model = tf.estimator.LinearClassifier(n_classes = 2,model_dir="ongoing/train",feature_columns=categorical_features+ continuous_features)

REZULTĀTS:

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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}

Tagad, kad klasifikators ir definēts, varat izveidot ievades funkciju. Metode ir tāda pati kā lineārā regresora apmācībā. Šeit jūs izmantojat 128 partijas lielumu un sajaucat datus.

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']LABEL= 'label'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 izveidojat funkciju ar lineārā novērtētāja pieprasītajiem argumentiem, ti, laikmetu skaitu, partiju skaitu un sajaucat datu kopu vai piezīmi. Tā kā datu pārsūtīšanai modelī izmantojat Pandas metodi, X mainīgie jānosaka kā pandas datu ietvars. Ņemiet vērā, ka jūs pārskata visus datus, kas saglabāti mapē FEATURES.

Apmācīsim modeli ar objekta modeli.vilciens. Jūs izmantojat iepriekš definēto funkciju, lai modelim pievienotu atbilstošās vērtības. Ņemiet vērā, ka partijas lielumu iestatāt uz 128 un laikmetu skaitu - Neviens. Modelis tiks apmācīts vairāk nekā tūkstoš soļu.

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

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 ongoing/train/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.INFO:tensorflow:Loss for final step: 5444.363.

Ņemiet vērā, ka zaudējumi vēlāk samazinājās pēdējo 100 darbību laikā, ti, no 901 līdz 1000.

Galīgais zaudējums pēc tūkstoš atkārtojumiem ir 5444. Jūs varat novērtēt savu modeli testa komplektā un redzēt veiktspēju. Lai novērtētu sava modeļa veiktspēju, jums jāizmanto objekta novērtējums. Jūs barojat modeli ar testa kopu un iestatāt laikmetu skaitu uz 1, ti, dati modelim tiks nosūtīti tikai vienu reizi.

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

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546{'accuracy': 0.7615626,'accuracy_baseline': 0.76377374,'auc': 0.63300294,'auc_precision_recall': 0.50891197,'average_loss': 47.12155,'global_step': 1000,'label/mean': 0.23622628,'loss': 5993.6406,'precision': 0.49401596,'prediction/mean': 0.18454961,'recall': 0.38637546}

TensorFlow atgriež visus rādītājus, kurus esat iemācījies teorētiskajā daļā. Bez pārsteiguma, precizitāte ir liela nelīdzsvarotās etiķetes dēļ. Patiesībā modelis darbojas nedaudz labāk nekā nejaušs minējums. Iedomājieties, ka modelis paredz visu mājsaimniecību ienākumus, kas ir mazāki par 50 000, tad modeļa precizitāte ir 70 procenti. Sīkāk analizējot, jūs varat redzēt, ka prognozes un atsaukums ir diezgan zemi.

4. solis. Uzlabojiet modeli

Tagad, kad jums ir etalona modelis, varat mēģināt to uzlabot, tas ir, palielināt precizitāti. Iepriekšējā apmācībā jūs uzzinājāt, kā ar mijiedarbības terminu uzlabot prognozēšanas spēku. Šajā apmācībā jūs atkārtoti aplūkosiet šo ideju, regresijai pievienojot polinoma terminu.

Polinomu regresija ir instrumentāla, ja datos ir nelineārā. Ir divi veidi, kā attēlot nelinearitāti datos.

• Pievienojiet polinoma terminu
• Nepārtrauktā mainīgā lielumu ievietojiet kategoriskajā mainīgajā

Polinoma termins

Zemāk redzamajā attēlā jūs varat redzēt, kas ir polinoma regresija. Tas ir vienādojums ar X mainīgajiem ar dažādu jaudu. Otrās pakāpes polinoma regresijai ir divi mainīgie - X un X kvadrātā. Trešajai pakāpei ir trīs mainīgie, X, X ² un X ³

Kas ir polinoma regresija

Zemāk mēs izveidojām grafiku ar diviem mainīgajiem lielumiem X un Y. Ir skaidrs, ka sakarība nav lineāra. Ja mēs pievienojam lineāru regresiju, mēs varam redzēt, ka modelis nespēj uztvert modeli (kreisais attēls).

Paskaties kreisajā attēlā no zemāk redzamā attēla, regresijai pievienojām piecu termiņu (tas ir, y = x + x ² + x ³ + x ⁴ + x ^5. Tagad modelis labāk attēlo modeli. Tas ir polinomu regresijas spēks.

Atgriezīsimies pie sava piemēra. Vecums nav lineārā sakarībā ar ienākumiem. Agrīnā vecumā ienākumi varētu būt vienādi ar nulli, jo bērni vai jaunieši nestrādā. Tad tas palielinās darbspējas vecumā un samazinās pensijas laikā. Parasti tā ir apgrieztā U forma. Viens no veidiem, kā iegūt šo modeli, ir regresijai pievienot divus spēkus.

Apskatīsim, vai tas palielina precizitāti.

Šī jaunā funkcija ir jāpievieno datu kopai un nepārtrauktu funkciju sarakstā.

Jūs pievienojat jauno mainīgo vilciena un testa datu kopā, tāpēc ērtāk ir uzrakstīt funkciju.

def square_var(df_t, df_te, var_name = 'age'):df_t['new'] = df_t[var_name].pow(2)df_te['new'] = df_te[var_name].pow(2)return df_t, df_te

Funkcijai ir 3 argumenti:

• df_t: definējiet apmācību kopu
• df_te: definējiet testa kopu
• var_name = 'vecums': definējiet pārveidojamo mainīgo

Varat izmantot objektu pow (2) mainīgā vecuma kvadrātā. Ņemiet vērā, ka jaunā mainīgā nosaukums ir “jauns”

Tagad, kad funkcija square_var ir rakstīta, varat izveidot jaunas datu kopas.

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age') 

Kā redzat, jaunajai datu kopai ir vēl viena funkcija.

print(df_train_new.shape, df_test_new.shape)(32561, 16) (16281, 16) 

Kvadrātveida mainīgo datu kopā sauc par jaunu. Jums tas jāpievieno nepārtraukto funkciju sarakstam.

CONTI_FEATURES_NEW = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

Ņemiet vērā, ka esat mainījis diagrammas direktoriju. Jūs nevarat apmācīt dažādus modeļus vienā direktorijā. Tas nozīmē, ka jums jāmaina argumenta modelis_dir ceļš. Ja jūs to nedarīsit, TensorFlow radīs kļūdu.

model_1 = tf.estimator.LinearClassifier(model_dir="ongoing/train1",feature_columns=categorical_features+ continuous_features_new)

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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}FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']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_NEW}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Tagad, kad klasifikators ir izstrādāts ar jauno datu kopu, jūs varat apmācīt un novērtēt modeli.

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

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 ongoing/train1/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.INFO:tensorflow:Loss for final step: 28861.898.

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

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703{'accuracy': 0.7944229,'accuracy_baseline': 0.76377374,'auc': 0.6093755,'auc_precision_recall': 0.54885805,'average_loss': 111.0046,'global_step': 1000,'label/mean': 0.23622628,'loss': 14119.265,'precision': 0.6682401,'prediction/mean': 0.09116262,'recall': 0.2576703}

Kvadrātveida mainīgais uzlaboja precizitāti no 0,76 līdz 0,79. Apskatīsim, vai jūs varat darīt labāk, apvienojot kopu un mijiedarbības terminu.

Bucketization un mijiedarbība

Kā jūs redzējāt iepriekš, lineārais klasifikators nespēj pareizi uztvert vecuma un ienākumu modeli. Tas ir tāpēc, ka tā apgūst vienu svaru katrai funkcijai. Lai klasifikatoram būtu vieglāk, jūs varat veikt vienu funkciju. Spainošana pārveido skaitlisku pazīmi vairākos noteiktos, pamatojoties uz diapazonu, kurā tā ietilpst, un katra no šīm jaunajām pazīmēm norāda, vai personas vecums ietilpst šajā diapazonā.

Izmantojot šīs jaunās funkcijas, lineārais modelis var uztvert attiecības, apgūstot dažādus svarus katram spainim.

TensorFlow tas tiek darīts ar bucketized_column. Robežās jāpievieno vērtību diapazons.

age = tf.feature_column.numeric_column('age')age_buckets = tf.feature_column.bucketized_column(age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

Jūs jau zināt, ka vecums nav lineārs ar ienākumiem. Vēl viens veids, kā uzlabot modeli, ir mijiedarbība. TensorFlow vārdiem sakot, tas ir iezīmju šķērsošana. Funkciju šķērsošana ir veids, kā izveidot jaunas funkcijas, kas ir esošo kombinācijas, kas var būt noderīgi lineāram klasifikatoram, kurš nevar modelēt mijiedarbību starp funkcijām.

Jūs varat sadalīt vecumu ar citu funkciju, piemēram, izglītību. Tas ir, dažām grupām, visticamāk, ir augsti ienākumi, bet citām - zemi ienākumi (padomājiet par doktora grādu).

education_x_occupation = [tf.feature_column.crossed_column(['education', 'occupation'], hash_bucket_size=1000)]age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column([age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

Lai izveidotu krustojuma elementu kolonnu, krustojumam iekavās izmantojiet crossed_column ar mainīgajiem. Hash_bucket_size norāda maksimālās šķērsošanas iespējas. Lai izveidotu mijiedarbību starp mainīgajiem (vismaz vienam mainīgajam jābūt kategoriskam), varat izmantot tf.feature_column.crossed_column. Lai izmantotu šo objektu, kvadrātiekavās jāpievieno mainīgais, lai mijiedarbotos, un otrais arguments - kopas lielums. Grupas lielums ir maksimālais iespējamais grupas skaits mainīgajā. Šeit jūs to iestatījāt uz 1000, jo nezināt precīzu grupu skaitu

age_buckets pirms tam ir jānorāda kvadrātā, lai to pievienotu funkciju kolonnām. Jūs arī pievienojat jaunās funkcijas funkciju kolonnām un sagatavojat aprēķinātāju

base_columns = [age_buckets,]model_imp = tf.estimator.LinearClassifier(model_dir="ongoing/train3",feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

IZVADE

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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}

FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'native_country', 'new']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_imp}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Jūs esat gatavs novērtēt jauno modeli un pārliecināties, vai tas uzlabo precizitāti.

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

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 ongoing/train3/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.INFO:tensorflow:Loss for final step: 44.18133.

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

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216{'accuracy': 0.8358209,'accuracy_baseline': 0.76377374,'auc': 0.88401634,'auc_precision_recall': 0.69599575,'average_loss': 0.35122654,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.67437,'precision': 0.68986726,'prediction/mean': 0.23320661,'recall': 0.55408216}

Jaunais precizitātes līmenis ir 83,58 procenti. Tas ir par četriem procentiem augstāks nekā iepriekšējais modelis.

Visbeidzot, jūs varat pievienot legalizācijas terminu, lai novērstu pārmērīgu uzstādīšanu.

5. solis) hiperparametrs: Lasso & Ridge

Jūsu modelis var ciest no overfitting vai underfitting .

• Pārspīlēšana: modelis nespēj vispārināt prognozi jauniem datiem
• Nepietiekams: modelis nespēj uztvert datu modeli. ti, lineārā regresija, kad dati ir nelineāri

Ja modelim ir daudz parametru un salīdzinoši maz datu, tas noved pie sliktām prognozēm. Iedomājieties, vienai grupai ir tikai trīs novērojumi; modelis aprēķinās šīs grupas svaru. Svaru izmanto, lai veiktu prognozi; ja testu kopas novērojumi šai konkrētajai grupai pilnībā atšķiras no apmācību kopas, tad modelis prognozēs nepareizi. Vērtēšanas laikā ar treniņu komplektu precizitāte ir laba, bet nav laba testu komplektā, jo aprēķinātie svari nav patiesie, lai vispārinātu modeli. Šajā gadījumā tas nerada saprātīgu prognozi par neredzētiem datiem.

Lai novērstu pārspīlēšanu, legalizācija dod jums iespēju kontrolēt šādu sarežģītību un padarīt to vispārināmāku. Ir divas regulēšanas metodes:

• L1: Lasso
• L2: Ridge

Programmā TensorFlow optimizatorā varat pievienot šos divus hiperparametrus. Piemēram, jo ​​augstāks ir hiperparametrs L2, svars mēdz būt ļoti mazs un tuvu nullei. Uzstādītā līnija būs ļoti plakana, savukārt L2 tuvu nullei svars ir tuvu regulārajai lineārajai regresijai.

Jūs pats varat izmēģināt atšķirīgo hiperparametru vērtību un pārliecināties, vai varat palielināt precizitātes līmeni.

Ņemiet vērā, ka, mainot hiperparametru, jums jāizdzēš mape käynnā / vilciens4, pretējā gadījumā modelis sāksies ar iepriekš apmācīto modeli.

Apskatīsim, kā ir precizitāte ar hype

model_regu = tf.estimator.LinearClassifier(model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,optimizer=tf.train.FtrlOptimizer(learning_rate=0.1,l1_regularization_strength=0.9,l2_regularization_strength=5))

OUPUT

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_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}

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

OUPUT

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 ongoing/train4/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.INFO:tensorflow:Loss for final step: 43.4942.

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

IZVADE

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823{'accuracy': 0.83833915,'accuracy_baseline': 0.76377374,'auc': 0.8869794,'auc_precision_recall': 0.7014905,'average_loss': 0.34691378,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.12581,'precision': 0.69720596,'prediction/mean': 0.23662092,'recall': 0.5579823}

Izmantojot šo hiperparametru, jūs nedaudz palielināt precizitātes metriku. Nākamajā apmācībā jūs uzzināsiet, kā uzlabot lineāro klasifikatoru, izmantojot kodola metodi.

Kopsavilkums

Lai apmācītu modeli, jums:

• Definējiet pazīmes: Neatkarīgie mainīgie: X
• Definējiet iezīmi: Atkarīgais mainīgais: y
• Kontrolējiet vilcienu / testa komplektu
• Definējiet sākotnējo svaru
• Definējiet zaudējumu funkciju: MSE
• Optimizējiet modeli: gradienta nolaišanās
• Definēt:
  • Mācīšanās ātrums
  • Laikmeta skaits
  • Partijas lielums
  • Nodarbību skaits

Šajā apmācībā jūs uzzinājāt, kā lineārā regresijas klasifikatorā izmantot augsta līmeņa API. Jums jādefinē:

1. Iezīmju kolonnas. Ja nepārtraukts: tf.feature_column.numeric_column (). Sarakstu var aizpildīt ar python saraksta izpratni
2. Novērtētājs: tf.estimator.LinearClassifier (feature_columns, model_dir, n_classes = 2)
3. Funkcija datu, sērijas lieluma un laikmeta importēšanai: input_fn ()

Pēc tam jūs esat gatavs trenēties, novērtēt un izdarīt prognozi ar vilcienu (), novērtēt () un prognozēt ()

Lai uzlabotu modeļa veiktspēju, varat:

• Izmantojiet polinomu regresiju
• Mijiedarbības termins: tf.feature_column.crossed_column
• Pievienot regulēšanas parametru