Binær klassificering i TensorFlow: Eksempel på lineær klassificering

De to mest almindelige overvågede læringsopgaver er lineær regression og lineær klassifikator. Lineær regression forudsiger en værdi, mens den lineære klassifikator forudsiger en klasse. Denne tutorial er fokuseret på Lineær klassificering.

Hvad er lineær klassifikator?

En lineær klassifikator i maskinindlæring er en metode til at finde et objekts klasse baseret på dets egenskaber til statistisk klassificering. Det tager klassificeringsbeslutning baseret på værdien af ​​en lineær kombination af et objekts karakteristika. Lineær klassifikator bruges i praktiske problemer som dokumentklassificering og problemer med mange variabler.

Klassificeringsproblemer udgør ca. 80 procent af maskinlæringsopgaven. Klassifikation sigter mod at forudsige sandsynligheden for hver klasse givet et sæt input. Etiketten (dvs. den afhængige variabel) er en diskret værdi, kaldet en klasse.

1. Hvis etiketten kun har to klasser, er læringsalgoritmen en binær klassifikator.
2. Multiclass-klassificering tackler etiketter med mere end to klasser.

For eksempel er et typisk binært klassificeringsproblem at forudsige sandsynligheden for, at en kunde foretager et andet køb. Forudsig, at dyretypen, der vises på et billede, er et klassificeringsproblem i flere klasser, da der findes mere end to dyresorter.

Den teoretiske del af denne tutorial sætter primært fokus på binærklassen. Du vil lære mere om multiclass-outputfunktionen i en fremtidig tutorial.

I denne vejledning lærer du

• Hvad er lineær klassifikator?
• Hvordan fungerer binær klassificering?
• Hvordan måles ydeevnen for Lineær klassifikator?
• Nøjagtighed
• Forvirringsmatrix
• Præcision og følsomhed
• Lineær klassifikator med TensorFlow
• Trin 1) Importer dataene
• Trin 2) Datakonvertering
• Trin 3) Træn klassifikatoren
• Trin 4) Forbedre modellen
• Trin 5) Hyperparameter: Lasso & Ridge

Hvordan fungerer binær klassificering?

Du lærte i den foregående tutorial, at en funktion er sammensat af to slags variabler, en afhængig variabel og et sæt funktioner (uafhængige variabler). I den lineære regression er en afhængig variabel et reelt tal uden område. Det primære mål er at forudsige dens værdi ved at minimere den gennemsnitlige kvadratiske fejl.

For TensorFlow Binary Classifier kan etiketten have haft to mulige heltalværdier. I de fleste tilfælde er det enten [0,1] eller [1,2]. For eksempel er målet at forudsige, om en kunde vil købe et produkt eller ej. Mærket er defineret som følger:

• Y = 1 (kunde købte produktet)
• Y = 0 (kunden køber ikke produktet)

Modellen bruger funktionerne X til at klassificere hver kunde i den mest sandsynlige klasse, han tilhører, nemlig potentiel køber eller ej.

Sandsynligheden for succes beregnes med logistisk regression . Algoritmen beregner en sandsynlighed baseret på funktionen X og forudsiger en succes, når denne sandsynlighed er over 50 procent. Mere formelt beregnes sandsynligheden som vist i nedenstående eksempel på TensorFlow binær klassificering:

hvor 0 er sæt af vægte, funktionerne og b bias.

Funktionen kan nedbrydes i to dele:

• Den lineære model
• Den logistiske funktion

Lineær model

Du er allerede bekendt med måden, hvorpå vægtene beregnes. Vægte beregnes ved hjælp af et punktprodukt: Y er en lineær funktion af alle funktionerne x _i . Hvis modellen ikke har funktioner, er forudsigelsen lig med bias, b.

Vægtene angiver retningen af ​​sammenhængen mellem funktionerne x _i og etiketten y. En positiv korrelation øger sandsynligheden for den positive klasse, mens en negativ korrelation fører sandsynligheden tættere på 0 (dvs. negativ klasse).

