Binäre Klassifizierung in TensorFlow: Beispiel für einen linearen Klassifizierer

Die beiden häufigsten überwachten Lernaufgaben 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 den linearen Klassifikator.

Was ist ein linearer Klassifikator?

Ein linearer Klassifikator beim maschinellen Lernen ist eine Methode zum Finden der Klasse eines Objekts basierend auf seinen Merkmalen 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 Klassifizierung von Dokumenten und bei Problemen mit vielen Variablen verwendet.

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

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

Ein typisches Problem bei der binären Klassifizierung besteht beispielsweise darin, die Wahrscheinlichkeit vorherzusagen, mit der ein Kunde einen zweiten Kauf tätigt. Die Vorhersage des auf einem Bild angezeigten Tiertyps ist ein Problem der Klassifizierung mehrerer Klassen, da mehr als zwei Tierarten vorhanden sind.

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

In diesem Tutorial lernen Sie

• Was ist ein linearer Klassifikator?
• Wie funktioniert der Binärklassifikator?
• Wie messe ich die Leistung eines linearen Klassifikators?
• Richtigkeit
• Verwirrung Matrix
• Präzision und Empfindlichkeit
• Linearer Klassifikator mit TensorFlow
• 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

Wie funktioniert der Binärklassifikator?

Sie haben im vorherigen Lernprogramm gelernt, dass eine Funktion aus zwei Arten von Variablen besteht, einer abhängigen Variablen und einer Reihe von Merkmalen (unabhängige Variablen). In der linearen Regression ist eine abhängige Variable eine reelle Zahl ohne Bereich. Das Hauptziel besteht darin, seinen Wert durch Minimierung des mittleren quadratischen Fehlers vorherzusagen.

Für den TensorFlow Binary Classifier kann das Label zwei mögliche ganzzahlige Werte haben. In den meisten Fällen ist es entweder [0,1] oder [1,2]. Ziel ist es beispielsweise, 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 zu klassifizieren, zu der er gehört, nämlich potenzieller Käufer oder nicht.

Die Erfolgswahrscheinlichkeit wird mit logistischer Regression berechnet . Der Algorithmus berechnet eine Wahrscheinlichkeit basierend auf dem Merkmal X und sagt einen Erfolg voraus, wenn diese Wahrscheinlichkeit über 50 Prozent liegt. Formal wird die Wahrscheinlichkeit wie im folgenden Beispiel für die binäre TensorFlow-Klassifizierung berechnet:

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

Die Funktion kann in zwei Teile zerlegt werden:

• Das lineare Modell
• Die logistische Funktion

Lineares Modell

Sie sind bereits mit der Berechnung der Gewichte vertraut. Gewichte werden unter Verwendung eines Punktprodukts berechnet: Y ist eine lineare Funktion aller Merkmale x _i . Wenn das Modell keine Merkmale aufweist, ist die Vorhersage gleich der Vorspannung, b.

Die Gewichte geben die Richtung der Korrelation zwischen den Merkmalen x _i und der Bezeichnung y an. 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 eine reelle Zahl zurück, die nicht mit dem Wahrscheinlichkeitsmaß des Bereichs [0,1] übereinstimmt. Die logistische Funktion ist erforderlich, um die Ausgabe des linearen Modells in eine Wahrscheinlichkeit umzuwandeln.

Logistische Funktion

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

Beispiel für eine logistische Funktion

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 messe ich die Leistung eines linearen Klassifikators?

Richtigkeit

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

Messen Sie die Leistung des linearen Klassifikators mithilfe der Genauigkeitsmetrik

Sie können einen Mangel bei dieser Metrik feststellen, insbesondere für die Ungleichgewichtsklasse. Ein Ungleichgewichtsdatensatz tritt auf, wenn die Anzahl der Beobachtungen pro Gruppe nicht gleich ist. Sagen wir; 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, um die Anzahl der Todesfälle vorherzusagen, und die Genauigkeitsmetrik verwenden, um die Leistungen zu bewerten. Wenn der Klassifizierer für den gesamten Datensatz 0 Todesfälle vorhersagt, ist dies in 95 Prozent der Fälle korrekt.

Verwirrung Matrix

Eine bessere Möglichkeit, die Leistung eines Klassifikators zu bewerten, besteht darin, die Verwirrungsmatrix zu betrachten.

Messen Sie die Leistung des linearen Klassifikators mithilfe der Verwirrungsmatrix

