Binær klassifisering i TensorFlow: Lineær klassifiseringseksempel

Innholdsfortegnelse:

Anonim

De to vanligste veiledede læringsoppgavene er lineær regresjon og lineær klassifisering. Lineær regresjon forutsier en verdi mens den lineære klassifisereren forutsier en klasse. Denne opplæringen er fokusert på Linear Classifier.

Hva er Linear Classifier?

En lineær klassifisering i maskinlæring er en metode for å finne et objekts klasse basert på dets egenskaper for statistisk klassifisering. Det tar en klassifiseringsbeslutning basert på verdien av en lineær kombinasjon av egenskapene til et objekt. Lineær klassifikator brukes i praktiske problemer som dokumentklassifisering og problemer med mange variabler.

Klassifiseringsproblemer representerer omtrent 80 prosent av maskinlæringsoppgaven. Klassifisering tar sikte på å forutsi sannsynligheten for at hver klasse får et sett med innganger. Merkelappen (dvs. den avhengige variabelen) er en diskret verdi, kalt en klasse.

  1. Hvis etiketten bare har to klasser, er læringsalgoritmen en binær klassifisering.
  2. Multiklass klassifisering takler etiketter med mer enn to klasser.

For eksempel er et typisk binært klassifiseringsproblem å forutsi sannsynligheten for at en kunde foretar et nytt kjøp. Forutsi at dyretypen som vises på et bilde er et klassifiseringsproblem i flere klasser siden det finnes mer enn to varianter av dyr.

Den teoretiske delen av denne opplæringen setter hovedfokus på binærklassen. Du vil lære mer om multiklass-utgangsfunksjonen i en fremtidig opplæring.

I denne veiledningen vil du lære

  • Hva er Linear Classifier?
  • Hvordan fungerer binær klassifisering?
  • Hvordan måler du ytelsen til Linear Classifier?
  • Nøyaktighet
  • Forvirringsmatrise
  • Presisjon og følsomhet
  • Lineær klassifisering med TensorFlow
  • Trinn 1) Importer dataene
  • Trinn 2) Datakonvertering
  • Trinn 3) Tren klassifisereren
  • Trinn 4) Forbedre modellen
  • Trinn 5) Hyperparameter: Lasso & Ridge

Hvordan fungerer binær klassifisering?

Du lærte i forrige opplæring at en funksjon består av to typer variabler, en avhengig variabel og et sett med funksjoner (uavhengige variabler). I den lineære regresjonen er en avhengig variabel et reelt tall uten område. Det primære målet er å forutsi verdien ved å minimere den gjennomsnittlige kvadratiske feilen.

For TensorFlow Binary Classifier kan etiketten ha hatt to mulige heltallverdier. I de fleste tilfeller er det enten [0,1] eller [1,2]. For eksempel er målet å forutsi om en kunde vil kjøpe et produkt eller ikke. Merkelappen er definert som følger:

  • Y = 1 (kunde kjøpte produktet)
  • Y = 0 (kunden kjøper ikke produktet)

Modellen bruker funksjonene X for å klassifisere hver kunde i den mest sannsynlige klassen han tilhører, nemlig potensiell kjøper eller ikke.

Sannsynligheten for suksess beregnes med logistisk regresjon . Algoritmen vil beregne en sannsynlighet basert på funksjonen X og forutsier en suksess når denne sannsynligheten er over 50 prosent. Mer formelt beregnes sannsynligheten som vist i nedenstående eksempel på TensorFlow binær klassifisering:

hvor 0 er settet med vekter, funksjonene og b skjevheten.

Funksjonen kan spaltes i to deler:

  • Den lineære modellen
  • Den logistiske funksjonen

Lineær modell

Du er allerede kjent med måten vektene beregnes på. Vekter beregnes ved hjelp av et punktprodukt: Y er en lineær funksjon av alle funksjonene x i . Hvis modellen ikke har funksjoner, er prediksjonen lik bias, b.

Vektene indikerer retningen på korrelasjonen mellom funksjonene x i og etiketten y. En positiv korrelasjon øker sannsynligheten for den positive klassen mens en negativ korrelasjon fører sannsynligheten nærmere 0, (dvs. negativ klasse).