Den lineære model returnerer kun det reelle tal, hvilket er uforeneligt med sandsynlighedsmålet for området [0,1]. Den logistiske funktion er nødvendig for at konvertere den lineære modeloutput til en sandsynlighed,

Logistisk funktion

Den logistiske funktion eller sigmoid-funktion har en S-form, og output af denne funktion er altid mellem 0 og 1.

Eksempel på logistisk funktion

Det er let at erstatte output fra den lineære regression til sigmoid-funktionen. Det resulterer i et nyt tal med en sandsynlighed mellem 0 og 1.

Klassifikatoren kan omdanne sandsynligheden til en klasse

• Værdier mellem 0 og 0,49 bliver klasse 0
• Værdier mellem 0,5 og 1 bliver klasse 1

Hvordan måles ydeevnen for Lineær klassifikator?

Nøjagtighed

Den samlede præstation for en klassifikator måles med nøjagtighedsmålingen. Nøjagtighed samler alle de korrekte værdier divideret med det samlede antal observationer. For eksempel betyder en nøjagtighedsværdi på 80 procent, at modellen er korrekt i 80 procent af tilfældene.

Mål præstationen for Lineær klassifikator ved hjælp af nøjagtighedsmåling

Du kan bemærke en mangel ved denne måling, især for ubalanceklasse. Et datasæt for ubalance opstår, når antallet af observationer pr. Gruppe ikke er lig. Lad os sige; du prøver at klassificere en sjælden begivenhed med en logistisk funktion. Forestil dig, at klassificeringen prøver at estimere en patients død efter en sygdom. I dataene dør 5 procent af patienterne. Du kan træne en klassifikator til at forudsige antallet af dødsfald og bruge nøjagtighedsmåling til at evaluere forestillingerne. Hvis klassifikatoren forudsiger 0 død for hele datasættet, vil det være korrekt i 95 procent af tilfældet.

Forvirringsmatrix

En bedre måde at vurdere præstationen for en klassifikator er at se på forvirringsmatrixen.

Mål ydeevnen for Lineær klassifikator ved hjælp af forvirringsmatrix

Forvirringsmatricen visualiserer nøjagtigheden af ​​en klassifikator ved at sammenligne de faktiske og forudsagte klasser som vist i ovenstående eksempel på lineær klassificering. Den binære forvirringsmatrix er sammensat af firkanter:

• TP: Ægte positive: Forudsagte værdier forudsiges korrekt som faktiske positive
• FP: Forudsagte værdier forudsagde forkert en faktisk positiv. dvs. negative værdier forudsagt som positive
• FN: Falsk negativ: Positive værdier forudsagt som negative
• TN: Sand negativ: Forudsagte værdier forudsiges korrekt som faktiske negative

Fra forvirringsmatrixen er det let at sammenligne den aktuelle klasse og den forudsagte klasse.

Præcision og følsomhed

Forvirringsmatrixen giver et godt indblik i det sande positive og falsk positive. I nogle tilfælde foretrækkes det at have en mere kortfattet metrik.

Præcision

Præcisionsmetricen viser nøjagtigheden af ​​den positive klasse. Det måler, hvor sandsynligt forudsigelsen af ​​den positive klasse er korrekt.

Den maksimale score er 1, når klassifikatoren perfekt klassificerer alle de positive værdier. Præcision alene er ikke særlig nyttig, fordi den ignorerer den negative klasse. Metricen parres normalt med Recall-metric. Recall kaldes også følsomhed eller ægte positiv hastighed.

Følsomhed

Sensitivity beregner forholdet mellem positive klasser, der registreres korrekt. Denne måling giver, hvor god modellen er til at genkende en positiv klasse.

Lineær klassifikator med TensorFlow

Til denne tutorial bruger vi folketællingsdatasættet. Formålet er at bruge variablerne i folketællingsdatasættet til at forudsige indkomstniveauet. Bemærk, at indkomsten er en binær variabel

• med en værdi på 1, hvis indkomsten> 50k
• 0 hvis indkomst <50k.

Denne variabel er din etiket

Dette datasæt indeholder otte kategoriske variabler:

• arbejdsplads
• uddannelse
• ægteskab
• beskæftigelse
• forhold
• race
• køn
• oprindelses land

