Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Vorgefertigte Schätzer

Ansicht auf TensorFlow.org In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

Dieses Tutorial zeigt Ihnen, wie Sie das Iris-Klassifizierungsproblem in TensorFlow mithilfe von Schätzern lösen. Ein Schätzer ist TensorFlows allgemeine Darstellung eines vollständigen Modells und wurde für eine einfache Skalierung und asynchrones Training entwickelt. Weitere Einzelheiten finden Sie unter Schätzer .

Beachten Sie, dass in TensorFlow 2.0 die Keras-API viele dieser Aufgaben ausführen kann und als einfacher zu erlernende API angesehen wird. Wenn Sie neu anfangen, empfehlen wir Ihnen, mit Keras zu beginnen. Weitere Informationen zu den verfügbaren High-Level-APIs in TensorFlow 2.0 finden Sie unter Standardisieren auf Keras .

Das wichtigste zuerst

Um zu beginnen, importieren Sie zuerst TensorFlow und eine Reihe von Bibliotheken, die Sie benötigen.

import tensorflow as tf

import pandas as pd

Der Datensatz

Das Beispielprogramm in diesem Dokument erstellt und testet ein Modell, das Irisblüten anhand der Größe ihrer Kelchblätter und Blütenblätter in drei verschiedene Arten unterteilt.

Sie trainieren ein Modell mit dem Iris-Datensatz. Der Iris-Datensatz enthält vier Funktionen und eine Beschriftung . Die vier Merkmale kennzeichnen die folgenden botanischen Merkmale einzelner Irisblüten:

  • Kelchblattlänge
  • Kelchblattbreite
  • Blütenblattlänge
  • Blütenblattbreite

Basierend auf diesen Informationen können Sie einige hilfreiche Konstanten zum Parsen der Daten definieren:

CSV_COLUMN_NAMES = ['SepalLength', 'SepalWidth', 'PetalLength', 'PetalWidth', 'Species']
SPECIES = ['Setosa', 'Versicolor', 'Virginica']

Laden Sie anschließend den Iris-Datensatz mit Keras und Pandas herunter und analysieren Sie ihn. Beachten Sie, dass Sie unterschiedliche Datensätze für Schulungen und Tests aufbewahren.

train_path = tf.keras.utils.get_file(
    "iris_training.csv", "https://storage.googleapis.com/download.tensorflow.org/data/iris_training.csv")
test_path = tf.keras.utils.get_file(
    "iris_test.csv", "https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv")

train = pd.read_csv(train_path, names=CSV_COLUMN_NAMES, header=0)
test = pd.read_csv(test_path, names=CSV_COLUMN_NAMES, header=0)

Sie können Ihre Daten überprüfen, um festzustellen, ob Sie vier Float-Feature-Spalten und eine int32-Bezeichnung haben.

train.head()

Teilen Sie für jeden Datensatz die Beschriftungen auf, für deren Vorhersage das Modell trainiert wird.

train_y = train.pop('Species')
test_y = test.pop('Species')

# The label column has now been removed from the features.
train.head()

Übersicht über die Programmierung mit Estimators

Nachdem Sie die Daten eingerichtet haben, können Sie ein Modell mit einem TensorFlow Estimator definieren. Ein Estimator ist eine von tf.estimator.Estimator abgeleitete tf.estimator.Estimator . TensorFlow bietet eine Sammlung von tf.estimator (z. B. LinearRegressor ) zur Implementierung gängiger ML-Algorithmen. Darüber hinaus können Sie Ihre eigenen benutzerdefinierten Schätzer schreiben. Wir empfehlen die Verwendung vorgefertigter Schätzer, wenn Sie gerade erst anfangen.

Um ein TensorFlow-Programm zu schreiben, das auf vorgefertigten Schätzern basiert, müssen Sie die folgenden Aufgaben ausführen:

  • Erstellen Sie eine oder mehrere Eingabefunktionen.
  • Definieren Sie die Feature-Spalten des Modells.
  • Instanziieren Sie einen Schätzer, indem Sie die Feature-Spalten und verschiedene Hyperparameter angeben.
  • Rufen Sie eine oder mehrere Methoden für das Estimator-Objekt auf und übergeben Sie die entsprechende Eingabefunktion als Datenquelle.