Den lineære modellen returnerer bare reelt tall, som er uforenlig med sannsynlighetsmålet for området [0,1]. Den logistiske funksjonen er nødvendig for å konvertere den lineære modellutgangen til en sannsynlighet,

Logistisk funksjon

Den logistiske funksjonen, eller sigmoid-funksjonen, har en S-form, og utgangen av denne funksjonen er alltid mellom 0 og 1.

Logistisk funksjon eksempel

Det er lett å erstatte utgangen fra den lineære regresjonen til sigmoidfunksjonen. Det resulterer i et nytt tall med en sannsynlighet mellom 0 og 1.

Klassifisereren kan forvandle sannsynligheten til en klasse

  • Verdier mellom 0 og 0,49 blir klasse 0
  • Verdier mellom 0,5 og 1 blir klasse 1

Hvordan måler du ytelsen til Linear Classifier?

Nøyaktighet

Den generelle ytelsen til en klassifikator måles med nøyaktighetsberegningen. Nøyaktighet samler alle riktige verdier delt på totalt antall observasjoner. For eksempel betyr en nøyaktighetsverdi på 80 prosent at modellen er korrekt i 80 prosent av tilfellene.

Mål ytelsen til Lineær klassifiser ved å bruke nøyaktighetsmåling

Du kan merke en mangel med denne beregningen, spesielt for ubalanseklasse. Et ubalansedatasett oppstår når antall observasjoner per gruppe ikke er like. La oss si; du prøver å klassifisere en sjelden hendelse med en logistisk funksjon. Tenk deg at klassifisereren prøver å estimere en pasients død etter en sykdom. I dataene går 5 prosent av pasientene bort. Du kan trene en klassifikator for å forutsi antall dødsfall og bruke nøyaktighetsberegningen for å evaluere forestillingene. Hvis klassifisereren forutsier 0 død for hele datasettet, vil det være riktig i 95 prosent av saken.

Forvirringsmatrise

En bedre måte å vurdere ytelsen til en klassifikator er å se på forvirringsmatrisen.

Mål ytelsen til Lineær klassifiser ved hjelp av forvirringsmatrise

Forvirringsmatrisen visualiserer nøyaktigheten til en klassifikator ved å sammenligne de faktiske og forutsagte klassene som vist i eksemplet ovenfor for Lineær klassifisering. Den binære forvirringsmatrisen er sammensatt av firkanter:

  • TP: True Positive: Forutsagte verdier korrekt forutsagt som faktisk positive
  • FP: Forutsagte verdier forutsa feil en faktisk positiv. dvs. negative verdier spådd som positive
  • FN: False Negative: Positive verdier spådd som negative
  • TN: True Negative: Forutsi verdier korrekt forutsagt som faktisk negativ

Fra forvirringsmatrisen er det enkelt å sammenligne den faktiske klassen og den forutsagte klassen.

Presisjon og følsomhet

Forvirringsmatrisen gir et godt innblikk i det sanne positive og falske positive. I noen tilfeller er det å foretrekke å ha en mer kortfattet beregning.

Presisjon

Presisjonsmåling viser nøyaktigheten til den positive klassen. Den måler hvor sannsynlig spådommen til den positive klassen er riktig.

Maksimal poengsum er 1 når klassifisereren perfekt klassifiserer alle positive verdier. Presisjon alene er ikke veldig nyttig fordi den ignorerer den negative klassen. Beregningen er vanligvis parret med tilbakekallingsverdien. Tilbakekalling kalles også følsomhet eller ekte positiv hastighet.

Følsomhet

Sensitivity beregner forholdet mellom positive klasser som er riktig oppdaget. Denne beregningen gir hvor god modellen er å gjenkjenne en positiv klasse.

Lineær klassifisering med TensorFlow

For denne opplæringen vil vi bruke tellingsdatasettet. Hensikten er å bruke variablene i folketellingsdatasettet for å forutsi inntektsnivået. Merk at inntekten er en binær variabel

  • med en verdi på 1 hvis inntekten> 50k
  • 0 hvis inntekt <50k.

