TensorFlow binær klassifikation: Eksempel på lineær klassificering

Af: Redaktionelle team Redaktionelle team
Hours Opdateret

⚡ Smart opsummering

Lineære klassifikatorer tildeler hver observation til en klasse ud fra en vægtet sum af dens funktioner. Denne gennemgang bygger en TensorFlow binær klassifikator på folketællingsdatasættet og hæver nøjagtigheden fra 0.76 til 0.84.

  • 🔘 Kernedefinition: En lineær klassifikator forudsiger en diskret klasse ud fra en lineær kombination af funktionsværdier.
  • ☑️ Sandsynlighedstrin: Den logistiske funktion konverterer den lineære models output til en sandsynlighed mellem 0 og 1.
  • ✅ Målinger er vigtige: Nøjagtighed alene vildleder ved ubalancerede etiketter, så kombiner det med forvirringsmatricen, præcision og genkaldelse.
  • 🧪 Gennemgang af folketællingen: Seks kontinuerlige og otte kategoriske kolonner bliver tensorer, før estimatoren nogensinde ser dem.
  • 🛠️ Funktionsteknik: Ved at kvadrere alder, opdele den i flere grupper og derefter krydse uddannelse med beskæftigelse øges nøjagtigheden fra 0.7616 til 0.8358.
  • 📈 Regulering: En Ftrl-optimering med L1 på 0.9 og L2 på 5 skubber den endelige nøjagtighed til 0.8383.
Læs mere

TensorFlow binær klassificering lineær klassifikator

De to mest almindelige overvåget læring opgaver 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ære klassificeringsapparater.

Hvad er lineær klassificering?

A Lineær klassifikator i Machine Learning er en metode til at finde et objekts klasse baseret på dets karakteristika til statistisk klassificering. Den træffer klassificeringsbeslutning baseret på værdien af ​​en lineær kombination af karakteristika for et objekt. Lineær klassifikator bruges i praktiske problemer som dokumentklassificering og problemer med mange variabler.

Klassificeringsproblemer repræsenterer omkring 80 procent af maskinlæringsopgaven. Klassificering har til formål 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 indlæringsalgoritmen en binær klassifikator.
  2. Multiclass classifier tackler etiketter med mere end to klasser.

For eksempel er et typisk binært klassifikationsproblem at forudsige sandsynligheden for, at en kunde foretager et andet køb. Forudsige den type dyr, der vises på et billede, er et multiklasse-klassificeringsproblem, da der findes mere end to dyrevarianter.

Den teoretiske del af denne tutorial sætter primært fokus på den binære klasse. Du vil lære mere om multiclass output-funktionen i en fremtidig vejledning.

Når definitionen er på plads, er næste skridt at se, hvordan algoritmen omdanner rå funktioner til en klassebeslutning.

Hvordan virker binær klassificering?

Du lærte i den forrige tutorial, at en funktion er sammensat af to slags variable, 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 interval. Det primære formål er at forudsige dens værdi ved at minimere den gennemsnitlige kvadratiske fejl.