Mal sehen, wie diese Aufgaben für die Iris-Klassifizierung implementiert werden.

Erstellen Sie Eingabefunktionen

Sie müssen Eingabefunktionen erstellen, um Daten für Training, Auswertung und Vorhersage bereitzustellen.

Eine Eingabefunktion ist eine Funktion, die ein tf.data.Dataset Objekt tf.data.Dataset , das das folgende Tupel mit zwei Elementen ausgibt:

  • features - Ein Python-Wörterbuch, in dem:
    • Jeder Schlüssel ist der Name eines Features.
    • Jeder Wert ist ein Array, das alle Werte dieses Features enthält.
  • label - Ein Array, das die Werte des Labels für jedes Beispiel enthält.

Um das Format der Eingabefunktion zu demonstrieren, folgt eine einfache Implementierung:

def input_evaluation_set():
    features = {'SepalLength': np.array([6.4, 5.0]),
                'SepalWidth':  np.array([2.8, 2.3]),
                'PetalLength': np.array([5.6, 3.3]),
                'PetalWidth':  np.array([2.2, 1.0])}
    labels = np.array([2, 1])
    return features, labels

Ihre Eingabefunktion kann das features und die label Belieben generieren. Wir empfehlen jedoch die Verwendung der Dataset-API von TensorFlow, mit der alle Arten von Daten analysiert werden können.

Die Dataset-API kann viele häufige Fälle für Sie behandeln. Mit der Dataset-API können Sie beispielsweise problemlos Datensätze aus einer großen Sammlung von Dateien parallel einlesen und zu einem einzigen Stream zusammenfügen.

Um die Dinge in diesem Beispiel einfach zu halten, werden Sie die Daten mit Pandas laden und eine Eingabepipeline aus diesen speicherinternen Daten erstellen:

def input_fn(features, labels, training=True, batch_size=256):
    """An input function for training or evaluating"""
    # Convert the inputs to a Dataset.
    dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels))

    # Shuffle and repeat if you are in training mode.
    if training:
        dataset = dataset.shuffle(1000).repeat()
    
    return dataset.batch(batch_size)

Definieren Sie die Feature-Spalten

Eine Feature-Spalte ist ein Objekt, das beschreibt, wie das Modell rohe Eingabedaten aus dem Feature-Wörterbuch verwenden soll. Wenn Sie ein Estimator-Modell erstellen, übergeben Sie ihm eine Liste von Feature-Spalten, in der alle Features beschrieben werden, die das Modell verwenden soll. Das Modul tf.feature_column bietet viele Optionen zum Darstellen von Daten im Modell.

Für Iris sind die 4 Roh-Features numerische Werte. Daher erstellen wir eine Liste von Feature-Spalten, um das Estimator-Modell anzuweisen, jedes der vier Features als 32-Bit-Gleitkommawerte darzustellen. Daher lautet der Code zum Erstellen der Feature-Spalte:

# Feature columns describe how to use the input.
my_feature_columns = []
for key in train.keys():
    my_feature_columns.append(tf.feature_column.numeric_column(key=key))

Feature-Spalten können weitaus komplexer sein als die hier gezeigten. Weitere Informationen zu Feature-Spalten finden Sie in diesem Handbuch .

Nachdem Sie nun beschrieben haben, wie das Modell die Rohfunktionen darstellen soll, können Sie den Schätzer erstellen.

Instanziieren Sie einen Schätzer

Das Iris-Problem ist ein klassisches Klassifizierungsproblem. Glücklicherweise bietet TensorFlow mehrere vorgefertigte Klassifikatorschätzer an, darunter:

Für das Iris-Problem scheint tf.estimator.DNNClassifier die beste Wahl zu sein. So haben Sie diesen Schätzer instanziiert:

# Build a DNN with 2 hidden layers with 30 and 10 hidden nodes each.
classifier = tf.estimator.DNNClassifier(
    feature_columns=my_feature_columns,
    # Two hidden layers of 30 and 10 nodes respectively.
    hidden_units=[30, 10],
    # The model must choose between 3 classes.
    n_classes=3)
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpbhg2uvbr
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpbhg2uvbr', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_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}

Trainieren, bewerten und vorhersagen

Nachdem Sie ein Estimator-Objekt haben, können Sie Methoden aufrufen, um Folgendes zu tun:

  • Trainiere das Modell.
  • Bewerten Sie das trainierte Modell.
  • Verwenden Sie das trainierte Modell, um Vorhersagen zu treffen.

Trainiere das Modell

Trainieren des Modells durch den Schätzer des anrufenden train Methode wie folgt:

# Train the Model.
classifier.train(
    input_fn=lambda: input_fn(train, train_y, training=True),
    steps=5000)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because its dtype defaults to floatx.

If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.

To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/optimizer_v2/adagrad.py:83: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
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:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpbhg2uvbr/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.1140382, step = 0
INFO:tensorflow:global_step/sec: 312.415
INFO:tensorflow:loss = 0.8781501, step = 100 (0.321 sec)
INFO:tensorflow:global_step/sec: 375.535
INFO:tensorflow:loss = 0.80712265, step = 200 (0.266 sec)
INFO:tensorflow:global_step/sec: 372.712
INFO:tensorflow:loss = 0.7615077, step = 300 (0.268 sec)
INFO:tensorflow:global_step/sec: 368.782
INFO:tensorflow:loss = 0.733555, step = 400 (0.271 sec)
INFO:tensorflow:global_step/sec: 372.689
INFO:tensorflow:loss = 0.6983943, step = 500 (0.268 sec)
INFO:tensorflow:global_step/sec: 370.308
INFO:tensorflow:loss = 0.67940104, step = 600 (0.270 sec)
INFO:tensorflow:global_step/sec: 373.374
INFO:tensorflow:loss = 0.65386146, step = 700 (0.268 sec)
INFO:tensorflow:global_step/sec: 368.335
INFO:tensorflow:loss = 0.63730353, step = 800 (0.272 sec)
INFO:tensorflow:global_step/sec: 371.575
INFO:tensorflow:loss = 0.61313766, step = 900 (0.269 sec)
INFO:tensorflow:global_step/sec: 371.975
INFO:tensorflow:loss = 0.6123625, step = 1000 (0.269 sec)
INFO:tensorflow:global_step/sec: 369.615
INFO:tensorflow:loss = 0.5957534, step = 1100 (0.270 sec)
INFO:tensorflow:global_step/sec: 374.054
INFO:tensorflow:loss = 0.57203, step = 1200 (0.267 sec)
INFO:tensorflow:global_step/sec: 369.713
INFO:tensorflow:loss = 0.56556034, step = 1300 (0.270 sec)
INFO:tensorflow:global_step/sec: 366.202
INFO:tensorflow:loss = 0.547443, step = 1400 (0.273 sec)
INFO:tensorflow:global_step/sec: 361.407
INFO:tensorflow:loss = 0.53326523, step = 1500 (0.277 sec)
INFO:tensorflow:global_step/sec: 367.461
INFO:tensorflow:loss = 0.51837724, step = 1600 (0.272 sec)
INFO:tensorflow:global_step/sec: 364.181
INFO:tensorflow:loss = 0.5281174, step = 1700 (0.275 sec)
INFO:tensorflow:global_step/sec: 368.139
INFO:tensorflow:loss = 0.5139683, step = 1800 (0.271 sec)
INFO:tensorflow:global_step/sec: 366.277
INFO:tensorflow:loss = 0.51073176, step = 1900 (0.273 sec)
INFO:tensorflow:global_step/sec: 366.634
INFO:tensorflow:loss = 0.4949246, step = 2000 (0.273 sec)
INFO:tensorflow:global_step/sec: 364.732
INFO:tensorflow:loss = 0.49381495, step = 2100 (0.274 sec)
INFO:tensorflow:global_step/sec: 365.006
INFO:tensorflow:loss = 0.48916715, step = 2200 (0.274 sec)
INFO:tensorflow:global_step/sec: 366.902
INFO:tensorflow:loss = 0.48790723, step = 2300 (0.273 sec)
INFO:tensorflow:global_step/sec: 362.232
INFO:tensorflow:loss = 0.47671652, step = 2400 (0.276 sec)
INFO:tensorflow:global_step/sec: 368.592
INFO:tensorflow:loss = 0.47324088, step = 2500 (0.271 sec)
INFO:tensorflow:global_step/sec: 371.611
INFO:tensorflow:loss = 0.46822113, step = 2600 (0.269 sec)
INFO:tensorflow:global_step/sec: 362.345
INFO:tensorflow:loss = 0.4621966, step = 2700 (0.276 sec)
INFO:tensorflow:global_step/sec: 362.788
INFO:tensorflow:loss = 0.47817266, step = 2800 (0.275 sec)
INFO:tensorflow:global_step/sec: 368.473
INFO:tensorflow:loss = 0.45853442, step = 2900 (0.271 sec)
INFO:tensorflow:global_step/sec: 360.944
INFO:tensorflow:loss = 0.44062576, step = 3000 (0.277 sec)
INFO:tensorflow:global_step/sec: 370.982
INFO:tensorflow:loss = 0.4331399, step = 3100 (0.269 sec)
INFO:tensorflow:global_step/sec: 366.248
INFO:tensorflow:loss = 0.45120597, step = 3200 (0.273 sec)
INFO:tensorflow:global_step/sec: 371.703
INFO:tensorflow:loss = 0.4403404, step = 3300 (0.269 sec)
INFO:tensorflow:global_step/sec: 362.176
INFO:tensorflow:loss = 0.42405623, step = 3400 (0.276 sec)
INFO:tensorflow:global_step/sec: 363.283
INFO:tensorflow:loss = 0.41672814, step = 3500 (0.275 sec)
INFO:tensorflow:global_step/sec: 363.529
INFO:tensorflow:loss = 0.42626005, step = 3600 (0.275 sec)
INFO:tensorflow:global_step/sec: 367.348
INFO:tensorflow:loss = 0.4089098, step = 3700 (0.272 sec)
INFO:tensorflow:global_step/sec: 363.067
INFO:tensorflow:loss = 0.41276374, step = 3800 (0.275 sec)
INFO:tensorflow:global_step/sec: 364.771
INFO:tensorflow:loss = 0.4112524, step = 3900 (0.274 sec)
INFO:tensorflow:global_step/sec: 363.167
INFO:tensorflow:loss = 0.39261794, step = 4000 (0.275 sec)
INFO:tensorflow:global_step/sec: 362.082
INFO:tensorflow:loss = 0.41160905, step = 4100 (0.276 sec)
INFO:tensorflow:global_step/sec: 364.979
INFO:tensorflow:loss = 0.39620766, step = 4200 (0.274 sec)
INFO:tensorflow:global_step/sec: 363.323
INFO:tensorflow:loss = 0.39696264, step = 4300 (0.275 sec)
INFO:tensorflow:global_step/sec: 361.25
INFO:tensorflow:loss = 0.38196522, step = 4400 (0.277 sec)
INFO:tensorflow:global_step/sec: 365.666
INFO:tensorflow:loss = 0.38667366, step = 4500 (0.274 sec)
INFO:tensorflow:global_step/sec: 361.202
INFO:tensorflow:loss = 0.38149032, step = 4600 (0.277 sec)
INFO:tensorflow:global_step/sec: 365.038
INFO:tensorflow:loss = 0.37832782, step = 4700 (0.274 sec)
INFO:tensorflow:global_step/sec: 366.375
INFO:tensorflow:loss = 0.3726803, step = 4800 (0.273 sec)
INFO:tensorflow:global_step/sec: 366.474
INFO:tensorflow:loss = 0.37167495, step = 4900 (0.273 sec)
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 5000...
INFO:tensorflow:Saving checkpoints for 5000 into /tmp/tmpbhg2uvbr/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 5000...
INFO:tensorflow:Loss for final step: 0.36297452.