Denne variabelen er din etikett

Dette datasettet inneholder åtte kategoriske variabler:

  • arbeidsplass
  • utdanning
  • ekteskapelig
  • okkupasjon
  • forhold
  • løp
  • kjønn
  • hjemland

dessuten seks kontinuerlige variabler:

  • alder
  • fnlwgt
  • utdanning_nummer
  • kapital_gevinst
  • kapital_tap
  • times_uke

Gjennom dette TensorFlow-klassifiseringseksemplet vil du forstå hvordan du trener lineære TensorFlow-klassifikatorer med TensorFlow-estimator og hvordan du kan forbedre nøyaktighetsberegningen.

Vi fortsetter som følger:

  • Trinn 1) Importer dataene
  • Trinn 2) Datakonvertering
  • Trinn 3) Tren klassifisereren
  • Trinn 4) Forbedre modellen
  • Trinn 5) Hyperparameter: Lasso & Ridge

Trinn 1) Importer dataene

Du importerer først bibliotekene som ble brukt under opplæringen.

import tensorflow as tfimport pandas as pd

Deretter importerer du dataene fra UCI-arkivet og definerer kolonnenavnene. Du vil bruke KOLONNENE til å navngi kolonnene i en panda-dataramme.

Merk at du vil trene klassifisereren ved hjelp av et Pandas-dataramme.

## 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 som er lagret på nettet er allerede delt mellom togsett og testsett.

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)

Togsettet inneholder 32 561 observasjoner og testsettet 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 krever en boolsk verdi for å trene klassifisereren. Du må kaste verdiene fra streng til heltall. Etiketten er lagret som et objekt, men du må konvertere den til en numerisk verdi. Koden nedenfor lager en ordbok med verdiene som skal konverteres og løpes over kolonneelementet. Merk at du utfører denne operasjonen to ganger, en for togtesten, en for testsettet

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 togsdataene er det 24720 inntekter lavere enn 50 000 og 7841 over. Forholdet er nesten det samme for testsettet. Se denne veiledningen om fasetter for mer.

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

Trinn 2) Datakonvertering

Noen få trinn kreves før du trener en lineær klassifikator med Tensorflow. Du må forberede funksjonene som skal inkluderes i modellen. I referanseindeksen vil du bruke de opprinnelige dataene uten å bruke noen transformasjon.

Estimatoren må ha en liste over funksjoner for å trene modellen. Derfor krever kolonnens data å konverteres til en tensor.

En god praksis er å definere to lister med funksjoner basert på type og deretter sende dem i funksjonskolonnene i estimatoren.

Du begynner med å konvertere kontinuerlige funksjoner, og deretter definere en bøtte med de kategoriske dataene.

Funksjonene i datasettet har to formater:

  • Heltall
  • Gjenstand

Hver funksjon er oppført i de neste to variablene etter typene.

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

Funksjonskolonnen er utstyrt med et objekt numerisk kolonne for å hjelpe til med transformasjonen av de kontinuerlige variablene til tensor. I koden nedenfor konverterer du alle variablene fra CONTI_FEATURES til en tensor med en numerisk verdi. Dette er obligatorisk for å konstruere modellen. Alle uavhengige variabler må konverteres til riktig type tensor.

Nedenfor skriver vi en kode for å la deg se hva som skjer bak feature_column.numeric_column. Vi vil skrive ut den konverterte verdien for alder. Det er for å forklare formålet, derfor er det ikke nødvendig å forstå pythonkoden. Du kan se i den offisielle dokumentasjonen for å forstå kodene.

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

Verdiene er nøyaktig de samme som i df_train

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

I følge TensorFlow-dokumentasjon er det forskjellige måter å konvertere kategoriske data på. Hvis ordlisten til en funksjon er kjent og ikke har mange verdier, er det mulig å lage den kategoriske kolonnen med categorical_column_with_vocabulary_list. Den vil tildele alle unike ordforråd en ID.

For eksempel, hvis en variabelstatus har tre forskjellige verdier:

  • Ektemann
  • Kone
  • Enkelt

Deretter tildeles tre ID. For eksempel vil mannen ha ID 1, Kone ID 2 og så videre.