Die Verwirrungsmatrix visualisiert die Genauigkeit eines Klassifikators durch Vergleichen der tatsächlichen und vorhergesagten Klassen, wie im obigen Beispiel für einen linearen Klassifikator gezeigt. Die binäre Verwirrungsmatrix besteht aus Quadraten:

• TP: True Positive: Vorhersagewerte, die korrekt als tatsächlich positiv vorhergesagt wurden
• FP: Vorausgesagte Werte haben fälschlicherweise ein tatsächliches Positiv vorhergesagt. dh negative Werte, die als positiv vorhergesagt werden
• FN: Falsch Negativ: Positive Werte werden als negativ vorhergesagt
• TN: True Negative: Vorhersagewerte, die korrekt als tatsächlich negativ vorhergesagt wurden

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

Präzision und Empfindlichkeit

Die Verwirrungsmatrix bietet einen guten Einblick in das wahre Positive und das falsche Positive. In einigen Fällen ist es vorzuziehen, eine präzisere Metrik zu haben.

Präzision

Die Präzisionsmetrik zeigt die Genauigkeit der positiven Klasse. Es misst, wie wahrscheinlich die Vorhersage der positiven Klasse korrekt 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 Rückrufmetrik gepaart. Der Rückruf wird auch als Empfindlichkeit oder echte positive Rate bezeichnet.

Empfindlichkeit

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

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.000 ist
• 0 bei Einkommen <50.000.

Diese Variable ist Ihre Bezeichnung

Dieser Datensatz enthält acht kategoriale Variablen:

• Arbeitsplatz
• Bildung
• ehelich
• Besetzung
• Beziehung
• Rennen
• Sex
• Heimatland

Darüber hinaus sechs kontinuierliche Variablen:

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

In diesem Beispiel für die TensorFlow-Klassifizierung erfahren Sie, wie Sie lineare TensorFlow-Klassifizierer 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 zuerst die im Lernprogramm verwendeten Bibliotheken.

import tensorflow as tfimport pandas as pd 

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

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

## Define path dataCOLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss','hours_week', 'native_country', 'label']PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

Die online gespeicherten Daten sind bereits zwischen einem Zugsatz und einem 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)

Das Zugset enthält 32.561 Beobachtungen und das Testset 16.281

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

Tensorflow erfordert einen Booleschen Wert, um den Klassifikator zu trainieren. Sie müssen die Werte von Zeichenfolge in Ganzzahl umwandeln. Die Beschriftung wird als Objekt gespeichert. Sie müssen sie jedoch in einen numerischen Wert konvertieren. Der folgende Code erstellt ein Wörterbuch mit den Werten, die konvertiert werden sollen, und führt eine Schleife über das Spaltenelement durch. Beachten Sie, dass Sie diesen Vorgang zweimal ausführen, einen für den Zugtest und einen 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.000 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 caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

Schritt 2) Datenkonvertierung

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

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

Es empfiehlt sich, zwei Listen von Features basierend auf ihrem Typ zu definieren und sie dann in den feature_columns des Schätzers zu übergeben.

Sie konvertieren zunächst fortlaufende Features und definieren dann einen Bucket mit den kategorialen Daten.

Die Funktionen des Datensatzes haben zwei Formate:

• Ganze Zahl
• Objekt

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

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

Die feature_column ist mit einem Objekt numeric_column ausgestattet, um die Umwandlung der stetigen Variablen in einen Tensor zu erleichtern. Im folgenden Code konvertieren Sie alle Variablen von CONTI_FEATURES in einen Tensor mit einem numerischen Wert. Dies ist obligatorisch, um das Modell zu erstellen. Alle unabhängigen Variablen müssen in den richtigen Tensortyp konvertiert werden.

Im Folgenden schreiben wir einen Code, mit dem Sie sehen können, was hinter feature_column.numeric_column passiert. Wir werden den konvertierten Wert für das Alter ausdrucken. Er dient zu Erklärungszwecken, daher ist es nicht erforderlich, den Python-Code zu verstehen. Sie können sich auf die offizielle Dokumentation beziehen, um die Codes zu verstehen.

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif continuous == True:c = tf.feature_column.numeric_column(feature)feature_columns = [c]else:c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size)c_indicator = tf.feature_column.indicator_column(c)feature_columns = [c_indicator]## Use input_layer to print the valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(sess.run(input_layer))print_transformation(feature = "age", continuous = True)[[39.][50.][38.]… [58.][22.][52.]]

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 Vokabelliste eines Features bekannt ist und nicht viele Werte enthält, kann die kategoriale Spalte mit categoryical_column_with_vocabulary_list erstellt werden. Es wird jeder eindeutigen Vokabelliste eine ID zugewiesen.

