Binäre TensorFlow-Klassifizierung: Beispiel für einen linearen Klassifikator

Die zwei am häufigsten überwachtes Lernen Aufgaben sind lineare Regression und linearer Klassifikator. Die lineare Regression sagt einen Wert voraus, während der lineare Klassifikator eine Klasse vorhersagt. Dieses Tutorial konzentriert sich auf lineare Klassifikatoren.

Was ist ein linearer Klassifikator?

A Linearer Klassifikator Beim maschinellen Lernen handelt es sich um eine Methode zum Finden der Klasse eines Objekts anhand seiner Merkmale für die statistische Klassifizierung. Es trifft eine Klassifizierungsentscheidung basierend auf dem Wert einer linearen Kombination von Merkmalen eines Objekts. Der lineare Klassifikator wird bei praktischen Problemen wie der Dokumentenklassifizierung und Problemen mit vielen Variablen verwendet.

Klassifizierungsprobleme machen etwa 80 Prozent der maschinellen Lernaufgabe aus. Die Klassifizierung zielt darauf ab, die Wahrscheinlichkeit jeder Klasse anhand einer Reihe von Eingaben vorherzusagen. Die Bezeichnung (dh die abhängige Variable) ist ein diskreter Wert, der als Klasse bezeichnet wird.

1. Wenn das Etikett nur zwei Klassen hat, ist der Lernalgorithmus ein binärer Klassifikator.
2. Der Multiklassen-Klassifizierer bewältigt Etiketten mit mehr als zwei Klassen.

Ein typisches Problem der binären Klassifizierung ist beispielsweise die Vorhersage der Wahrscheinlichkeit, mit der ein Kunde einen zweiten Einkauf tätigt. Die Vorhersage der auf einem Bild abgebildeten Tierart ist ein Problem der Mehrklassenklassifizierung, da mehr als zwei Tierarten existieren.

Der theoretische Teil dieses Tutorials konzentriert sich hauptsächlich auf die Binärklasse. In einem zukünftigen Tutorial erfahren Sie mehr über die Multiklassen-Ausgabefunktion.

Wie funktioniert der binäre Klassifikator?

Im vorherigen Tutorial haben Sie gelernt, dass eine Funktion aus zwei Arten von Variablen besteht, einer abhängigen Variablen und einer Reihe von Features (unabhängigen Variablen). Bei der linearen Regression ist eine abhängige Variable eine reelle Zahl ohne Bereich. Das Hauptziel besteht darin, seinen Wert vorherzusagen, indem der mittlere quadratische Fehler minimiert wird.

Beim TensorFlow Binary Classifier kann die Bezeichnung zwei mögliche ganzzahlige Werte haben. In den meisten Fällen ist es entweder [0,1] oder [1,2]. Das Ziel besteht beispielsweise darin, vorherzusagen, ob ein Kunde ein Produkt kaufen wird oder nicht. Das Etikett ist wie folgt definiert:

• Y = 1 (Kunde hat das Produkt gekauft)
• Y = 0 (Kunde kauft das Produkt nicht)

Das Modell verwendet die Merkmale X, um jeden Kunden in die wahrscheinlichste Klasse einzustufen, zu der er gehört, nämlich potenzieller Käufer oder nicht.

Die Erfolgswahrscheinlichkeit wird mit berechnet logistische Regression. Der Algorithmus berechnet eine Wahrscheinlichkeit basierend auf dem Merkmal X und sagt einen Erfolg voraus, wenn diese Wahrscheinlichkeit über 50 Prozent liegt. Formeller ausgedrückt wird die Wahrscheinlichkeit wie im folgenden Beispiel für die TensorFlow-Binärklassifizierung gezeigt berechnet:

Dabei ist 0 die Menge der Gewichte, der Merkmale und b der Bias.

Die Funktion kann in zwei Teile zerlegt werden:

• Das lineare Modell
• Die Logistikfunktion

Lineares Modell

Sie sind bereits mit der Art und Weise vertraut, wie die Gewichte berechnet werden. Gewichte werden mithilfe eines Skalarprodukts berechnet: Y ist eine lineare Funktion aller Merkmale x_i. Wenn das Modell keine Merkmale aufweist, entspricht die Vorhersage dem Bias, b.

