TensorFlow binaire classificatie: voorbeeld van lineaire classificatie

De twee meest voorkomende leren onder toezicht taken zijn lineaire regressie en lineaire classificator. Lineaire regressie voorspelt een waarde, terwijl de lineaire classificator een klasse voorspelt. Deze tutorial is gericht op lineaire classificaties.

Wat is lineaire classificatie?

A Lineaire classificator in Machine Learning is een methode voor het vinden van de klasse van een object op basis van zijn kenmerken voor statistische classificatie. Het neemt een classificatiebeslissing op basis van de waarde van een lineaire combinatie van kenmerken van een object. Lineaire classificatie wordt gebruikt bij praktische problemen zoals documentclassificatie en problemen met veel variabelen.

Classificatieproblemen vertegenwoordigen grofweg 80 procent van de machine learning-taak. Classificatie heeft tot doel de waarschijnlijkheid van elke klasse te voorspellen, gegeven een reeks inputs. Het label (dwz de afhankelijke variabele) is een discrete waarde, een klasse genoemd.

  1. Als het label slechts twee klassen heeft, is het leeralgoritme een binaire classificatie.
  2. Multiclass-classificatie pakt labels aan met meer dan twee klassen.

Een typisch binair classificatieprobleem is bijvoorbeeld om de waarschijnlijkheid te voorspellen dat een klant een tweede aankoop doet. Het voorspellen van het type dier dat op een foto wordt weergegeven, is een multiclass classificatieprobleem, aangezien er meer dan twee soorten dieren bestaan.

Het theoretische deel van deze tutorial legt de nadruk op de binaire klasse. In een toekomstige zelfstudie leert u meer over de uitvoerfunctie met meerdere klassen.

Hoe werkt de binaire classificatie?

In de vorige tutorial heb je geleerd dat een functie uit twee soorten variabelen bestaat: een afhankelijke variabele en een reeks features (onafhankelijke variabelen). Bij lineaire regressie is een afhankelijke variabele een reëel getal zonder bereik. Het primaire doel is om de waarde ervan te voorspellen door de gemiddelde kwadratische fout te minimaliseren.

Voor TensorFlow Binary Classifier kan het label twee mogelijke gehele waarden hebben gehad. In de meeste gevallen is dit [0,1] of [1,2]. Het doel is bijvoorbeeld om te voorspellen of een klant een product zal kopen of niet. Het label is als volgt gedefinieerd:

  • Y = 1 (klant heeft het product gekocht)
  • Y = 0 (klant koopt het product niet)

Het model gebruikt de kenmerken X om elke klant in te delen in de meest waarschijnlijke klasse waartoe hij behoort, namelijk potentiële koper of niet.

Er wordt rekening gehouden met de kans op succes logistische regressie. Het algoritme berekent een waarschijnlijkheid op basis van het kenmerk X en voorspelt een succes wanneer deze waarschijnlijkheid boven de 50 procent ligt. Formeel wordt de waarschijnlijkheid berekend zoals weergegeven in het onderstaande voorbeeld van de TensorFlow Binaire Classificatie:

Voorbeeld van binaire classificatie

waarbij 0 de reeks gewichten, de kenmerken en b de bias is.

De functie kan in twee delen worden opgesplitst:

  • Het lineaire model
  • De logistieke functie

Lineair model

Je bent al bekend met de manier waarop de gewichten worden berekend. Gewichten worden berekend met behulp van een puntproduct:Punt product Y is een lineaire functie van alle kenmerken xi. Als het model geen kenmerken heeft, is de voorspelling gelijk aan de bias, b.

De gewichten geven de richting aan van de correlatie tussen de kenmerken xi en het label y. Een positieve correlatie verhoogt de waarschijnlijkheid van de positieve klasse, terwijl een negatieve correlatie de waarschijnlijkheid dichter bij 0 brengt (dwz negatieve klasse).

Het lineaire model retourneert alleen een reëel getal, wat inconsistent is met de waarschijnlijkheidsmaatstaf van bereik [0,1]. De logistieke functie is vereist om de output van het lineaire model om te zetten in een waarschijnlijkheid,

Logistieke functie

De logistieke functie, of sigmoïdefunctie, heeft een S-vorm en de uitvoer van deze functie ligt altijd tussen 0 en 1.

Logistiek Functievoorbeeld

Logistiek Functievoorbeeld
Logistiek Functievoorbeeld