desuden seks kontinuerlige variabler:

• alder
• fnlwgt
• uddannelsesnummer
• kapital_gevinst
• kapital-tab
• timer_uge

Gennem dette TensorFlow-klassificeringseksempel forstår du, hvordan du træner lineære TensorFlow-klassifikatorer med TensorFlow-estimator, og hvordan du forbedrer nøjagtighedsmåling.

Vi fortsætter som følger:

• Trin 1) Importer dataene
• Trin 2) Datakonvertering
• Trin 3) Træn klassifikatoren
• Trin 4) Forbedre modellen
• Trin 5) Hyperparameter: Lasso & Ridge

Trin 1) Importer dataene

Du importerer først de biblioteker, der blev brugt under selvstudiet.

import tensorflow as tfimport pandas as pd 

Dernæst importerer du dataene fra UCI-arkivet og definerer kolonnenavnene. Du bruger COLUMNS til at navngive kolonnerne i en pandadataramme.

Bemærk, at du vil træne klassifikatoren ved hjælp af en Pandas dataframe.

## 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"

Dataene, der er gemt online, er allerede delt mellem et togsæt og testsæt.

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)

Togsættet indeholder 32.561 observationer og testsættet 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 kræver en boolsk værdi for at træne klassifikatoren. Du skal kaste værdierne fra streng til heltal. Mærkaten gemmes som et objekt, men du skal konvertere den til en numerisk værdi. Koden nedenfor opretter en ordbog med de værdier, der skal konverteres og løses over kolonneelementet. Bemærk, at du udfører denne handling to gange, en til togtesten, en til testsættet

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]

I togedataene er der 24.720 indkomster lavere end 50.000 og 7841 ovenfor. Forholdet er næsten det samme for testsættet. Se denne vejledning om facetter for mere.

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

Trin 2) Datakonvertering

Der kræves et par trin, før du træner en lineær klassifikator med Tensorflow. Du skal forberede de funktioner, der skal medtages i modellen. I benchmark-regressionen bruger du de originale data uden at anvende nogen transformation.

Estimatoren skal have en liste over funktioner til at træne modellen. Derfor kræver søjlens data at blive konverteret til en tensor.

En god praksis er at definere to lister med funktioner baseret på deres type og derefter videregive dem i estimatorens funktion_kolonner.

Du begynder med at konvertere kontinuerlige funktioner og derefter definere en spand med de kategoriske data.

Datasætets funktioner har to formater:

• Heltal
• Objekt

Hver funktion er anført i de næste to variabler efter deres typer.

## 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']

Funktionskolonnen er udstyret med et objekt numerisk kolonne til at hjælpe med omdannelsen af ​​de kontinuerlige variabler til tensor. I koden nedenfor konverterer du alle variabler fra CONTI_FEATURES til en tensor med en numerisk værdi. Dette er obligatorisk for at konstruere modellen. Alle de uafhængige variabler skal konverteres til den rigtige type tensor.

Nedenfor skriver vi en kode, så du kan se, hvad der sker bag feature_column.numeric_column. Vi udskriver den konverterede værdi for alder. Det er til forklarende formål, derfor er der ikke behov for at forstå pythonkoden. Du kan henvise til den officielle dokumentation for at forstå koderne.

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ærdierne er nøjagtigt de samme som i df_train

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

Ifølge dokumentationen til TensorFlow er der forskellige måder at konvertere kategoriske data på. Hvis ordliste for en funktion er kendt og ikke har masser af værdier, er det muligt at oprette den kategoriske kolonne med categorical_column_with_vocabulary_list. Det tildeler et ID til alle unikke ordforrådslister.

For eksempel, hvis en variabelstatus har tre forskellige værdier:

• Ægtemand
• Kone
• Enkelt

Derefter tildeles tre ID. For eksempel vil mand have ID 1, Wife ID 2 og så videre.

Som illustration kan du bruge denne kode til at konvertere en objektvariabel til en kategorisk kolonne i TensorFlow.