Die Gewichte geben die Richtung der Korrelation zwischen den Merkmalen x an_i und die Bezeichnung y. Eine positive Korrelation erhöht die Wahrscheinlichkeit der positiven Klasse, während eine negative Korrelation die Wahrscheinlichkeit näher an 0 (dh negative Klasse) führt.

Das lineare Modell gibt nur reelle Zahlen zurück, was nicht mit dem Wahrscheinlichkeitsmaß der Reichweite [0,1] übereinstimmt. Die Logistikfunktion ist erforderlich, um die Ausgabe des linearen Modells in eine Wahrscheinlichkeit umzuwandeln.

Logistische Funktion

Die Logistikfunktion oder Sigmoidfunktion hat eine S-Form und die Ausgabe dieser Funktion liegt immer zwischen 0 und 1.

Es ist einfach, die Ausgabe der linearen Regression in die Sigmoidfunktion zu ersetzen. Es ergibt sich eine neue Zahl mit einer Wahrscheinlichkeit zwischen 0 und 1.

Der Klassifikator kann die Wahrscheinlichkeit in eine Klasse umwandeln

• Werte zwischen 0 und 0.49 werden zur Klasse 0
• Werte zwischen 0.5 und 1 werden zur Klasse 1

Wie misst man die Leistung des linearen Klassifikators?

Genauigkeit

Die Gesamtleistung eines Klassifikators wird mit der Genauigkeitsmetrik gemessen. Die Genauigkeit erfasst alle korrekten Werte dividiert durch die Gesamtzahl der Beobachtungen. Ein Genauigkeitswert von 80 Prozent bedeutet beispielsweise, dass das Modell in 80 Prozent der Fälle korrekt ist.

Sie können einen Mangel bei dieser Metrik feststellen, insbesondere bei der Ungleichgewichtsklasse. Ein unausgewogener Datensatz liegt vor, wenn die Anzahl der Beobachtungen pro Gruppe nicht gleich ist. Nehmen wir an, Sie versuchen, ein seltenes Ereignis mit einer logistischen Funktion zu klassifizieren. Stellen Sie sich vor, der Klassifikator versucht, den Tod eines Patienten nach einer Krankheit abzuschätzen. In den Daten sterben 5 Prozent der Patienten. Sie können einen Klassifikator trainieren, die Anzahl der Todesfälle vorherzusagen, und die Genauigkeitsmetrik verwenden, um die Leistung zu bewerten. Wenn der Klassifikator für den gesamten Datensatz 0 Todesfälle vorhersagt, liegt er in 95 Prozent der Fälle richtig.

Verwirrung Matrix

Eine bessere Möglichkeit, die Leistung eines Klassifikators zu beurteilen, ist die Betrachtung der Verwirrungsmatrix.

Die Verwirrung Matrix visualisiert die Genauigkeit eines Klassifikators durch Vergleich der tatsächlichen und vorhergesagten Klassen, wie im obigen Beispiel des linearen Klassifikators gezeigt. Die binäre Konfusionsmatrix besteht aus Quadraten:

• TP: Richtig positiv: Vorhergesagte Werte werden korrekt als tatsächlich positiv vorhergesagt
• FP: Die vorhergesagten Werte haben fälschlicherweise ein tatsächlich positives Ergebnis vorhergesagt. Das heißt, negative Werte werden als positiv vorhergesagt
• FN: Falsch negativ: Positive Werte werden als negativ vorhergesagt
• TN: Richtig negativ: Vorhergesagte Werte werden korrekt als tatsächlich negativ vorhergesagt

Anhand der Verwirrungsmatrix ist es einfach, die tatsächliche Klasse und die vorhergesagte Klasse zu vergleichen.

Präzision und Sensibilität

Die Verwirrungsmatrix bietet einen guten Einblick in das wahre Positive und das falsche Positive. In manchen Fällen ist eine prägnantere Metrik vorzuziehen.

Präzision

Die Präzisionsmetrik zeigt die Genauigkeit der positiven Klasse. Es misst, wie wahrscheinlich die Vorhersage der positiven Klasse richtig ist.

Die maximale Punktzahl beträgt 1, wenn der Klassifikator alle positiven Werte perfekt klassifiziert. Präzision allein ist nicht sehr hilfreich, da sie die negative Klasse ignoriert. Die Metrik wird normalerweise mit der Recall-Metrik gepaart. Der Rückruf wird auch Sensitivität oder echte positive Rate genannt.