Het is gemakkelijk om de uitvoer van de lineaire regressie te vervangen door de sigmoïdefunctie. Het resulteert in een nieuw getal met een waarschijnlijkheid tussen 0 en 1.

De classificator kan de waarschijnlijkheid omzetten in een klasse

  • Waarden tussen 0 en 0.49 worden klasse 0
  • Waarden tussen 0.5 en 1 worden klasse 1

Hoe de prestaties van Linear Classifier meten?

Nauwkeurigheid

De algehele prestaties van een classificator worden gemeten met de nauwkeurigheidsmetriek. Nauwkeurigheid verzamelt alle juiste waarden gedeeld door het totale aantal waarnemingen. Een nauwkeurigheidswaarde van 80 procent betekent bijvoorbeeld dat het model in 80 procent van de gevallen correct is.

Nauwkeurigheid Metriek
Meet de prestaties van Linear Classifier met behulp van de nauwkeurigheidsmetriek

U kunt een tekortkoming opmerken met deze metriek, met name voor de onevenwichtigheidsklasse. Een onevenwichtigheidsdataset treedt op wanneer het aantal observaties per groep niet gelijk is. Stel dat u een zeldzame gebeurtenis probeert te classificeren met een logistieke functie. Stel dat de classificator de dood van een patiënt na een ziekte probeert te schatten. In de gegevens overlijdt 5 procent van de patiënten. U kunt een classificator trainen om het aantal doden te voorspellen en de nauwkeurigheidsmetriek gebruiken om de prestaties te evalueren. Als de classificator 0 doden voor de hele dataset voorspelt, zal dit in 95 procent van de gevallen correct zijn.

Verwarring matrix

Een betere manier om de prestaties van een classifier te beoordelen, is door naar de verwarringsmatrix te kijken.

Verwarring Matrix
Meet de prestaties van Linear Classifier met behulp van de Confusion-matrix

De verwarring matrix visualiseert de nauwkeurigheid van een classifier door de werkelijke en voorspelde klassen te vergelijken, zoals weergegeven in het bovenstaande Linear Classifier-voorbeeld. De binaire verwarringsmatrix bestaat uit vierkanten:

  • TP: True Positive: voorspelde waarden correct voorspeld als feitelijk positief
  • FP: Voorspelde waarden voorspelden ten onrechte een feitelijk positief resultaat. dat wil zeggen, negatieve waarden voorspeld als positief
  • FN: Vals negatief: Positieve waarden voorspeld als negatief
  • TN: True Negative: Voorspelde waarden correct voorspeld als feitelijk negatief

Vanuit de verwarringsmatrix is ​​het gemakkelijk om de werkelijke klasse en de voorspelde klasse te vergelijken.

Precisie en gevoeligheid

De verwarringsmatrix geeft een goed inzicht in de ware positieve en valse positieven. In sommige gevallen verdient het de voorkeur om een ​​beknoptere metriek te hebben.

precisie

De precisiemetriek toont de nauwkeurigheid van de positieve klasse. Het meet hoe waarschijnlijk het is dat de voorspelling van de positieve klasse correct is.

precisie

De maximale score is 1 wanneer de classificator alle positieve waarden perfect classificeert. Precisie alleen is niet erg nuttig omdat het de negatieve klasse negeert. De statistiek wordt meestal gecombineerd met de Recall-statistiek. Recall wordt ook wel gevoeligheid of echt positief percentage genoemd.

Gevoeligheid

Gevoeligheid berekent de verhouding van de positieve klassen die correct zijn gedetecteerd. Deze maatstaf geeft aan hoe goed het model is om een ​​positieve klasse te herkennen.

Gevoeligheid

Lineaire classificatie met TensorFlow

Voor deze zelfstudie gebruiken we de censusgegevensset. Het doel is om de variabelen in de censusdataset te gebruiken om het inkomensniveau te voorspellen. Merk op dat het inkomen een binaire variabele is

  • met een waarde van 1 als het inkomen > 50k
  • 0 als inkomen < 50k.

Deze variabele is uw label

Deze dataset bevat acht categorische variabelen:

  • werkplaats
  • onderwijs
  • huwelijks-
  • bezetting
  • verwantschap
  • race
  • geslacht
  • geboorteland

bovendien zes continue variabelen:

  • leeftijd
  • fnlwgt
  • onderwijs_num
  • kapitaal_winst
  • kapitaal_verlies
  • uren_week

Via dit voorbeeld van TensorFlow-classificatie begrijpt u hoe u lineaire TensorFlow-classifiers kunt trainen met de TensorFlow-schatter en hoe u de nauwkeurigheidsmetriek kunt verbeteren.