Zum Beispiel, wenn ein Variablenstatus drei unterschiedliche Werte hat:

• Mann
• Ehefrau
• Single

Dann werden drei IDs zugeordnet. Zum Beispiel 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 Feature Geschlecht konvertieren, erstellt Tensorflow zwei neue Spalten, eine für Männer und eine für Frauen. Wenn das Geschlecht gleich männlich ist, ist die neue Spalte männlich gleich 1 und weiblich gleich 0. Dieses Beispiel ist in der folgenden Tabelle dargestellt:

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

Im Tensorfluss:

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

Unten haben wir Python-Code hinzugefügt, um die Codierung zu drucken. 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 die Verwendung der Methode categoryical_column_with_hash_bucket. Das Ändern von Zeichenfolgenvariablen in einer Matrix mit geringer Dichte ist hilfreich. Eine spärliche Matrix ist eine Matrix mit meistens Null. Die Methode kümmert sich um alles. Sie müssen nur die Anzahl der Buckets und die Schlüsselspalte angeben. Die Anzahl der Buckets ist die maximale Anzahl von 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 Funktionen.

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 die lineare Klassifizierung.

• Lineare Regression: LinearRegressor
• Lineare Klassifizierung: LinearClassifier

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

Das Modell berechnet die Gewichte der Spalten, die in Continuous_Features und Categical_Features enthalten sind.

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

AUSGABE:

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec':, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Nachdem der Klassifizierer definiert wurde, 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, dh Anzahl der Epochen, Anzahl der Stapel, und mischen den Datensatz oder die Notiz. Da Sie die Pandas-Methode verwenden, 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 Stapelgröße auf 128 und die Anzahl der Epochen auf Keine festlegen. Das Modell wird in tausend Schritten 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 = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.INFO:tensorflow:Loss for final step: 5444.363.

Beachten Sie, dass der Verlust anschließend während der letzten 100 Schritte, dh von 901 auf 1000, abnahm.

Der endgültige Verlust nach tausend Iterationen beträgt 5444. Sie können Ihr Modell anhand des Testsatzes schätzen und die Leistung anzeigen. Um die Leistung Ihres Modells zu bewerten, müssen Sie die Objektbewertung verwenden. Sie füttern das Modell mit dem Testsatz und setzen die Anzahl der Epochen auf 1, dh 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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546{'accuracy': 0.7615626,'accuracy_baseline': 0.76377374,'auc': 0.63300294,'auc_precision_recall': 0.50891197,'average_loss': 47.12155,'global_step': 1000,'label/mean': 0.23622628,'loss': 5993.6406,'precision': 0.49401596,'prediction/mean': 0.18454961,'recall': 0.38637546}

TensorFlow gibt alle Metriken zurück, die Sie im theoretischen Teil gelernt haben. Ohne Überraschung ist die Genauigkeit aufgrund des unausgeglichenen Etiketts groß. Tatsächlich schneidet das Modell etwas besser ab als eine zufällige Vermutung. Stellen Sie sich vor, das Modell prognostiziert alle Haushalte mit einem Einkommen von weniger als 50.000, dann hat das Modell eine Genauigkeit von 70 Prozent. Bei näherer Betrachtung können Sie feststellen, dass die Vorhersage und der Rückruf recht gering sind.

Schritt 4) Verbessern Sie das Modell

Nachdem Sie ein Benchmark-Modell haben, können Sie versuchen, es zu verbessern, dh 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 Polynomregression spielt eine wichtige Rolle, wenn die Daten nichtlinear sind. Es gibt zwei Möglichkeiten, die Nichtlinearität in den Daten zu erfassen.

• Polynomterm hinzufügen
• Binden Sie die kontinuierliche Variable in eine kategoriale Variable ein

Polynomterm

Auf dem Bild unten können Sie sehen, was eine Polynomregression ist. Es ist eine Gleichung mit X Variablen mit unterschiedlicher Leistung. Eine Polynomregression zweiten Grades hat zwei Variablen, X und X im Quadrat. Der dritte Grad hat drei Variablen, X, X ² und X ³