Sensitivität

Die Empfindlichkeit berechnet das Verhältnis der korrekt erkannten positiven Klassen. Diese Metrik gibt an, wie gut das Modell eine positive Klasse erkennen kann.

Linearer Klassifikator mit TensorFlow

Für dieses Tutorial verwenden wir den Volkszählungsdatensatz. Der Zweck besteht darin, die Variablen im Volkszählungsdatensatz zu verwenden, um das Einkommensniveau vorherzusagen. Beachten Sie, dass das Einkommen eine binäre Variable ist

• mit einem Wert von 1, wenn das Einkommen > 50 ist
• 0, wenn das Einkommen < 50 ist.

Diese Variable ist Ihr Label

Dieser Datensatz enthält acht kategoriale Variablen:

• Arbeitsplatz
• Ausbildung
• ehelich
• Beruf
• Beziehung
• Rennen
• Sex
• Heimatland

außerdem sechs kontinuierliche Variablen:

• Alter
• fnlwgt
• education_num
• Wertzuwachs
• Kapitalverlust
• Stunden_Woche

Anhand dieses TensorFlow-Klassifizierungsbeispiels erfahren Sie, wie Sie lineare TensorFlow-Klassifikatoren mit dem TensorFlow-Schätzer trainieren und die Genauigkeitsmetrik verbessern.

Wir werden wie folgt vorgehen:

• Schritt 1) ​​Importieren Sie die Daten
• Schritt 2) Datenkonvertierung
• Schritt 3) Trainieren Sie den Klassifikator
• Schritt 4) Verbessern Sie das Modell
• Schritt 5) Hyperparameter:Lasso & Ridge

Schritt 1) ​​Importieren Sie die Daten

Sie importieren zunächst die während des Tutorials verwendeten Bibliotheken.

import tensorflow as tf
import pandas as pd

Als nächstes importieren Sie die Daten aus dem Archiv von UCI und definieren die Spaltennamen. Sie verwenden die SPALTEN, um die Spalten in einem Pandas-Datenrahmen zu benennen.

Beachten Sie, dass Sie den Klassifikator mithilfe eines Pandas-Datenrahmens trainieren.

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

Die online gespeicherten Daten sind bereits auf einen Zugsatz und einen Testsatz aufgeteilt.

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)

Der Zugsatz enthält 32,561 Beobachtungen und der Testsatz 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 erfordert einen Booleschen Wert, um den Klassifikator zu trainieren. Sie müssen die Werte von Zeichenfolgen in Ganzzahlen umwandeln. Das Label wird als Objekt gespeichert, Sie müssen es jedoch in einen numerischen Wert umwandeln. Der folgende Code erstellt ein Wörterbuch mit den zu konvertierenden Werten und führt eine Schleife über das Spaltenelement aus. Beachten Sie, dass Sie diesen Vorgang zweimal ausführen, einmal für den Trainingstest und einmal für den Testsatz

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 den Zugdaten gibt es 24,720 Einkommen unter 50 und 7841 darüber. Das Verhältnis ist für den Testsatz nahezu gleich. Weitere Informationen finden Sie in diesem Tutorial zu Facetten.

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

Schritt 2) Datenkonvertierung

Bevor Sie einen linearen Klassifikator mit Tensorflow trainieren, sind einige Schritte erforderlich. Sie müssen die Features vorbereiten, die in das Modell aufgenommen werden sollen. Bei der Benchmark-Regression verwenden Sie die Originaldaten, ohne eine Transformation anzuwenden.

Der Schätzer benötigt eine Liste von Funktionen, um das Modell zu trainieren. Daher müssen die Daten der Spalte in einen Tensor umgewandelt werden.

Eine bewährte Vorgehensweise besteht darin, zwei Feature-Listen basierend auf ihrem Typ zu definieren und sie dann in den feature_columns des Schätzers zu übergeben.

Sie beginnen mit der Konvertierung kontinuierlicher Features und definieren dann einen Bucket mit den kategorialen Daten.

Die Funktionen des Datensatzes haben zwei Formate:

• ganze Zahl
• Betreff

Jedes Feature wird in den nächsten beiden Variablen nach seinem Typ aufgelistet.

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