For illustrasjonsformål kan du bruke denne koden til å konvertere en objektvariabel til en kategorisk kolonne i TensorFlow.

Funksjonskjønnet kan bare ha to verdier: mann eller kvinne. Når vi konverterer funksjonskjønnet, oppretter Tensorflow to nye kolonner, en for mann og en for kvinne. Hvis kjønnet er lik mann, vil den nye kolonnen hann være lik 1 og hunn til 0. Dette eksemplet vises i tabellen nedenfor:

rader

kjønn

etter transformasjon

hann

hunn

1

hann

=>

1

0

2

hann

=>

1

0

3

hunn

=>

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 la vi til Python-kode for å skrive ut kodingen. Igjen, du trenger ikke å forstå koden, formålet er å se transformasjonen

En raskere måte å transformere dataene er imidlertid å bruke metoden categorical_column_with_hash_bucket. Å endre strengvariabler i en sparsom matrise vil være nyttig. En sparsom matrise er en matrise med stort sett null. Metoden tar vare på alt. Du trenger bare å spesifisere antall bøtter og nøkkelkolonnen. Antall bøtter er det maksimale antall grupper som Tensorflow kan opprette. Nøkkelkolonnen er ganske enkelt navnet på kolonnen som skal konverteres.

I koden nedenfor oppretter du en løkke over alle de kategoriske funksjonene.

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

Trinn 3) Tren klassifisereren

TensorFlow gir for øyeblikket en estimator for lineær regresjon og lineær klassifisering.

  • Lineær regresjon: LinearRegressor
  • Lineær klassifisering: LinearClassifier

Syntaksen til den lineære klassifisereren er den samme som i opplæringen om lineær regresjon bortsett fra ett argument, n_class. Du må definere funksjonskolonnen, modellkatalogen og sammenligne med den lineære regressoren; du har definert antall klasser. For en logit regresjon er det antall klasser lik 2.

Modellen vil beregne vektene til kolonnene som er inkludert i kontinuerlige funksjoner og kategoriske funksjoner.

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

PRODUKSJON:

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}

Nå som klassifisereren er definert, kan du opprette inndatafunksjonen. Metoden er den samme som i den lineære regressorveiledningen. Her bruker 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 oppretter en funksjon med argumentene som kreves av den lineære estimatoren, dvs. antall epoker, antall batcher og blander datasettet eller notatet. Siden du bruker Pandas-metoden for å overføre dataene til modellen, må du definere X-variablene som en pandadataramme. Merk at du sløyfer over alle dataene som er lagret i FUNKSJONER.

La oss trene modellen med objektmodellen. Tog. Du bruker funksjonen som er definert tidligere for å mate modellen med passende verdier. Merk at du setter batchstørrelsen til 128 og antall epoker til Ingen. Modellen vil bli trent over tusen trinn.

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.

Vær oppmerksom på at tapet ble redusert i løpet av de siste 100 trinnene, dvs. fra 901 til 1000.

Det endelige tapet etter tusen iterasjoner er 5444. Du kan estimere modellen din på testsettet og se ytelsen. For å evaluere ytelsen til modellen din, må du bruke objektet evaluere. Du mater modellen med testsettet og setter antall epoker til 1, dvs. dataene vil bare gå 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 beregningene du lærte i den teoretiske delen. Uten overraskelse er nøyaktigheten stor på grunn av den ubalanserte etiketten. Egentlig fungerer modellen litt bedre enn en tilfeldig gjetning. Tenk deg at modellen forutsier alle husholdninger med inntekt lavere enn 50 000, så har modellen en nøyaktighet på 70 prosent. Ved en nærmere analyse kan du se spådommen og tilbakekallingen er ganske lav.

Trinn 4) Forbedre modellen

Nå som du har en standardmodell, kan du prøve å forbedre den, det vil si øke nøyaktigheten. I forrige opplæring lærte du hvordan du kan forbedre prediksjonskraften med et interaksjonsuttrykk. I denne veiledningen vil du gå tilbake til denne ideen ved å legge til et polynomielt begrep i regresjonen.