Was ist Polynomregression?

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, können wir sehen, dass das Modell das Muster nicht erfassen kann (linkes Bild).

Schauen Sie sich nun das linke Bild aus dem Bild unten an. Wir haben der Regression einen Fünf-Term hinzugefügt (dh y = x + x ² + x ³ + x ⁴ + x ^5. Das Modell erfasst das Muster jetzt viel besser. Dies ist die Kraft der Polynomregression.

Kehren wir zu unserem Beispiel zurück. Das Alter steht nicht in einem linearen Verhältnis zum Einkommen. Frühes Alter kann ein pauschales Einkommen nahe Null haben, weil Kinder oder Jugendliche nicht arbeiten. Dann nimmt es im erwerbsfähigen Alter zu und im Ruhestand ab. Es ist typischerweise eine umgekehrte U-Form. Eine Möglichkeit, dieses Muster zu erfassen, besteht darin, der Regression eine Potenz zwei hinzuzufügen.

Mal sehen, ob es die Genauigkeit erhöht.

Sie müssen diese neue Funktion zum Datensatz und in der Liste der fortlaufenden Funktionen hinzufügen.

Sie fügen die neue Variable dem Zug- und Testdatensatz hinzu, damit Sie bequemer eine Funktion schreiben können.

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: Definiere den Trainingssatz
• df_te: Definiere den Testsatz
• var_name = 'age': Definiert die zu transformierende Variable

Mit dem Objekt pow (2) können Sie das variable Alter quadrieren. Beachten Sie, dass die neue Variable "neu" heißt.

Nachdem die Funktion square_var geschrieben wurde, 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 können, 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 wird im Datensatz als neu bezeichnet. Sie müssen es zur Liste der fortlaufenden Funktionen 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]

Beachten Sie, dass Sie das Verzeichnis des Diagramms geändert haben. Sie können nicht verschiedene Modelle im selben Verzeichnis trainieren. Dies 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':, '_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 mit dem neuen Datensatz entworfen wurde, können Sie das Modell trainieren und bewerten.

model_1.train(input_fn=get_input_fn(df_train,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into ongoing/train1/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.INFO:tensorflow:Loss for final step: 28861.898.

model_1.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703{'accuracy': 0.7944229,'accuracy_baseline': 0.76377374,'auc': 0.6093755,'auc_precision_recall': 0.54885805,'average_loss': 111.0046,'global_step': 1000,'label/mean': 0.23622628,'loss': 14119.265,'precision': 0.6682401,'prediction/mean': 0.09116262,'recall': 0.2576703}

Die quadratische Variable verbesserte die Genauigkeit von 0,76 auf 0,79. Mal sehen, ob Sie es besser machen können, indem Sie Bucketization und Interaktionsbegriff miteinander kombinieren.

Bucketization und Interaktion

Wie Sie zuvor gesehen haben, kann ein linearer Klassifikator das Alterseinkommensmuster nicht korrekt erfassen. Das liegt daran, dass für jedes Merkmal ein einzelnes Gewicht gelernt wird. Um es dem Klassifizierer einfacher zu machen, können Sie die Funktion erweitern. Durch das Bucketing wird ein numerisches Merkmal basierend auf dem Bereich, in den es fällt, in mehrere bestimmte Merkmale umgewandelt. 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 für jeden Eimer unterschiedliche Gewichte gelernt werden.

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 zum Einkommen ist. Eine andere Möglichkeit, das Modell zu verbessern, ist die Interaktion. Im Wort von TensorFlow ist es Feature Crossing. Das Überkreuzen von Features ist eine Möglichkeit, neue Features zu erstellen, bei denen es sich um Kombinationen vorhandener Features handelt. Dies kann für einen linearen Klassifizierer hilfreich sein, der Interaktionen zwischen Features nicht modellieren kann.

Sie können das Alter mit einer anderen Funktion wie Bildung aufschlüsseln. Das heißt, einige Gruppen haben wahrscheinlich ein hohes Einkommen und 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 gekreuzte Spalte mit den Variablen, die in einer Klammer gekreuzt werden sollen. Das 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 die zu interagierende Variable in eckige Klammern und ein zweites Argument, die Bucket-Größe, einfügen. Die Bucket-Größe ist die maximal mögliche Anzahl von Gruppen innerhalb einer Variablen. Hier setzen Sie es auf 1000, da Sie die genaue Anzahl der Gruppen nicht kennen

age_buckets muss vorher quadriert werden, um es zu den Feature-Spalten hinzuzufügen. Sie fügen die neuen Features auch 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)

AUSGABE

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'native_country', 'new']def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES_imp}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Sie können das neue Modell abschätzen und prüfen, 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 = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.INFO:tensorflow:Loss for final step: 44.18133.