Die feature_column ist mit einem Objekt numeric_column ausgestattet, um bei der Umwandlung der kontinuierlichen Variablen in Tensor zu helfen. Im folgenden Code konvertieren Sie alle Variablen von CONTI_FEATURES in einen Tensor mit einem numerischen Wert. Dies ist für die Erstellung des Modells zwingend erforderlich. Alle unabhängigen Variablen müssen in den richtigen Tensortyp umgewandelt werden.

Nachfolgend schreiben wir einen Code, damit Sie sehen können, was hinter feature_column.numeric_column passiert. Wir werden den konvertierten Wert für das Alter ausdrucken. Dies dient der Erläuterung, daher ist es nicht erforderlich, den Python-Code zu verstehen. Um die Codes zu verstehen, können Sie sich auf die offizielle Dokumentation beziehen.

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

Die Werte sind genau die gleichen wie in df_train

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

Laut TensorFlow-Dokumentation gibt es verschiedene Möglichkeiten, kategoriale Daten zu konvertieren. Wenn die Vokabularliste eines Features bekannt ist und nicht viele Werte enthält, ist es möglich, die kategoriale Spalte mit categorical_column_with_vocabulary_list zu erstellen. Es wird jeder eindeutigen Vokabelliste eine ID zugewiesen.

Wenn beispielsweise ein Variablenstatus drei unterschiedliche Werte hat:

• Mann
• Ehefrau
• Einwellig

Dann werden drei IDs vergeben. Beispielsweise hat der Ehemann die ID 1, die Ehefrau die ID 2 und so weiter.

Zur Veranschaulichung können Sie diesen Code verwenden, um eine Objektvariable in eine kategoriale Spalte in TensorFlow zu konvertieren.

Das Merkmal „Geschlecht“ kann nur zwei Werte haben: männlich oder weiblich. Wenn wir das Merkmal „Geschlecht“ konvertieren, erstellt Tensorflow zwei neue Spalten, eine für männlich und eine für weiblich. Wenn das Geschlecht männlich ist, ist die neue Spalte männlich gleich 2 und weiblich gleich 1. Dieses Beispiel wird in der folgenden Tabelle angezeigt:

Reihen	Sex	nach der Verwandlung	männlich	weiblich
1	männlich	=>	1	0
2	männlich	=>	1	0
3	weiblich	=>	0	1

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

Nachfolgend haben wir hinzugefügt Python Code, um die Kodierung auszudrucken. Auch hier müssen Sie den Code nicht verstehen, der Zweck besteht darin, die Transformation zu sehen

Eine schnellere Möglichkeit, die Daten zu transformieren, ist jedoch die Verwendung der Methode categorical_column_with_hash_bucket. Das Ändern von Zeichenfolgenvariablen in einer dünn besetzten Matrix ist hilfreich. Eine dünn besetzte Matrix ist eine Matrix mit überwiegend Null. Die Methode kümmert sich um alles. Sie müssen lediglich die Anzahl der Buckets und die Schlüsselspalte angeben. Die Anzahl der Buckets ist die maximale Anzahl an Gruppen, die Tensorflow erstellen kann. Die Schlüsselspalte ist einfach der Name der zu konvertierenden Spalte.

Im folgenden Code erstellen Sie eine Schleife über alle kategorialen Features.

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

Schritt 3) Trainieren Sie den Klassifikator

TensorFlow bietet derzeit einen Schätzer für die lineare Regression und lineare Klassifizierung.

• Lineare Regression: LinearRegressor
• Lineare Klassifizierung: LinearClassifier

Die Syntax des linearen Klassifikators ist dieselbe wie im Tutorial lineare Regression bis auf ein Argument, n_class. Sie müssen die Feature-Spalte und das Modellverzeichnis definieren und mit dem linearen Regressor vergleichen. Sie müssen die Anzahl der Klassen definieren. Bei einer Logit-Regression ist die Anzahl der Klassen gleich 2.

Das Modell berechnet die Gewichtungen der in „continuous_features“ und „categorical_features“ enthaltenen Spalten.

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

Ausgang

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}

Nachdem der Klassifikator nun definiert ist, können Sie die Eingabefunktion erstellen. Die Methode ist dieselbe wie im Tutorial zum linearen Regressor. Hier verwenden Sie eine Stapelgröße von 128 und mischen die Daten.

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)