Til TensorFlow Binær klassifikator, etiketten kan have to mulige heltalsvæ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. Etiketten er defineret som følger:

  • Y = 1 (kunden 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 vil beregne 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 TensorFlow Binary Classification-eksempel:

Sigmoid sandsynlighedsformel brugt af en TensorFlow binær klassifikator

hvor 0 er mængden af ​​vægte, funktionerne og b bias.

Funktionen kan dekomponeres i to dele:

  • Den lineære model
  • Den logistiske funktion

Lineær model

Du er allerede bekendt med den måde, vægten beregnes på. Vægte beregnes ved hjælp af et prikprodukt:Prikproduktet af vægtvektoren og funktionsvektoren Y er en lineær funktion af alle træk xi. Hvis modellen ikke har funktioner, er forudsigelsen lig med bias, b.

Vægtene angiver retningen af ​​korrelationen mellem funktionerne xi 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 et reelt tal, hvilket er inkonsistent med sandsynlighedsmålet for rækkevidde [0,1]. Den logistiske funktion er påkrævet for at konvertere den lineære modeloutput til en sandsynlighed,

Logistisk funktion

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

Formlen nedenfor angiver transformationen, og det følgende plot viser den resulterende kurve, der flader ud mod 0 til venstre og mod 1 til højre.

Logistisk funktionsformel, der knytter en lineær score til en sandsynlighed

S-formet sigmoidkurve afgrænset mellem 0 og 1
Logistisk funktion eksempel

Det er let at erstatte outputtet af den lineære regression med sigmoidfunktionen. 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

Når modellen producerer klasser, skal du have en måde at vurdere, om disse klasser er gode.

Hvordan måler man ydeevnen af ​​Linear Classifier?

Nøjagtighed

Den samlede ydeevne af en klassifikator måles med nøjagtighedsmetrikken. Nøjagtighed indsamler 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.

Nøjagtighedsformel tæller korrekte forudsigelser over samlede observationer

Mål ydeevnen af ​​Linear Classifier ved hjælp af nøjagtighedsmetrik

Du kan bemærke en mangel med denne metrik, især for ubalanceklasse. Et ubalancedatasæt opstår, når antallet af observationer pr. gruppe ikke er det samme. Lad os sige; du forsøger at klassificere en sjælden hændelse med en logistisk funktion. Forestil dig, at klassificereren forsøger 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øjagtighedsmetrikken til at evaluere præstationerne. Hvis klassifikatoren forudsiger 0 dødsfald for hele datasættet, vil det være korrekt i 95 procent af tilfældene.

Forvirringsmatrix

En bedre måde at vurdere en klassifikators ydeevne er at se på forvirringsmatricen.

Binær forvirringsmatrix, der viser TP-, FP-, FN- og TN-kvadrater

Mål ydeevnen af ​​Linear Classifier ved hjælp af konfusionsmatrix

forvirringsmatrix visualiserer nøjagtigheden af ​​en klassifikator ved at sammenligne de faktiske og forudsagte klasser som vist i ovenstående Linear Classifier-eksempel. Den binære forvekslingsmatrix er sammensat af kvadrater:

  • TP: Sand positiv: Forudsagte værdier korrekt forudsagt som faktisk 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 korrekt forudsagt som faktisk negative

Fra forvirringsmatricen er det let at sammenligne den faktiske klasse og den forudsagte klasse.

Præcision og følsomhed

Forvirringsmatricen giver et godt indblik i de sande positive og falske positive. I nogle tilfælde er det at foretrække at have en mere kortfattet metrisk.

Precision

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

Præcisionsformel, sande positive tal frem for forudsagte positive tal

Den maksimale score er 1, når klassificereren perfekt klassificerer alle de positive værdier. Præcision alene er ikke særlig nyttig, fordi den ignorerer den negative klasse. Metrikken er normalt parret med Recall-metrikken. Genkaldelse kaldes også følsomhed eller sand positiv rate.

Følsomhed

Følsomhed beregner forholdet mellem positive klasser korrekt detekteret. Denne metrik viser, hvor god modellen er til at genkende en positiv klasse.

Følsomhedsformel, sande positiver frem for faktiske positiver

Teorien er nu på plads, så resten af ​​denne gennemgang anvender den fra ende til anden i koden.

Gå ikke glip af:

Lineær klassificering med TensorFlow

Til denne vejledning vil vi bruge folketællingsdatasættet. Formålet er at bruge variablerne i tæ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 variable:

  • arbejdsplads
  • uddannelse
  • ægteskabelig
  • besættelse
  • forhold
  • løb
  • køn
  • oprindelses land

desuden seks kontinuerte variable:

  • alder
  • fnlwgt
  • uddannelsesnummer
  • kapitalgevinst
  • kapitaltab
  • timer_uge

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

Versionsnotat: Koden nedenfor bruger TensorFlow 1.x Estimator API'en. tf-estimator Pakken blev sendt i sin endelige udgivelse med TensorFlow 2.15 og er ikke tilgængelig i TensorFlow 2.16 eller nyere, så kør disse snippets på TensorFlow 1.x, eller portér dem med den officielle guide til migrering af forudindstillede estimatorerKoncepterne, funktionsudviklingen og metrikken forbliver de samme.

Vi fortsætter som følger:

  • Trin 1) Importer dataene
  • Trin 2) Datakonvertering
  • Trin 3) Træn klassificereren
  • 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 tf
import pandas as pd

Derefter importerer du dataene fra UCI's arkiv og definerer kolonnenavnene. Du skal bruge KOLONNERNE til at navngive kolonnerne i en panda-dataramme.

Bemærk, at du træner klassificereren ved hjælp af en Pandas-dataramme.