Polynomial regresjon er instrumental når det er ikke-linearitet i dataene. Det er to måter å fange opp ikke-linearitet i dataene.

  • Legg til polynomuttrykk
  • Sett den kontinuerlige variabelen i en kategorisk variabel

Polynom begrep

Fra bildet nedenfor kan du se hva en polynomial regresjon er. Det er en ligning med X-variabler med forskjellig kraft. En annengrads polynomial regresjon har to variabler, X og X i kvadrat. Tredje grad har tre variabler, X, X 2 og X 3

Hva er polynomisk regresjon

Nedenfor konstruerte vi en graf med to variabler, X og Y. Det er åpenbart at forholdet ikke er lineært. Hvis vi legger til en lineær regresjon, kan vi se at modellen ikke klarer å fange opp mønsteret (venstre bilde).

Nå, se på venstre bilde fra bildet nedenfor, vi la til fem-term til regresjonen (det vil si y = x + x 2 + x 3 + x 4 + x 5. Modellen fanger nå mønsteret bedre. Dette er kraften til polynomisk regresjon.

La oss gå tilbake til eksemplet vårt. Alder er ikke i et lineært forhold til inntekt. Tidlig alder kan ha en flat inntekt nær null fordi barn eller unge ikke jobber. Da øker den i yrkesaktiv alder og avtar under pensjon. Det er vanligvis en omvendt U-form. En måte å fange dette mønsteret på er å legge en kraft to til regresjonen.

La oss se om det øker nøyaktigheten.

Du må legge til denne nye funksjonen i datasettet og i listen over kontinuerlige funksjoner.

Du legger til den nye variabelen i toget og testdatasettet, så det er mer praktisk å skrive en funksjon.

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

Funksjonen har 3 argumenter:

  • df_t: definer treningssettet
  • df_te: definere testsettet
  • var_name = 'age': Definer variabelen som skal transformeres

Du kan bruke objektet pow (2) til å kvadratere variabel alder. Merk at den nye variabelen heter 'ny'

Nå som funksjonen square_var er skrevet, kan du opprette de nye datasettene.

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

Som du kan se, har det nye datasettet en funksjon til.

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

Firkantvariabelen kalles ny i datasettet. Du må legge den til i listen over kontinuerlige funksjoner.

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]

Merk at du endret katalogen til grafen. Du kan ikke trene forskjellige modeller i samme katalog. Det betyr at du må endre banen til argumentet model_dir. Hvis du ikke gjør det, vil TensorFlow kaste en feil.

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)

Nå som klassifisereren er designet med det nye datasettet, kan du trene 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 variabelen forbedret nøyaktigheten fra 0,76 til 0,79. La oss se om du kan gjøre det bedre ved å kombinere bucketization og interaksjonsterm sammen.

Bucketization og interaksjon

Som du så før, er en lineær klassifikator ikke i stand til å fange aldersinntektsmønsteret riktig. Det er fordi den lærer en enkelt vekt for hver funksjon. For å gjøre det lettere for klassifisereren, er en ting du kan gjøre å skuffe funksjonen. Bucketing forvandler en numerisk funksjon til flere bestemte, basert på rekkevidden den faller inn i, og hver av disse nye funksjonene indikerer om en persons alder faller innenfor det området.

Med disse nye funksjonene kan den lineære modellen fange forholdet ved å lære forskjellige vekter for hver bøtte.

I TensorFlow gjøres det med bucketized_column. Du må legge til verdiområdet i grensene.

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 vet allerede at alder er ikke-lineær med inntekt. En annen måte å forbedre modellen på er gjennom interaksjon. I ordet TensorFlow er det funksjonskryssing. Funksjonskryssing er en måte å lage nye funksjoner som er kombinasjoner av eksisterende, noe som kan være nyttig for en lineær klassifikator som ikke kan modellere interaksjoner mellom funksjoner.