Sie erstellen eine Funktion mit den vom linearen Schätzer benötigten Argumenten, z. B. Anzahl der Epochen, Anzahl der Stapel, und mischen den Datensatz oder die Notiz. Da Sie das verwenden Pandas Um die Daten an das Modell zu übergeben, müssen Sie die X-Variablen als Pandas-Datenrahmen definieren. Beachten Sie, dass Sie alle in FEATURES gespeicherten Daten durchlaufen.

Lassen Sie uns das Modell mit dem Objekt model.train trainieren. Sie verwenden die zuvor definierte Funktion, um das Modell mit den entsprechenden Werten zu versorgen. Beachten Sie, dass Sie die Batchgröße auf 128 und die Anzahl der Epochen auf „Keine“ festlegen. Das Modell wird über tausend Schritte trainiert.

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>

Beachten Sie, dass der Verlust in den letzten 100 Schritten anschließend abnahm, also von 901 auf 1000.

Der endgültige Verlust nach tausend Iterationen beträgt 5444. Sie können Ihr Modell anhand des Testsatzes schätzen und die Leistung sehen. Um die Leistung Ihres Modells zu bewerten, müssen Sie die Objektbewertung verwenden. Sie füttern das Modell mit dem Testsatz und legen die Anzahl der Epochen auf 1 fest, d. h. die Daten werden nur einmal an das Modell gesendet.

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 gibt alle Metriken zurück, die Sie im theoretischen Teil gelernt haben. Es überrascht nicht, dass die Genauigkeit aufgrund der unausgeglichenen Beschriftung hoch ist. Tatsächlich schneidet das Modell etwas besser ab als eine zufällige Schätzung. Stellen Sie sich vor, dass das Modell alle Haushalte mit einem Einkommen von weniger als 50 prognostiziert, dann hat das Modell eine Genauigkeit von 70 Prozent. Bei einer genaueren Analyse können Sie erkennen, dass Vorhersage und Rückruf recht niedrig sind.

Schritt 4) Verbessern Sie das Modell

Da Sie nun über ein Benchmark-Modell verfügen, können Sie versuchen, es zu verbessern, also die Genauigkeit zu erhöhen. Im vorherigen Tutorial haben Sie gelernt, wie Sie die Vorhersagekraft mit einem Interaktionsterm verbessern können. In diesem Tutorial werden Sie diese Idee erneut aufgreifen, indem Sie der Regression einen Polynomterm hinzufügen.

Die polynomielle Regression ist von entscheidender Bedeutung, wenn die Daten nichtlinear sind. Es gibt zwei Möglichkeiten, Nichtlinearität in den Daten zu erfassen.

• Polynomterm hinzufügen
• Fassen Sie die kontinuierliche Variable in eine kategoriale Variable um

Polynomterm

Auf dem Bild unten können Sie sehen, was eine polynomielle Regression ist. Es handelt sich um eine Gleichung mit X Variablen unterschiedlicher Potenz. Eine Polynomregression zweiten Grades hat zwei Variablen, X und X-Quadrat. Der dritte Grad hat drei Variablen, X, X², und X³

Unten haben wir ein Diagramm mit zwei Variablen, X und Y, erstellt. Es ist offensichtlich, dass die Beziehung nicht linear ist. Wenn wir eine lineare Regression hinzufügen, sehen wir, dass das Modell das Muster nicht erfassen kann (linkes Bild).

Schauen Sie sich nun das linke Bild des Bildes unten an. Wir haben der Regression fünf Terme hinzugefügt (das heißt y=x+x).²+x³+x⁴+x⁵. Das Modell erfasst das Muster jetzt viel besser. Dies ist die Stärke der polynomialen Regression.

Kehren wir zu unserem Beispiel zurück. Das Alter steht in keinem linearen Zusammenhang mit dem Einkommen. Im frühen Alter kann es sein, dass das Einkommen nahe Null liegt, weil Kinder oder Jugendliche nicht arbeiten. Dann steigt sie im Erwerbsalter an und sinkt im Rentenalter. Typischerweise handelt es sich um eine umgekehrte U-Form. Eine Möglichkeit, dieses Muster zu erfassen, besteht darin, der Regression eine Zweierpotenz hinzuzufügen.

Mal sehen, ob es die Genauigkeit erhöht.

Sie müssen dieses neue Feature zum Datensatz und zur Liste der kontinuierlichen Features hinzufügen.