Wij gaan als volgt te werk:

  • Stap 1) Importeer de gegevens
  • Stap 2) Gegevensconversie
  • Stap 3) Train de classificator
  • Stap 4) Verbeter het model
  • Stap 5) Hyperparameter: Lasso & Ridge

Stap 1) Importeer de gegevens

Je importeert eerst de bibliotheken die je tijdens de tutorial gebruikt.

import tensorflow as tf
import pandas as pd

Vervolgens importeert u de gegevens uit het archief van UCI en definieert u de namen van de kolommen. U gebruikt de COLUMNS om de kolommen in een pandas-dataframe te benoemen.

Houd er rekening mee dat u de classificator gaat trainen met behulp van een Pandas-dataframe.

## 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 online opgeslagen gegevens zijn al verdeeld tussen een treinstel en een testset.

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)

Het treinstel bevat 32,561 waarnemingen en het proefstel 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 vereist een Booleaanse waarde om de classifier te trainen. U moet de waarden van string naar integer casten. Het label wordt opgeslagen als een object, maar u moet het converteren naar een numerieke waarde. De onderstaande code maakt een woordenboek met de waarden die moeten worden geconverteerd en loop over het kolomitem. Let op dat u deze bewerking twee keer uitvoert, één voor de train test, één voor de testset

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]

In de treingegevens zijn er 24,720 inkomens lager dan 50 en 7841 daarboven. De verhouding is vrijwel hetzelfde voor de testset. Raadpleeg deze tutorial over Facetten voor meer informatie.

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

Stap 2) Gegevensconversie

Er zijn een paar stappen vereist voordat u een lineaire classificator traint met Tensorflow. U moet de functies voorbereiden die u in het model wilt opnemen. Bij de benchmarkregressie gebruikt u de originele gegevens zonder enige transformatie toe te passen.

De schatter heeft een lijst met functies nodig om het model te trainen. Daarom moeten de gegevens van de kolom worden omgezet in een tensor.

Een goede gewoonte is om twee lijsten met features te definiëren op basis van hun type en deze vervolgens door te geven aan de feature_columns van de schatter.

U begint met het converteren van continue functies en definieert vervolgens een bucket met de categorische gegevens.

De kenmerken van de dataset hebben twee formaten:

  • Geheel getal
  • Object

Elke functie wordt vermeld in de volgende twee variabelen, afhankelijk van hun type.

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

De feature_column is uitgerust met een object numerieke_kolom om te helpen bij de transformatie van de continue variabelen naar tensor. In de onderstaande code converteer je alle variabelen van CONTI_FEATURES naar een tensor met een numerieke waarde. Dit is verplicht om het model te construeren. Alle onafhankelijke variabelen moeten worden omgezet in het juiste type tensor.

Hieronder schrijven we een code waarmee u kunt zien wat er achter feature_column.numeric_column gebeurt. We zullen de omgerekende waarde voor leeftijd afdrukken. Dit is ter verduidelijking, daarom is het niet nodig om de Python-code te begrijpen. U kunt de officiële documentatie raadplegen om de codes te begrijpen.

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

De waarden zijn exact hetzelfde als in df_train

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

Volgens de TensorFlow-documentatie zijn er verschillende manieren om categorische gegevens te converteren. Als de woordenlijst van een kenmerk bekend is en niet voldoende waarden bevat, is het mogelijk om de categorische kolom te maken met categorische_kolom_met_vocabulary_lijst. Het wijst aan alle unieke woordenlijsten een ID toe.

Als een variabelestatus bijvoorbeeld drie verschillende waarden heeft:

  • Man
  • Vrouw
  • Enkele

Vervolgens worden er drie ID's toegekend. De man heeft bijvoorbeeld ID 1, de vrouw ID 2, enzovoort.

Ter illustratie kunt u deze code gebruiken om een ​​objectvariabele naar een categorische kolom in TensorFlow te converteren.

Het kenmerk geslacht kan slechts twee waarden hebben: mannelijk of vrouwelijk. Wanneer we het kenmerk geslacht converteren, zal Tensorflow 2 nieuwe kolommen aanmaken, één voor mannelijk en één voor vrouwelijk. Als het geslacht gelijk is aan mannelijk, dan zal de nieuwe kolom mannelijk gelijk zijn aan 1 en vrouwelijk aan 0. Dit voorbeeld wordt weergegeven in de onderstaande tabel:

rijen geslacht na transformatie mannetje vrouw
1 mannetje => 1 0
2 mannetje => 1 0
3 vrouw => 0 1

In tensorstroom:

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

Hieronder hebben we toegevoegd Python code om de codering af te drukken. Nogmaals, je hoeft de code niet te begrijpen, het doel is om de transformatie te zien

Een snellere manier om de gegevens te transformeren is echter door de methode categorical_column_with_hash_bucket te gebruiken. Het kan handig zijn om stringvariabelen in een schaarse matrix te wijzigen. Een sparse matrix is ​​een matrix met grotendeels nul. De methode regelt alles. U hoeft alleen het aantal buckets en de sleutelkolom op te geven. Het aantal buckets is het maximale aantal groepen dat Tensorflow kan maken. De sleutelkolom is eenvoudigweg de naam van de kolom die moet worden geconverteerd.

In de onderstaande code maak je een lus over alle categorische features.

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

Stap 3) Train de classificator

TensorFlow biedt momenteel een schatter voor de lineaire regressie en lineaire classificatie.

  • Lineaire regressie: LinearRegressor
  • Lineaire classificatie: LinearClassifier

De syntaxis van de lineaire classificator is dezelfde als in de tutorial lineaire regressie behalve één argument, n_class. U moet de featurekolom en de modeldirectory definiëren en vergelijken met de lineaire regressor; je moet het aantal klassen definiëren. Voor een logit-regressie is het aantal klassen gelijk aan 2.

Het model berekent de gewichten van de kolommen in Continuous_features en Categorical_features.

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

uitgang

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 de classificator is gedefinieerd, kunt u de invoerfunctie maken. De methode is dezelfde als in de lineaire regressor-tutorial. Hier gebruik je een batchgrootte van 128 en schud je de gegevens.

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)

U maakt een functie met de argumenten die nodig zijn voor de lineaire schatter, dat wil zeggen het aantal tijdperken, het aantal batches, en u schudt de gegevensset of notitie door elkaar. Omdat je gebruik maakt van de Pandas methode om de gegevens in het model door te geven, moet u de X-variabelen definiëren als een pandas-dataframe. Houd er rekening mee dat u alle gegevens die zijn opgeslagen in FEATURES doorloopt.

Laten we het model trainen met het object model.train. U gebruikt de eerder gedefinieerde functie om het model van de juiste waarden te voorzien. Houd er rekening mee dat u de batchgrootte instelt op 128 en het aantal tijdperken op Geen. Het model zal in duizend stappen worden getraind.

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>

Merk op dat het verlies vervolgens tijdens de laatste 100 stappen afnam, dat wil zeggen van 901 naar 1000.

Het uiteindelijke verlies na duizend iteraties is 5444. U kunt uw model op de testset schatten en de prestaties bekijken. Om de prestaties van uw model te evalueren, moet u het object evalueren gebruiken. U voedt het model met de testset en stelt het aantal tijdperken in op 1, dat wil zeggen dat de gegevens slechts één keer naar het model gaan.

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 retourneert alle statistieken die je in het theoretische gedeelte hebt geleerd. Het zal geen verrassing zijn dat de nauwkeurigheid groot is vanwege het onevenwichtige label. Eigenlijk presteert het model iets beter dan een willekeurige gok. Stel je voor dat het model alle huishoudens met een inkomen lager dan 50 voorspelt, dan heeft het model een nauwkeurigheid van 70 procent. Bij nadere analyse zie je dat de voorspelling en herinnering vrij laag zijn.

Stap 4) Verbeter het model

Nu u een benchmarkmodel heeft, kunt u proberen dit te verbeteren, dat wil zeggen de nauwkeurigheid te vergroten. In de vorige tutorial heb je geleerd hoe je de voorspellingskracht kunt verbeteren met een interactieterm. In deze tutorial zul je dit idee opnieuw bekijken door een polynomiale term aan de regressie toe te voegen.

Polynomiale regressie is instrumenteel als er niet-lineariteit in de gegevens zit. Er zijn twee manieren om niet-lineariteit in de gegevens vast te leggen.

  • Polynomiale term toevoegen
  • Verdeel de continue variabele in een categorische variabele

Polynomiale term

In de onderstaande afbeelding kunt u zien wat een polynomiale regressie is. Het is een vergelijking met X-variabelen met verschillende machten. Een tweedegraads polynoomregressie heeft twee variabelen, X en X in het kwadraat. Derdegraads heeft drie variabelen, X, X2,en X3