Funktionskøn kan kun have to værdier: mand eller kvinde. Når vi konverterer funktionskøn, opretter Tensorflow 2 nye kolonner, en til mand og en til kvinde. Hvis køn er lig med mand, vil den nye kolonne mand være lig med 1 og kvinde til 0. Dette eksempel vises i nedenstående tabel:

rækker	køn	efter transformation	han-	kvinde
1	han-	=>	1	0
2	han-	=>	1	0
3	kvinde	=>	0	1

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

Nedenfor tilføjede vi Python-kode for at udskrive kodningen. Igen behøver du ikke forstå koden, formålet er at se transformationen

En hurtigere måde at transformere dataene er dog at bruge metoden categorical_column_with_hash_bucket. Ændring af strengvariabler i en sparsom matrix vil være nyttigt. En sparsom matrix er en matrix med stort set nul. Metoden tager sig af alt. Du skal kun angive antallet af skovle og nøglekolonnen. Antallet af skovle er det maksimale antal grupper, som Tensorflow kan oprette. Nøglekolonnen er simpelthen navnet på den kolonne, der skal konverteres.

I nedenstående kode opretter du en sløjfe over alle de kategoriske funktioner.

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

Trin 3) Træn klassifikatoren

TensorFlow giver i øjeblikket en estimator for lineær regression og lineær klassifikation.

• Lineær regression: LinearRegressor
• Lineær klassificering: LinearClassifier

Syntaksen for den lineære klassifikator er den samme som i vejledningen om lineær regression bortset fra et argument, n_class. Du skal definere funktionskolonnen, modelkataloget og sammenligne med den lineære regressor; du har defineret antallet af klasse. For en logit-regression er antallet af klasse lig med 2.

Modellen beregner vægten af ​​kolonnerne indeholdt i kontinuerlige_funktioner og kategoriske_funktioner.

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

PRODUKTION:

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}

Nu hvor klassifikatoren er defineret, kan du oprette inputfunktionen. Metoden er den samme som i den lineære regressor-tutorial. Her bruger du en batchstørrelse på 128, og du blander dataene.

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)

Du opretter en funktion med de argumenter, der kræves af den lineære estimator, dvs. antal epoker, antal batcher og blander datasættet eller noten. Da du bruger Pandas-metoden til at overføre dataene til modellen, skal du definere X-variablerne som en pandadataramme. Bemærk, at du løber over alle data, der er gemt i FUNKTIONER.

Lad os træne modellen med objektmodellen. Tog. Du bruger den tidligere definerede funktion til at fodre modellen med de relevante værdier. Bemærk, at du indstiller batchstørrelsen til 128 og antallet af epoker til Ingen. Modellen trænes over tusind trin.

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.

Bemærk, at tabet faldt efterfølgende i løbet af de sidste 100 trin, dvs. fra 901 til 1000.

Det endelige tab efter tusind iterationer er 5444. Du kan estimere din model på testsættet og se ydeevnen. For at evaluere ydeevnen af ​​din model skal du bruge objektet evaluere. Du fodrer modellen med testsættet og indstiller antallet af epoker til 1, dvs. dataene går kun til modellen en gang.

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 returnerer alle de målinger, du har lært i den teoretiske del. Uden overraskelse er nøjagtigheden stor på grund af den ubalancerede etiket. Faktisk fungerer modellen lidt bedre end et tilfældigt gæt. Forestil dig, at modellen forudsiger alle husstande med en indkomst under 50K, så har modellen en nøjagtighed på 70 procent. Ved en nærmere analyse kan du se forudsigelsen og tilbagekaldelsen er ret lave.

Trin 4) Forbedre modellen

Nu hvor du har en benchmark-model, kan du prøve at forbedre den, dvs. øge nøjagtigheden. I den forrige tutorial lærte du, hvordan du forbedrer forudsigelseskraften med et interaktionsudtryk. I denne vejledning vil du tage denne idé op igen ved at tilføje et polynomielt udtryk til regressionen.

Polynomial regression er instrumental, når der er ikke-linearitet i dataene. Der er to måder at registrere ikke-linearitet i dataene på.

• Tilføj polynomium
• Bucketize den kontinuerlige variabel til en kategorisk variabel