Sie fügen die neue Variable dem Trainings- und Testdatensatz hinzu, sodass das Schreiben einer Funktion bequemer ist.

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

Die Funktion hat 3 Argumente:

• df_t: Definieren Sie den Trainingssatz
• df_te: Definieren Sie den Testsatz
• var_name = 'age': Definieren Sie die zu transformierende Variable

Sie können das Objekt pow(2) verwenden, um die Variable Alter zu quadrieren. Beachten Sie, dass die neue Variable den Namen „new“ trägt.

Nachdem die Funktion „square_var“ nun geschrieben ist, können Sie die neuen Datensätze erstellen.

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

Wie Sie sehen, verfügt der neue Datensatz über eine weitere Funktion.

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

Die quadratische Variable heißt im Datensatz neu. Sie müssen es zur Liste der kontinuierlichen Features hinzufügen.

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]

Hinweis dass Sie das Verzeichnis des Graphen geändert haben. Sie können nicht verschiedene Modelle im selben Verzeichnis trainieren. Das bedeutet, dass Sie den Pfad des Arguments model_dir ändern müssen. Wenn Sie dies nicht tun, gibt TensorFlow einen Fehler aus.

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)

Nachdem der Klassifikator nun mit dem neuen Datensatz entworfen wurde, können Sie das Modell trainieren und auswerten.

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}

Die quadrierte Variable verbesserte die Genauigkeit von 0.76 auf 0.79. Mal sehen, ob Sie es besser machen können, indem Sie Bucketisierung und Interaktionsbegriff miteinander kombinieren.

Bucketisierung und Interaktion

Wie Sie bereits gesehen haben, ist ein linearer Klassifikator nicht in der Lage, das Alters-Einkommens-Muster korrekt zu erfassen. Das liegt daran, dass für jedes Feature eine einzelne Gewichtung erlernt wird. Um es dem Klassifizierer zu erleichtern, können Sie die Funktion in einen Bucket einbinden. Beim Bucketing wird ein numerisches Merkmal basierend auf dem Bereich, in den es fällt, in mehrere bestimmte Merkmale umgewandelt, und jedes dieser neuen Merkmale gibt an, ob das Alter einer Person in diesen Bereich fällt.

Mit diesen neuen Funktionen kann das lineare Modell die Beziehung erfassen, indem es unterschiedliche Gewichte für jeden Eimer lernt.

In TensorFlow erfolgt dies mit Bucketized_column. Sie müssen den Wertebereich in den Grenzen hinzufügen.

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

Sie wissen bereits, dass das Alter nicht linear mit dem Einkommen zusammenhängt. Eine weitere Möglichkeit, das Modell zu verbessern, ist die Interaktion. In den Worten von TensorFlow handelt es sich um Feature Crossing. Feature Crossing ist eine Möglichkeit, neue Features zu erstellen, die Kombinationen bestehender Features sind. Dies kann für einen linearen Klassifikator hilfreich sein, der keine Interaktionen zwischen Features modellieren kann.

Sie können das Alter anhand einer anderen Funktion wie der Bildung aufschlüsseln. Das heißt, einige Gruppen haben wahrscheinlich ein hohes Einkommen, andere ein niedriges (denken Sie an den Doktoranden).

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

Um eine Cross-Feature-Spalte zu erstellen, verwenden Sie „crossed_column“ mit den zu kreuzenden Variablen in einer Klammer. Die hash_bucket_size gibt die maximalen Kreuzungsmöglichkeiten an. Um eine Interaktion zwischen Variablen zu erstellen (mindestens eine Variable muss kategorisch sein), können Sie tf.feature_column.crossed_column verwenden. Um dieses Objekt zu verwenden, müssen Sie in eckigen Klammern die zu interagierende Variable und ein zweites Argument, die Bucket-Größe, hinzufügen. Die Bucket-Größe ist die maximal mögliche Gruppenanzahl innerhalb einer Variablen. Hier stellen Sie den Wert auf 1000 ein, da Sie die genaue Anzahl der Gruppen nicht kennen

age_buckets muss vorher quadriert werden, um es den Feature-Spalten hinzuzufügen. Außerdem fügen Sie die neuen Features zu den Feature-Spalten hinzu und bereiten den Schätzer vor

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)

Ausgang

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)

Sie sind bereit, das neue Modell abzuschätzen und zu sehen, ob es die Genauigkeit verbessert.

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}