Polynomiale regressie
Wat is polynomiale regressie

Hieronder hebben we een grafiek gemaakt met twee variabelen, X en Y. Het is duidelijk dat de relatie niet lineair is. Als we een lineaire regressie toevoegen, kunnen we zien dat het model het patroon niet kan vastleggen (linkerafbeelding).

Kijk nu naar de linkerafbeelding van de afbeelding hieronder, we hebben vijf termen aan de regressie toegevoegd (dat wil zeggen y=x+x2+x3+x4+x5. Het model legt het patroon nu veel beter vast. Dit is de kracht van polynomiale regressie.

Polynomiale regressie

Laten we teruggaan naar ons voorbeeld. Leeftijd staat niet in een lineaire relatie met inkomen. Op jonge leeftijd kan er sprake zijn van een vast inkomen dat bijna nul is, omdat kinderen of jongeren niet werken. Daarna stijgt het op de werkende leeftijd en daalt het tijdens de pensionering. Het is typisch een omgekeerde U-vorm. Eén manier om dit patroon vast te leggen is door een macht twee aan de regressie toe te voegen.

Laten we eens kijken of dit de nauwkeurigheid vergroot.

U moet deze nieuwe functie toevoegen aan de gegevensset en in de lijst met doorlopende functies.

U voegt de nieuwe variabele toe aan de trein- en testgegevensset, zodat het handiger is om een ​​functie te schrijven.

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

De functie heeft 3 argumenten:

  • df_t: definieer de trainingsset
  • df_te: definieer de testset
  • var_name = 'leeftijd': Definieer de variabele die moet worden getransformeerd

U kunt het object pow(2) gebruiken om de variabele leeftijd te kwadrateren. Merk op dat de nieuwe variabele 'nieuw' heet

Nu de functie square_var is geschreven, kunt u de nieuwe datasets maken.

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

Zoals u kunt zien, heeft de nieuwe dataset nog een functie.

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

De vierkante variabele wordt in de gegevensset nieuw genoemd. U moet het toevoegen aan de lijst met doorlopende functies.

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]

Note dat u de map van de grafiek hebt gewijzigd. U kunt geen verschillende modellen in dezelfde map trainen. Het betekent dat u het pad van het argument model_dir moet wijzigen. Als u dit niet doet, zal TensorFlow een foutmelding geven.

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 de classificator is ontworpen met de nieuwe gegevensset, kunt u het model trainen en evalueren.

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}

De kwadratische variabele verbeterde de nauwkeurigheid van 0.76 naar 0.79. Laten we eens kijken of u het beter kunt doen door bucketisatie en interactietermen samen te combineren.

Bucketisering en interactie

Zoals u eerder hebt gezien, is een lineaire classificator niet in staat het leeftijdsinkomenspatroon correct weer te geven. Dat komt omdat het voor elk kenmerk één enkel gewicht leert. Om het voor de classificator gemakkelijker te maken, kunt u de functie onder één noemer plaatsen. Bucketing transformeert een numeriek kenmerk in verschillende bepaalde kenmerken op basis van het bereik waarbinnen het valt, en elk van deze nieuwe kenmerken geeft aan of de leeftijd van een persoon binnen dat bereik valt.

Met deze nieuwe functies kan het lineaire model de relatie vastleggen door voor elke bucket verschillende gewichten te leren.

In TensorFlow wordt dit gedaan met bucketized_column. U moet het waardenbereik binnen de grenzen toevoegen.

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

Je weet al dat leeftijd niet lineair is met inkomen. Een andere manier om het model te verbeteren is door middel van interactie. In de woorden van TensorFlow is het feature-crossing. Feature Crossing is een manier om nieuwe features te creëren die combinaties zijn van bestaande features, wat handig kan zijn voor een lineaire classificator die geen interacties tussen features kan modelleren.

Je kunt de leeftijd uitsplitsen met een ander kenmerk, zoals opleiding. Dat wil zeggen dat sommige groepen waarschijnlijk een hoog inkomen hebben en andere een laag inkomen (denk aan de promovendus).

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

Om een ​​kolom met meerdere objecten te maken, gebruikt u gekruiste_kolom met de variabelen die u wilt kruisen tussen haakjes. De hash_bucket_size geeft de maximale kruisingsmogelijkheden aan. Om interactie tussen variabelen te creëren (minstens één variabele moet categorisch zijn), kunt u tf.feature_column.crossed_column gebruiken. Om dit object te gebruiken, moet u tussen vierkante haakjes de variabele toevoegen die moet interageren, en een tweede argument, de bucketgrootte. De bucketgrootte is het maximaal mogelijke aantal groepen binnen een variabele. Hier zet je hem op 1000 omdat je het exacte aantal groepen niet weet