Polynomieudtryk

Fra billedet nedenfor kan du se, hvad en polynomial regression er. Det er en ligning med X-variabler med forskellig styrke. En andengrads polynomial regression har to variabler, X og X i kvadrat. Tredje grad har tre variabler, X, X ² og X ³

Hvad er polynomisk regression

Nedenfor konstruerede vi en graf med to variabler, X og Y. Det er tydeligt, at forholdet ikke er lineært. Hvis vi tilføjer en lineær regression, kan vi se, at modellen ikke er i stand til at fange mønsteret (venstre billede).

Se nu på det venstre billede fra nedenstående billede, vi tilføjede fem-sigt til regressionen (det vil sige y = x + x ² + x ³ + x ⁴ + x ^5. Modellen fanger nu langt bedre mønster. Dette er styrken ved polynomisk regression.

Lad os gå tilbage til vores eksempel. Alder er ikke i et lineært forhold til indkomst. Tidlig alder kan have en flad indkomst tæt på nul, fordi børn eller unge ikke arbejder. Derefter øges det i arbejdsalderen og falder under pension. Det er typisk en omvendt-U-form. En måde at fange dette mønster er ved at tilføje en magt to til regressionen.

Lad os se, om det øger nøjagtigheden.

Du skal tilføje denne nye funktion til datasættet og på listen over kontinuerlig funktion.

Du tilføjer den nye variabel i toget og testdatasættet, så det er mere bekvemt at skrive en funktion.

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

Funktionen har 3 argumenter:

• df_t: definer træningssættet
• df_te: definer testsæt
• var_name = 'age': Definer den variabel, der skal transformeres

Du kan bruge objektet pow (2) til at kvadratere den variable alder. Bemærk, at den nye variabel hedder 'ny'

Nu hvor funktionen square_var er skrevet, kan du oprette de nye datasæt.

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

Som du kan se, har det nye datasæt endnu en funktion.

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

Den firkantede variabel kaldes ny i datasættet. Du skal tilføje den til listen over kontinuerlige funktioner.

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]

Bemærk, at du har ændret kataloget til grafen. Du kan ikke træne forskellige modeller i samme bibliotek. Det betyder, at du skal ændre stien til argumentet model_dir. Hvis du ikke gør det, kaster TensorFlow en fejl.

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)

Nu hvor klassifikatoren er designet med det nye datasæt, kan du træne og evaluere modellen.

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}

Den kvadratiske variabel forbedrede nøjagtigheden fra 0,76 til 0,79. Lad os se, om du kan gøre det bedre ved at kombinere bucketization og interaktionsudtryk sammen.

Bucketization og interaktion

Som du så før, er en lineær klassificering ikke i stand til at registrere aldersindkomstmønsteret korrekt. Det skyldes, at det lærer en enkelt vægt for hver funktion. For at gøre det lettere for klassifikatoren er en ting, du kan gøre, at bukke funktionen. Bucketing forvandler en numerisk funktion til flere bestemte funktioner baseret på det interval, den falder i, og hver af disse nye funktioner indikerer, om en persons alder falder inden for dette interval.

Med disse nye funktioner kan den lineære model fange forholdet ved at lære forskellige vægte for hver spand.

I TensorFlow gøres det med bucketized_column. Du skal tilføje værdiområdet i grænserne.

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

Du ved allerede, at alder er ikke-lineær med indkomst. En anden måde at forbedre modellen på er gennem interaktion. I ordet TensorFlow er det funktionsovergang. Funktionsovergang er en måde at oprette nye funktioner på, som er kombinationer af eksisterende, hvilket kan være nyttigt for en lineær klassifikator, der ikke kan modellere interaktioner mellem funktioner.

Du kan nedbryde alder med en anden funktion som uddannelse. Det vil sige, at nogle grupper sandsynligvis har en høj indkomst og andre lave (tænk på ph.d.-studerende).

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