Du kan bryte ned alder med en annen funksjon som utdanning. Det vil si at det er sannsynlig at noen grupper har høy inntekt og andre lave (Tenk på doktorgradsstudenten).

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 å opprette en kryssfunksjonskolonne bruker du crossed_column med variablene for å krysse i en parentes. Hash_bucket_size angir maksimale kryssingsmuligheter. For å skape samspill mellom variabler (minst én variabel må være kategorisk), kan du bruke tf.feature_column.crossed_column. For å bruke dette objektet, må du legge til variabelen som skal samhandles i firkantet parentes og et annet argument, skuffestørrelsen. Skuffestørrelsen er det maksimale antall grupper som er mulig i en variabel. Her setter du den til 1000, da du ikke vet nøyaktig antall grupper

age_buckets må firkantes før det legges til funksjonskolonnene. Du legger også til de nye funksjonene i funksjonskolonnene 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)

PRODUKSJON

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 å estimere den nye modellen og se om den forbedrer nøyaktigheten.

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øyaktighetsnivået er 83,58 prosent. Det er fire prosent høyere enn forrige modell.

Til slutt kan du legge til en reguleringsperiode for å forhindre overmontering.

Trinn 5) Hyperparameter: Lasso & Ridge

Modellen din kan lide av over- eller underinnredning .

  • Overmontering: Modellen klarer ikke å generalisere spådommen til nye data
  • Underfitting: Modellen klarer ikke å fange opp mønsteret til dataene. dvs. lineær regresjon når dataene er ikke-lineære

Når en modell har mange parametere og en relativt lav datamengde, fører det til dårlige spådommer. Tenk deg, en gruppe har bare tre observasjoner; modellen vil beregne en vekt for denne gruppen. Vekten brukes til å forutsi; Hvis observasjonene av testsettet for denne bestemte gruppen er helt forskjellige fra treningssettet, vil modellen forutsi feil. Under evalueringen med treningssettet er nøyaktigheten god, men ikke god med testsettet fordi vektene som er beregnet ikke er den sanne for å generalisere mønsteret. I dette tilfellet gir det ikke en rimelig spådom på usete data.

For å forhindre overmontering gir regulering deg mulighetene til å kontrollere for slik kompleksitet og gjøre den mer generaliserbar. Det er to reguleringsteknikker:

  • L1: Lasso
  • L2: Ridge

I TensorFlow kan du legge til disse to hyperparametrene i optimalisereren. For eksempel, jo høyere hyperparameter L2, har vekten en tendens til å være veldig lav og nær null. Den monterte linjen vil være veldig flat, mens en L2 nær null innebærer at vektene er nær den vanlige lineære regresjonen.

Du kan selv prøve de forskjellige verdiene til hyperparametrene og se om du kan øke nøyaktighetsnivået.

Merk at hvis du endrer hyperparameter, må du slette mappen pågående / train4 ellers starter modellen med den tidligere trente modellen.

La oss se hvordan er nøyaktigheten med sprøytenarkomanen

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)

PRODUKSJON

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 hyperparameteret øker du nøyaktighetsberegningene. I neste opplæring vil du lære hvordan du kan forbedre en lineær klassifisering ved hjelp av en kjernemetode.

Sammendrag

For å trene en modell, må du:

  • Definer funksjonene: Uavhengige variabler: X
  • Definer etiketten: Avhengig variabel: y
  • Konstruer et tog / testsett
  • Definer startvekten
  • Definer tapsfunksjonen: MSE
  • Optimaliser modellen: Gradient nedstigning
  • Definere:
    • Læringsgrad
    • Antall epoker
    • Partistørrelse, Gruppestørrelse
    • Antall klasser

I denne opplæringen lærte du hvordan du bruker APIet på høyt nivå for en lineær regresjonsklassifisering. Du må definere:

  1. Funksjonskolonner. Hvis kontinuerlig: tf.feature_column.numeric_column (). Du kan fylle ut en liste med pythonlisteforståelse
  2. Estimatoren: tf.estimator.LinearClassifier (feature_column, model_dir, n_classes = 2)
  3. En funksjon for å importere data, batchstørrelse og epoke: input_fn ()

Etter det er du klar til å trene, evaluere og forutsi med tog (), evaluere () og forutsi ()

For å forbedre ytelsen til modellen kan du:

  • Bruk polynomisk regresjon
  • Interaksjonsuttrykk: tf.feature_column.crossed_column
  • Legg til normaliseringsparameter