Die neue Genauigkeit liegt bei 83.58 Prozent. Er liegt vier Prozent höher als beim Vorgängermodell.

Schließlich können Sie einen Regularisierungsterm hinzufügen, um eine Überanpassung zu verhindern.

Schritt 5) Hyperparameter:Lasso & Ridge

Ihr Modell kann darunter leiden Überanpassung or Unteranpassung.

• Überanpassung: Das Modell ist nicht in der Lage, die Vorhersage auf neue Daten zu verallgemeinern
• Unteranpassung: Das Modell ist nicht in der Lage, das Muster der Daten zu erfassen. dh lineare Regression, wenn die Daten nichtlinear sind

Wenn ein Modell über viele Parameter und eine relativ geringe Datenmenge verfügt, führt dies zu schlechten Vorhersagen. Stellen Sie sich vor, eine Gruppe hat nur drei Beobachtungen; Das Modell berechnet eine Gewichtung für diese Gruppe. Das Gewicht wird verwendet, um eine Vorhersage zu treffen; Wenn sich die Beobachtungen des Testsatzes für diese bestimmte Gruppe völlig vom Trainingssatz unterscheiden, wird das Modell eine falsche Vorhersage treffen. Bei der Auswertung mit dem Trainingssatz ist die Genauigkeit gut, mit dem Testsatz jedoch nicht gut, da die berechneten Gewichte nicht die wahren sind, um das Muster zu verallgemeinern. In diesem Fall kann keine vernünftige Vorhersage auf der Grundlage unsichtbarer Daten getroffen werden.

Um Überanpassung zu vermeiden, bietet Ihnen die Regularisierung die Möglichkeit, diese Komplexität zu kontrollieren und sie allgemeiner zu machen. Es gibt zwei Regularisierungstechniken:

• L1: Lasso
• L2: Grat

In TensorFlow können Sie diese beiden Hyperparameter im Optimierer hinzufügen. Je höher beispielsweise der Hyperparameter L2 ist, desto niedriger ist das Gewicht tendenziell und liegt nahe bei Null. Die angepasste Linie wird sehr flach sein, während ein L2 nahe Null bedeutet, dass die Gewichte nahe an der regulären linearen Regression liegen.

Sie können die unterschiedlichen Werte der Hyperparameter selbst ausprobieren und sehen, ob Sie die Genauigkeit erhöhen können.

Hinweis dass Sie, wenn Sie den Hyperparameter ändern, den Ordner „running/train4“ löschen müssen, da das Modell sonst mit dem zuvor trainierten Modell startet.

Mal sehen, wie die Genauigkeit mit dem Hype ist

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

AUSGABE

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)

AUSGABE

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)

Ausgang

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}

Mit diesem Hyperparameter erhöhen Sie die Genauigkeitsmetriken geringfügig. Im nächsten Tutorial erfahren Sie, wie Sie einen linearen Klassifikator mithilfe einer Kernel-Methode verbessern.

Zusammenfassung

Um ein Modell zu trainieren, müssen Sie Folgendes tun:

• Definieren Sie die Funktionen: Unabhängige Variablen: X
• Definieren Sie die Bezeichnung: Abhängige Variable: y
• Konstruieren Sie einen Zug-/Testsatz
• Definieren Sie das Anfangsgewicht
• Definieren Sie die Verlustfunktion: MSE
• Optimieren Sie das Modell: Gradientenabstieg
• Definieren:
  • Lernrate
  • Anzahl der Epochen
  • Chargengröße
  • Anzahl der Klassen

In diesem Tutorial haben Sie gelernt, wie Sie die High-Level-API für einen linearen Regressionsklassifikator verwenden. Sie müssen Folgendes definieren:

1. Feature-Spalten. Wenn kontinuierlich: tf.feature_column.numeric_column(). Sie können eine Liste mit Python-Listenverständnis füllen
2. Der Schätzer: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
3. Eine Funktion zum Importieren der Daten, der Batch-Größe und der Epoche: input_fn()

Danach können Sie trainieren, auswerten und eine Vorhersage mit train(), equal() und predict() treffen.

Um die Leistung des Modells zu verbessern, können Sie:

• Verwenden Sie eine polynomielle Regression
• Interaktionsbegriff: tf.feature_column.crossed_column
• Regularisierungsparameter hinzufügen