## Define path data
COLUMNS = ['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"

De data, der er lagret online, er allerede opdelt mellem et togsæt og et 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                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label             object
dtype: object

TensorFlow kræver en boolsk værdi for at træne klassifikatoren. Du skal konvertere værdierne fra streng til heltal. Etiketten 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 som løber hen over kolonneelementet. Bemærk, at du udfører denne operation to gange, én for træningstesten og én for 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 togdataene er der 24,720 indkomster lavere end 50 og 7841 derover. Forholdet er næsten det samme for testsættet, så cirka 76 procent af begge opdelinger bærer den negative klasse.

print(df_train["label"].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test["label"].value_counts())
## Unbalanced label
print(df_train.dtypes)
0    24720
1     7841
Name: label, dtype: int64
0    12435
1     3846
Name: label, dtype: int64
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label              int64
dtype: 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 inkluderes i modellen. I benchmarkregressionen bruger du de originale data uden at anvende nogen transformation, præcis som en scikit-lære Pipeline ville starte fra rå kolonner.

Estimatoren skal have en liste over funktioner for at træne modellen. Derfor skal kolonnens data konverteres til en tensor.

En god praksis er at definere to lister over funktioner baseret på deres type og derefter sende dem i feature_columns i estimatoren.

Du vil begynde med at konvertere kontinuerlige funktioner og derefter definere en bøtte med de kategoriske data.

Datasættets funktioner har to formater:

  • Integer
  • Object

Hver funktion er angivet i de næste to variabler i henhold til deres typer.

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

Feature_column er udstyret med en objekt numeric_column for at hjælpe med at transformere de kontinuerlige variable til tensor. I koden nedenfor konverterer du alle variablerne 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, der viser dig, hvad der sker bag feature_column.numeric_column. Vi udskriver den konverterede værdi for age. Dette er kun til forklarende formål, så der er ingen grund til at forstå Python kode. Du kan se den officielle dokumentation for at forstå koderne.

def print_transformation(feature = "age", continuous = True, size = 2): 
    #X = fc.numeric_column(feature)
    ## Create feature name
    feature_names = [
    feature]

    ## Create dict with the data
    d = dict(zip(feature_names, [df_train[feature]]))

    ## Convert age
    if 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 value
    input_layer = tf.feature_column.input_layer(
        features=d,
        feature_columns=feature_columns
        )
    ## Create lookup table
    zero = tf.constant(0, dtype=tf.float32)
    where = tf.not_equal(input_layer, zero)
    ## Return lookup tble
    indices = tf.where(where)
    values = tf.gather_nd(input_layer, indices)
    ## Initiate graph
    sess = tf.Session()
    ## Print value
    print(sess.run(input_layer))
print_transformation(feature = "age", continuous = True) 
[[39.]
 [50.]
 [38.]
 ...
 [58.]
 [22.]
 [52.]]

Værdierne er nøjagtig de samme som i df_train

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

Ifølge TensorFlow-dokumentationen er der forskellige måder at konvertere kategoriske data på. Hvis ordforrådslisten for en funktion er kendt og ikke har mange værdier, er det muligt at oprette den kategoriske kolonne med kategorisk_kolonne_med_ordforrådsliste. Det vil tildele alle unikke ordforrådslister et ID.

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

  • mand
  • Kone
  • Single

Derefter vil tre ID blive tildelt. For eksempel vil Mand have ID 1, Kone ID 2 og så videre.

Til illustrationsformål kan du bruge denne kode til at konvertere en objektvariabel til en kategorisk kolonne i TensorFlow.

Funktionens køn kan kun have to værdier: mand eller kvinde. Når vi konverterer funktionens køn, opretter TensorFlow to nye kolonner, en for mand og en for kvinde. Hvis kønnet er lig med mand, vil den nye kolonne for mand være lig med 1 og kvinde med 0. Dette eksempel vises i tabellen nedenfor:

rækker køn efter transformation mand kvinde
1 mand => 1 0
2 mand => 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, du behøver ikke at forstå koden, formålet er at se transformationen

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

I koden nedenfor opretter du en løkke 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 klassificereren

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

  • Lineær regression: LineærRegressor
  • Lineær klassifikation: LinearClassifier

Syntaksen for den lineære klassifikator er den samme som i vejledningen om lineær regression undtagen et argument, n_class. Du skal definere funktionskolonnen, modelbiblioteket 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 vil beregne vægten af ​​kolonnerne indeholdt i continuous_features og categorical_features.

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': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x181f24c898>, '_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 klassificeringen 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 batches og blander datasættet eller noten. Siden du bruger pandas metode til at sende dataene ind i modellen, skal du definere X-variablerne som en panda-dataramme. Bemærk, at du går over alle data, der er gemt i FEATURES.

Lad os træne modellen med objektet model.train. Du bruger den tidligere definerede funktion til at fodre modellen med de passende værdier. Bemærk, at du indstiller batchstørrelsen til 128 og antallet af epoker til Ingen. Modellen vil blive trænet 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 = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO: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.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

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

Det endelige tab efter tusinde iterationer er 5444. Du kan estimere din model på testsættet og se ydeevnen. For at evaluere din models ydeevne skal du bruge objektevalueringen. Du fodrer modellen med testsættet og indstiller antallet af epoker til 1, dvs. dataene vil kun gå til modellen én 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:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO: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:23
INFO: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 klarer modellen sig lidt bedre end et tilfældigt gæt. Forestil dig, at modellen forudsiger alle husstande med indkomst lavere end 50K, så har modellen en nøjagtighed på 70 procent. Ved en nærmere analyse kan du se forudsigelsen og tilbagekaldelsen er ret lav.

Trin 4) Forbedre modellen