<tensorflow_estimator.python.estimator.canned.dnn.DNNClassifierV2 at 0x7fc9983ed470>

Beachten Sie, dass Sie Ihren Aufruf von input_fn in ein lambda input_fn , um die Argumente zu erfassen, während Sie eine Eingabefunktion bereitstellen, die keine Argumente input_fn , wie vom Schätzer erwartet. Die steps Argument sagt , die Methode zu stoppen Ausbildung nach einer Reihe von Trainingsschritten.

Bewerten Sie das trainierte Modell

Nachdem das Modell trainiert wurde, können Sie Statistiken über seine Leistung abrufen. Der folgende Codeblock bewertet die Genauigkeit des trainierten Modells anhand der Testdaten:

eval_result = classifier.evaluate(
    input_fn=lambda: input_fn(test, test_y, training=False))

print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**eval_result))
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Layer dnn is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because its dtype defaults to floatx.

If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.

To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.

INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2020-09-10T01:40:47Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpbhg2uvbr/model.ckpt-5000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Inference Time : 0.21153s
INFO:tensorflow:Finished evaluation at 2020-09-10-01:40:47
INFO:tensorflow:Saving dict for global step 5000: accuracy = 0.96666664, average_loss = 0.42594802, global_step = 5000, loss = 0.42594802
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 5000: /tmp/tmpbhg2uvbr/model.ckpt-5000