model_imp.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216{'accuracy': 0.8358209,'accuracy_baseline': 0.76377374,'auc': 0.88401634,'auc_precision_recall': 0.69599575,'average_loss': 0.35122654,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.67437,'precision': 0.68986726,'prediction/mean': 0.23320661,'recall': 0.55408216}

Die neue Genauigkeit liegt bei 83,58 Prozent. Es ist vier Prozent höher als das Vorgängermodell.

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

Schritt 5) Hyperparameter: Lasso & Ridge

Ihr Modell kann leiden an Überanpassung oder underfitting .

• Überanpassung: Das Modell kann die Vorhersage nicht auf neue Daten verallgemeinern
• Unteranpassung: Das Modell kann das Muster der Daten nicht erfassen. dh lineare Regression, wenn die Daten nicht linear sind

Wenn ein Modell viele Parameter und eine relativ geringe Datenmenge aufweist, führt dies zu schlechten Vorhersagen. Stellen Sie sich vor, eine Gruppe hat nur drei Beobachtungen. Das Modell berechnet ein Gewicht für diese Gruppe. Das Gewicht wird verwendet, um eine Vorhersage zu treffen; Wenn sich die Beobachtungen des Testsatzes für diese bestimmte Gruppe vollständig vom Trainingssatz unterscheiden, macht das Modell eine falsche Vorhersage. Während der Auswertung mit dem Trainingssatz ist die Genauigkeit gut, aber nicht gut mit dem Testsatz, da die berechneten Gewichte nicht die wahre sind, um das Muster zu verallgemeinern. In diesem Fall wird keine vernünftige Vorhersage für unsichtbare Daten getroffen.

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

• L1: Lasso
• L2: Ridge

In TensorFlow können Sie diese beiden Hyperparameter im Optimierer hinzufügen. Zum Beispiel ist das Gewicht umso niedriger und nahe Null, je höher der Hyperparameter L2 ist. Die angepasste Linie ist sehr flach, während ein L2 nahe Null impliziert, dass die Gewichte nahe an der regulären linearen Regression liegen.

Sie können den unterschiedlichen Wert der Hyperparameter selbst ausprobieren und prüfen, ob Sie die Genauigkeit erhöhen können.

Beachten Sie, dass Sie beim Ändern des Hyperparameters den Ordner running / train4 löschen müssen, da das Modell sonst mit dem zuvor trainierten Modell beginnt.

Mal sehen, wie genau der 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))

OUPUT

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

model_regu.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

OUPUT

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into ongoing/train4/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.INFO:tensorflow:Loss for final step: 43.4942.

model_regu.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

AUSGABE

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823{'accuracy': 0.83833915,'accuracy_baseline': 0.76377374,'auc': 0.8869794,'auc_precision_recall': 0.7014905,'average_loss': 0.34691378,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.12581,'precision': 0.69720596,'prediction/mean': 0.23662092,'recall': 0.5579823}

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:

• Definieren Sie die Features: Unabhängige Variablen: X.
• Definieren Sie die Bezeichnung: Abhängige Variable: y
• Konstruieren Sie ein Zug- / Test-Set
• Definieren Sie das Anfangsgewicht
• Definieren Sie die Verlustfunktion: MSE
• Modell optimieren: Gradientenabstieg
• Definieren:
  • Lernrate
  • Anzahl der Epochen
  • Chargengröße
  • Anzahl der Klassen

In diesem Lernprogramm haben Sie gelernt, wie Sie die übergeordnete API für einen linearen Regressionsklassifizierer verwenden. Sie müssen 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 Stapelgröße und der Epoche: input_fn ()

Danach können Sie mit train () trainieren, bewerten und eine Vorhersage treffen, evaluieren () und vorhersagen ()

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

• Verwenden Sie die Polynomregression
• Interaktionsbegriff: tf.feature_column.crossed_column
• Regularisierungsparameter hinzufügen