Nu hvor du har en benchmark-model, kan du prøve at forbedre den, det vil sige øge nøjagtigheden. I det forrige selvstudie lærte du, hvordan du forbedrer forudsigelseskraften med et interaktionsudtryk. I denne øvelse vil du gense denne idé ved at tilføje et polynomielt udtryk til regressionen.

Polynomiel regression er medvirkende, når der er ikke-linearitet i dataene. Der er to måder at fange ikke-linearitet i dataene.

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

Polynomisk udtryk

Fra billedet nedenfor kan du se, hvad en polynomiel regression er. Det er en ligning med X-variable med forskellig styrke. En andengrads polynomiel regression har to variable, X og X i anden. Tredje grad har tre variabler, X, X2, og X3

Anden- og tredjegrads polynomielle regressionsligninger

Hvad er polynomiel regression

Diagrammet ovenfor viser en andengradskurve mod den underliggende ligning. Nedenfor har vi konstrueret 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 indfange mønsteret (venstre billede).

Se nu på det venstre billede fra billedet nedenfor, vi tilføjede fem-led til regressionen (det vil sige y=x+x2+x3+x4+x5. Modellen fanger nu mønsteret langt bedre. Dette er kraften i polynomiel regression.

Lineær tilpasning versus en femterms polynomiel tilpasning på samme scatterplot

Lad os gå tilbage til vores eksempel. Alder er ikke i et lineært forhold til indkomst. Den tidlige alder kan have en flad indkomst tæt på nul, fordi børn eller unge ikke arbejder. Så stiger den i den erhvervsaktive alder og falder under pensioneringen. Det er typisk en omvendt U-form. En måde at fange dette mønster på er ved at tilføje en potens 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 kontinuerlige funktioner.

Du tilføjer den nye variabel i tog- 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ættet
  • var_name = 'alder': Definer den variabel, der skal transformeres

Du kan bruge objektet pow(2) til at kvadre 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 kvadratiske variabel kaldes ny i datasættet. Du skal tilføje det 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 mappen til grafen. Du kan ikke træne forskellige modeller i den samme mappe. Det betyder, at du skal ændre stien til argumentet model_dir. Hvis du ikke gør det, vil TensorFlow give 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': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x1820f04b70>, '_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 klassificereren 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 = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO: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.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>

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:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO: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:39
INFO: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 klassifikator ikke i stand til at fange aldersindkomstmønsteret korrekt. Det er fordi den lærer en enkelt vægt for hver funktion. For at gøre det nemmere for klassificereren er én ting, du kan gøre, at indsætte funktionen. Bucking omdanner en numerisk funktion til flere bestemte, baseret på det interval, den falder ind i, og hver af disse nye funktioner angiver, 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 rækken af ​​værdier 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. Med TensorFlows ord er det funktionskrydsning. Featurekrydsning er en måde at skabe nye funktioner, der 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 lav (tænk på den 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 krydselementkolonne 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 én variabel skal være kategorisk), kan du bruge tf.feature_column.crossed_column. For at bruge dette objekt skal du tilføje variablen til at interagere i firkantet parentes og et andet argument, bøttestørrelsen. Spandstørrelsen er det maksimale antal mulige grupper inden for en variabel. Her sætter du den til 1000 da du ikke kender det præcise antal grupper

age_buckets skal kvadreres før for at tilføje det til funktionskolonnerne. Du tilføjer også de nye funktioner til egenskabskolonnerne 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1823021be0>, '_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 = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO: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.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>

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:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO: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:54
INFO: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.

Til sidst kan du tilføje en regulariseringsterm for at forhindre overfitting.

Trin 5) Hyperparameter: Lasso & Ridge

Din model kan lide under overmontering or undertilpasning.

  • Overfitting: Modellen er ikke i stand til at generalisere forudsigelsen til nye data
  • Undertilpasning: Modellen er ikke i stand til at fange mønsteret af 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 én gruppe kun har tre observationer; modellen vil beregne en vægt for denne gruppe. Vægten bruges til at lave en forudsigelse; hvis observationerne af testsættet for denne særlige gruppe er helt anderledes end træningssættet, vil modellen lave 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 giver den ikke en rimelig forudsigelse om usete data.