Test set accuracy: 0.967


Im Gegensatz zu dem Aufruf der train Methode bestanden hat Sie nicht die steps Argument zu bewerten. Die input_fn für eval liefert nur eine einzige Epoche von Daten.

Das eval_result Wörterbuch enthält auch den average_loss (mittlerer Verlust pro Stichprobe), den loss (mittlerer Verlust pro Mini-Batch) und den Wert des global_step des Schätzers (die Anzahl der durchgeführten Trainingsiterationen).

Vorhersagen treffen (ableiten) aus dem trainierten Modell

Sie haben jetzt ein geschultes Modell, das gute Bewertungsergebnisse liefert. Sie können jetzt das trainierte Modell verwenden, um die Art einer Irisblume anhand einiger unbeschrifteter Messungen vorherzusagen. Wie bei Training und Evaluierung machen Sie Vorhersagen mit einem einzigen Funktionsaufruf:

# Generate predictions from the model
expected = ['Setosa', 'Versicolor', 'Virginica']
predict_x = {
    'SepalLength': [5.1, 5.9, 6.9],
    'SepalWidth': [3.3, 3.0, 3.1],
    'PetalLength': [1.7, 4.2, 5.4],
    'PetalWidth': [0.5, 1.5, 2.1],
}

def input_fn(features, batch_size=256):
    """An input function for prediction."""
    # Convert the inputs to a Dataset without labels.
    return tf.data.Dataset.from_tensor_slices(dict(features)).batch(batch_size)

predictions = classifier.predict(
    input_fn=lambda: input_fn(predict_x))

Die predict gibt eine iterierbare Python-Datei zurück und liefert für jedes Beispiel ein Wörterbuch mit Vorhersageergebnissen. Der folgende Code gibt einige Vorhersagen und ihre Wahrscheinlichkeiten aus:

for pred_dict, expec in zip(predictions, expected):
    class_id = pred_dict['class_ids'][0]
    probability = pred_dict['probabilities'][class_id]

    print('Prediction is "{}" ({:.1f}%), expected "{}"'.format(
        SPECIES[class_id], 100 * probability, expec))
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpbhg2uvbr/model.ckpt-5000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Prediction is "Setosa" (91.3%), expected "Setosa"
Prediction is "Versicolor" (52.0%), expected "Versicolor"
Prediction is "Virginica" (63.5%), expected "Virginica"