For at oprette en krydsfunktionssøjle bruger du crossed_column med variablerne til at krydse i en parentes. Hash_bucket_size angiver de maksimale krydsningsmuligheder. For at skabe interaktion mellem variabler (mindst en variabel skal være kategorisk) kan du bruge tf.feature_column.crossed_column. For at bruge dette objekt skal du tilføje den firkantede parentes til den variabel, der skal interagere, og et andet argument, skovlstørrelsen. Skovlstørrelsen er det maksimale antal mulige grupper inden for en variabel. Her indstilles det til 1000, da du ikke kender det nøjagtige antal grupper

age_buckets skal firkantes for at føje det til funktionskolonnerne. Du tilføjer også de nye funktioner til funktionskolonnerne og forbereder estimatoren

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)

PRODUKTION

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)

Du er klar til at estimere den nye model og se, om den forbedrer nøjagtigheden.

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}

Det nye nøjagtighedsniveau er 83,58 procent. Det er fire procent højere end den tidligere model.

Endelig kan du tilføje et reguleringsudtryk for at forhindre overmontering.

Trin 5) Hyperparameter: Lasso & Ridge

Din model kan lide af over- eller underudstyr .

• Overfitting: Modellen er ude af stand til at generalisere forudsigelsen til nye data
• Underfitting: Modellen er ikke i stand til at registrere mønsteret for dataene. dvs. lineær regression, når dataene er ikke-lineære

Når en model har mange parametre og en relativt lav mængde data, fører det til dårlige forudsigelser. Forestil dig, at en gruppe kun har tre observationer; modellen beregner en vægt for denne gruppe. Vægten bruges til at forudsige; hvis observationerne af testsættet for denne særlige gruppe er helt forskellige fra træningssættet, forudsiger modellen en forkert forudsigelse. Under evalueringen med træningssættet er nøjagtigheden god, men ikke god med testsættet, fordi de beregnede vægte ikke er den rigtige til at generalisere mønsteret. I dette tilfælde forudsiger den ikke en rimelig forudsætning for usete data.

For at forhindre overmontering giver regulering dig mulighederne for at kontrollere for en sådan kompleksitet og gøre den mere generaliserbar. Der er to reguleringsteknikker:

• L1: Lasso
• L2: Ryg

I TensorFlow kan du tilføje disse to hyperparametre i optimeringsværktøjet. For eksempel, jo højere hyperparameter L2 er, har vægten en tendens til at være meget lav og tæt på nul. Den monterede linje vil være meget flad, mens en L2 tæt på nul indebærer, at vægtene er tæt på den regelmæssige lineære regression.

Du kan selv prøve de forskellige værdier af hyperparametrene og se om du kan øge nøjagtighedsniveauet.

Bemærk, at hvis du skifter hyperparameter, skal du slette mappen igangværende / train4, ellers starter modellen med den tidligere uddannede model.

Lad os se, hvordan er nøjagtigheden med 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)

PRODUKTION

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}

Med dette hyperparameter øger du nøjagtighedsmålingerne lidt. I den næste vejledning lærer du, hvordan du forbedrer en lineær klassificering ved hjælp af en kernemetode.

Resumé

For at træne en model skal du:

• Definer funktionerne: Uafhængige variabler: X
• Definer etiketten: Afhængig variabel: y
• Konstruer et tog / testsæt
• Definer den indledende vægt
• Definer tabsfunktionen: MSE
• Optimer modellen: Gradient nedstigning
• Definere:
  • Læringsgrad
  • Antal epoker
  • Batchstørrelse
  • Antal klasser

I denne vejledning lærte du, hvordan du bruger API'en på højt niveau til en lineær regressionsklassifikator. Du skal definere:

1. Funktionskolonner. Hvis kontinuerlig: tf.feature_column.numeric_column (). Du kan udfylde en liste med pythonlisteforståelse
2. Estimatoren: tf.estimator.LinearClassifier (feature_column, model_dir, n_classes = 2)
3. En funktion til at importere data, batchstørrelse og epoke: input_fn ()

Derefter er du klar til at træne, evaluere og forudsige med tog (), evaluere () og forudsige ()

For at forbedre modelens ydeevne kan du:

• Brug polynomisk regression
• Interaktionsudtryk: tf.feature_column.crossed_column
• Tilføj normaliseringsparameter