age_buckets moet worden gekwadrateerd voordat het aan de featurekolommen kan worden toegevoegd. Ook voeg je de nieuwe features toe aan de featureskolommen en bereid je de schatter voor

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)

uitgang

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)

U bent klaar om het nieuwe model te schatten en te kijken of dit de nauwkeurigheid verbetert.

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}

Het nieuwe nauwkeurigheidsniveau is 83.58 procent. Het is vier procent hoger dan het vorige model.

Ten slotte kunt u een regularisatietermijn toevoegen om overfitting te voorkomen.

Stap 5) Hyperparameter: Lasso & Ridge

Uw model kan er last van hebben overfitting or ondermaats.

  • Overfitting: het model is niet in staat de voorspelling te generaliseren naar nieuwe gegevens
  • Underfitting: Het model kan het patroon van de gegevens niet vastleggen. dwz lineaire regressie wanneer de gegevens niet-lineair zijn

Wanneer een model veel parameters en een relatief lage hoeveelheid gegevens heeft, leidt dit tot slechte voorspellingen. Stel je voor dat één groep slechts drie observaties heeft; het model berekent een gewicht voor deze groep. Het gewicht wordt gebruikt om een ​​voorspelling te doen; als de waarnemingen van de testset voor deze specifieke groep geheel anders zijn dan die van de trainingsset, zal het model een verkeerde voorspelling doen. Tijdens de evaluatie met de trainingsset is de nauwkeurigheid goed, maar niet goed met de testset, omdat de berekende gewichten niet de juiste zijn om het patroon te generaliseren. In dit geval doet het geen redelijke voorspelling op basis van ongeziene gegevens.

Om overfitting te voorkomen, geeft regularisatie u de mogelijkheid om dergelijke complexiteit te controleren en het algemener te maken. Er zijn twee regularisatietechnieken:

  • L1: Lasso
  • L2: Rand

In TensorFlow kunt u deze twee hyperparameters toevoegen in de optimizer. Hoe hoger de hyperparameter L2, hoe hoger het gewicht bijvoorbeeld zeer laag is en dicht bij nul ligt. De gepaste lijn zal erg vlak zijn, terwijl een L2 dichtbij nul impliceert dat de gewichten dicht bij de reguliere lineaire regressie liggen.

U kunt zelf de verschillende waarden van de hyperparameters uitproberen en kijken of u het nauwkeurigheidsniveau kunt verhogen.

Note dat als u de hyperparameter wijzigt, u de map ongoing/train4 moet verwijderen, anders start het model met het eerder getrainde model.

Laten we eens kijken hoe de nauwkeurigheid is met de hype

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

UITGANG

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)

UITGANG

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)

uitgang

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}

Met deze hyperparameter verhoogt u de nauwkeurigheidsstatistieken enigszins. In de volgende zelfstudie leert u hoe u een lineaire classificator kunt verbeteren met behulp van een kernelmethode.

Samenvatting

Om een ​​model te trainen, moet je:

  • Definieer de kenmerken: Onafhankelijke variabelen: X
  • Definieer het label: Afhankelijke variabele: y
  • Bouw een trein/testset
  • Definieer het initiële gewicht
  • Definieer de verliesfunctie: MSE
  • Optimaliseer het model: Gradiëntafdaling
  • Bepalen:
    • Leren tarief
    • Aantal tijdperk
    • Seriegrootte
    • Aantal klasse

In deze zelfstudie hebt u geleerd hoe u de API op hoog niveau kunt gebruiken voor een lineaire regressieclassificator. U moet definiëren:

  1. Functiekolommen. Indien continu: tf.feature_column.numeric_column(). U kunt een lijst vullen met Python-lijstbegrip
  2. De schatter: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
  3. Een functie om de gegevens, de batchgrootte en het tijdperk te importeren: input_fn()

Daarna ben je klaar om te trainen, evalueren en een voorspelling te doen met train(), evalueren() en voorspellen()

Om de prestaties van het model te verbeteren, kunt u:

  • Gebruik polynomiale regressie
  • Interactieterm: tf.feature_column.crossed_column
  • Regularisatieparameter toevoegen