For at forhindre overfitting giver regularisering dig muligheder for at kontrollere en sådan kompleksitet og gøre den mere generaliserbar. Der er to regulariseringsteknikker:

  • L1: Lasso
  • L2: Ryg

I TensorFlow kan du tilføje disse to hyperparametre i optimizeren. 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 tilpassede linje vil være meget flad, mens en L2 tæt på nul betyder, at vægtene er tæt på den regulære 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 ændrer hyperparameteren, skal du slette mappen ongoing/train4 ellers starter modellen med den tidligere trænede model.

Lad os se, hvordan er nøjagtigheden med hypen

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

Produktion

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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820d9c128>, '_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)

Produktion

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 = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO: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.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>

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:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO: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:09
INFO: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 denne hyperparameter øger du nøjagtighedsmålingerne en smule. Tabellen nedenfor samler alle målinger, der rapporteres af de fire evalueringskald i denne vejledning.

Model Funktionssæt Nøjagtighed AUC Precision Recall
model Baseline kontinuerlig + kategorisk 0.7615626 0.63300294 0.49401596 0.38637546
model_1 Basislinje plus kvadreret alder 0.7944229 0.6093755 0.6682401 0.2576703
model_imp Spækket alder plus krydsede kolonner 0.8358209 0.88401634 0.68986726 0.55408216
model_regul Krydsede kolonner plus L1 og L2 0.83833915 0.8869794 0.69720596 0.5579823

Bemærk, at basisnøjagtigheden for en model, der altid forudsiger majoritetsklassen, er 0.76377374, så kun de sidste to modeller slår et trivielt gæt med en brugbar margin.

I den næste vejledning lærer du, hvordan du forbedrer en lineær klassifikator ved hjælp af en kernemetode.

Ofte Stillede Spørgsmål

Logistisk regression er én type lineær klassifikator. Den tilpasser en lineær score og presser den derefter gennem en sigmoid for at returnere kalibrerede sandsynligheder. Andre lineære klassifikatorer, såsom en lineær SVM eller en perceptron, deler den lineære grænse, men optimerer et andet tab.

En lineær SVM optimerer hængselstab, og kun marginpunkterne påvirker grænsen, hvilket hjælper på små, støjende datasæt. Logistisk regression trænes hurtigere på meget store data og returnerer sandsynlighedsestimater, hvilket er vigtigt, når du har brug for en justerbar beslutningstærskel.

Nej. Pakken tf-estimator blev leveret i sin seneste udgivelse sammen med TensorFlow 2.15 og findes ikke i TensorFlow 2.16 og fremefter. Kør denne vejledning på TensorFlow 1.x, eller migrer den standardiserede estimator til en Keras lineær model ved hjælp af den officielle migreringsvejledning.

Automatiserede søgebiblioteker behandler L1, L2, læringshastighed og bucket-grænser som et søgerum og bruger derefter Bayesiansk optimering eller banditmetoder til at beskære svage forsøg tidligt. Det erstatter den manuelle scanning, som denne vejledning foreslår, og finder normalt et bedre regulariseringspar.

Copilot udarbejder hurtigt gentagne standardtekster for feature_columns, inklusive listeforståelser over kontinuerlige kolonner og blokke med krydsede kolonner. Behandl outputtet som et første udkast – verificer hvert API-navn mod den version, du kører, fordi Copilot blander TensorFlow 1.x og 2.x-idiomer.

Den angiver antallet af buckets, som en kategorisk kolonne hashes ind i. En for lille værdi tvinger uafhængige kategorier til at kollidere og dele en vægt; en for stor værdi spilder hukommelse. Sæt den komfortabelt over antallet af distinct-values, som denne vejledning gør med 1000.

Tilføjelse af det kvadrerede led ændrer modellen i retning af at forudsige majoritetsklassen mere sikkert. Præcisionen stiger til 0.6682, mens recall falder til 0.2577, hvilket er den sædvanlige præcision-recall-afvejning ved en ubalanceret etiket snarere end en kodningsfejl.

Brug en kerne, når der ikke er nogen lineær grænse, der adskiller klasserne, selv efter bucketing og feature crossing. Kerner mapper implicit data ind i et højere dimensionelt rum, hvilket giver langsommere træning og svagere fortolkningsevne end de lineære vægte, der er vist her.

Opsummer dette indlæg med: