Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Gotowe estymatory

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub Pobierz notatnik

Ten samouczek pokazuje, jak rozwiązać problem klasyfikacji tęczówki w TensorFlow za pomocą estymatorów. Estymator to wysokopoziomowa reprezentacja pełnego modelu TensorFlow, która została zaprojektowana z myślą o łatwym skalowaniu i asynchronicznym trenowaniu. Aby uzyskać więcej informacji, zobacz Estymatory .

Należy zauważyć, że w TensorFlow 2.0 interfejs API Keras może wykonywać wiele takich samych zadań i uważa się, że jest łatwiejszy do nauczenia. Jeśli zaczynasz od nowa, zalecamy rozpoczęcie od Keras. Aby uzyskać więcej informacji na temat dostępnych interfejsów API wysokiego poziomu w TensorFlow 2.0, zobacz Standaryzacja w Keras .

Po pierwsze

Aby rozpocząć, najpierw zaimportujesz TensorFlow i pewną liczbę potrzebnych bibliotek.

 import tensorflow as tf

import pandas as pd
 

Zestaw danych

Przykładowy program w tym dokumencie buduje i testuje model, który dzieli kwiaty tęczówki na trzy różne gatunki na podstawie wielkości ich działek i płatków .

Będziesz trenować model przy użyciu zestawu danych Iris. Zestaw danych Iris zawiera cztery funkcje i jedną etykietę . Cztery cechy identyfikują następujące cechy botaniczne poszczególnych kwiatów tęczówki:

  • długość działki
  • szerokość działki
  • długość płatka
  • szerokość płatka

Na podstawie tych informacji możesz zdefiniować kilka pomocnych stałych do analizowania danych:

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

Następnie pobierz i przeanalizuj zestaw danych Iris za pomocą Keras i Pandas. Zwróć uwagę, że przechowujesz odrębne zestawy danych na potrzeby szkolenia i testowania.

 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)
 

Możesz sprawdzić swoje dane, aby zobaczyć, że masz cztery kolumny funkcji zmiennoprzecinkowych i jedną etykietę int32.

 train.head()
 

Dla każdego zestawu danych podziel etykiety, do przewidywania których model zostanie przeszkolony.

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

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

Omówienie programowania za pomocą estymatorów

Teraz, gdy masz już skonfigurowane dane, możesz zdefiniować model za pomocą TensorFlow Estimator. Estymator to dowolna klasa pochodna od tf.estimator.Estimator . TensorFlow udostępnia kolekcję tf.estimator (na przykład LinearRegressor ) do implementacji typowych algorytmów ML. Poza tym możesz napisać własne, niestandardowe Estymatory . Na początku zalecamy korzystanie z gotowych prognoz.

Aby napisać program TensorFlow w oparciu o gotowe estymatory, należy wykonać następujące czynności:

  • Utwórz jedną lub więcej funkcji wejściowych.
  • Zdefiniuj kolumny cech modelu.
  • Utwórz wystąpienie estymatora, określając kolumny funkcji i różne hiperparametry.
  • Wywołaj jedną lub więcej metod w obiekcie Estimator, przekazując odpowiednią funkcję wejściową jako źródło danych.

Zobaczmy, jak te zadania są realizowane w klasyfikacji Iris.

Utwórz funkcje wejściowe

Musisz utworzyć funkcje wejściowe, aby dostarczyć dane do uczenia, oceny i prognozowania.

Funkcja wejściowa to funkcja, która zwraca obiekt tf.data.Dataset który wyprowadza następującą dwuelementową krotkę:

  • features - Słownik Pythona, w którym:
    • Każdy klawisz to nazwa funkcji.
    • Każda wartość jest tablicą zawierającą wszystkie wartości tej funkcji.
  • label - tablica zawierająca wartości etykiety dla każdego przykładu.

Aby zademonstrować format funkcji wejściowej, oto prosta implementacja:

 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
 

Twoja funkcja wejściowa może w dowolny sposób wygenerować słownik features i listę label . Zalecamy jednak korzystanie z interfejsu API zestawu danych TensorFlow, który może analizować wszystkie rodzaje danych.

Interfejs API zestawu danych może obsłużyć wiele typowych przypadków. Na przykład za pomocą interfejsu API zestawu danych można łatwo odczytywać rekordy z dużej kolekcji plików równolegle i łączyć je w jeden strumień.

Aby uprościć sprawę w tym przykładzie, załadujesz dane za pomocą pand i utworzysz potok wejściowy z tych danych w pamięci:

 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)

 

Zdefiniuj kolumny funkcji

Kolumna cech to obiekt opisujący, w jaki sposób model powinien wykorzystywać surowe dane wejściowe ze słownika cech. Podczas tworzenia modelu estymatora przekazujesz mu listę kolumn funkcji, które opisują każdą z funkcji, których model ma używać. Moduł tf.feature_column zapewnia wiele opcji reprezentacji danych w modelu.

W przypadku Iris 4 surowe cechy są wartościami liczbowymi, więc utworzymy listę kolumn funkcji, aby powiedzieć modelowi Estimator, aby przedstawiał każdą z czterech cech jako 32-bitowe wartości zmiennoprzecinkowe. Dlatego kod do utworzenia kolumny funkcji to:

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

Kolumny funkcji mogą być znacznie bardziej wyrafinowane niż te, które tutaj pokazujemy. Więcej informacji na temat kolumn funkcji można znaleźć w tym przewodniku .

Teraz, gdy masz już opis tego, jak chcesz, aby model przedstawiał surowe cechy, możesz zbudować estymator.

Utwórz instancję estymatora

Problem tęczówki jest klasycznym problemem klasyfikacyjnym. Na szczęście TensorFlow udostępnia kilka gotowych estymatorów klasyfikatorów, w tym:

W przypadku problemu tf.estimator.DNNClassifier najlepszym wyborem wydaje się tf.estimator.DNNClassifier . Oto jak utworzyłeś ten Estimator:

 # 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/tmpmtyfr7jr
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpmtyfr7jr', '_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}

Trenuj, oceniaj i przewiduj

Teraz, gdy masz już obiekt Estimator, możesz wywołać metody, aby wykonać następujące czynności:

  • Wytrenuj model.
  • Oceń wytrenowany model.
  • Użyj wytrenowanego modelu do tworzenia prognoz.

Wytrenuj model

Wytrenuj model, wywołując metodę train estymatora w następujący sposób:

 # 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/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.
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 it's 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:106: 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/tmpmtyfr7jr/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.070166, step = 0
INFO:tensorflow:global_step/sec: 331.753
INFO:tensorflow:loss = 0.93704396, step = 100 (0.302 sec)
INFO:tensorflow:global_step/sec: 395.296
INFO:tensorflow:loss = 0.89240634, step = 200 (0.253 sec)
INFO:tensorflow:global_step/sec: 403.495
INFO:tensorflow:loss = 0.86647666, step = 300 (0.248 sec)
INFO:tensorflow:global_step/sec: 399.91
INFO:tensorflow:loss = 0.83915037, step = 400 (0.250 sec)
INFO:tensorflow:global_step/sec: 396.068
INFO:tensorflow:loss = 0.81960267, step = 500 (0.253 sec)
INFO:tensorflow:global_step/sec: 397.425
INFO:tensorflow:loss = 0.8010495, step = 600 (0.251 sec)
INFO:tensorflow:global_step/sec: 382.707
INFO:tensorflow:loss = 0.7765475, step = 700 (0.261 sec)
INFO:tensorflow:global_step/sec: 387.627
INFO:tensorflow:loss = 0.7703535, step = 800 (0.258 sec)
INFO:tensorflow:global_step/sec: 394.507
INFO:tensorflow:loss = 0.7543229, step = 900 (0.253 sec)
INFO:tensorflow:global_step/sec: 407.933
INFO:tensorflow:loss = 0.73848957, step = 1000 (0.245 sec)
INFO:tensorflow:global_step/sec: 402.228
INFO:tensorflow:loss = 0.72251606, step = 1100 (0.249 sec)
INFO:tensorflow:global_step/sec: 389.775
INFO:tensorflow:loss = 0.7172867, step = 1200 (0.256 sec)
INFO:tensorflow:global_step/sec: 399.683
INFO:tensorflow:loss = 0.71068585, step = 1300 (0.250 sec)
INFO:tensorflow:global_step/sec: 391.019
INFO:tensorflow:loss = 0.69202876, step = 1400 (0.256 sec)
INFO:tensorflow:global_step/sec: 389.996
INFO:tensorflow:loss = 0.68415767, step = 1500 (0.256 sec)
INFO:tensorflow:global_step/sec: 400.404
INFO:tensorflow:loss = 0.6856695, step = 1600 (0.250 sec)
INFO:tensorflow:global_step/sec: 392.96
INFO:tensorflow:loss = 0.66869813, step = 1700 (0.254 sec)
INFO:tensorflow:global_step/sec: 391.745
INFO:tensorflow:loss = 0.6558564, step = 1800 (0.255 sec)
INFO:tensorflow:global_step/sec: 404.816
INFO:tensorflow:loss = 0.6562849, step = 1900 (0.247 sec)
INFO:tensorflow:global_step/sec: 402.047
INFO:tensorflow:loss = 0.6460574, step = 2000 (0.249 sec)
INFO:tensorflow:global_step/sec: 398.388
INFO:tensorflow:loss = 0.63663703, step = 2100 (0.251 sec)
INFO:tensorflow:global_step/sec: 398.704
INFO:tensorflow:loss = 0.637564, step = 2200 (0.251 sec)
INFO:tensorflow:global_step/sec: 395.021
INFO:tensorflow:loss = 0.6212883, step = 2300 (0.253 sec)
INFO:tensorflow:global_step/sec: 402.692
INFO:tensorflow:loss = 0.61691123, step = 2400 (0.248 sec)
INFO:tensorflow:global_step/sec: 407.281
INFO:tensorflow:loss = 0.61063623, step = 2500 (0.245 sec)
INFO:tensorflow:global_step/sec: 400.64
INFO:tensorflow:loss = 0.6003194, step = 2600 (0.250 sec)
INFO:tensorflow:global_step/sec: 409.434
INFO:tensorflow:loss = 0.5979265, step = 2700 (0.244 sec)
INFO:tensorflow:global_step/sec: 409.898
INFO:tensorflow:loss = 0.5848124, step = 2800 (0.244 sec)
INFO:tensorflow:global_step/sec: 402.807
INFO:tensorflow:loss = 0.59079146, step = 2900 (0.248 sec)
INFO:tensorflow:global_step/sec: 425.34
INFO:tensorflow:loss = 0.5736993, step = 3000 (0.235 sec)
INFO:tensorflow:global_step/sec: 433.806
INFO:tensorflow:loss = 0.58517057, step = 3100 (0.231 sec)
INFO:tensorflow:global_step/sec: 434.689
INFO:tensorflow:loss = 0.58007574, step = 3200 (0.230 sec)
INFO:tensorflow:global_step/sec: 421.99
INFO:tensorflow:loss = 0.56112236, step = 3300 (0.237 sec)
INFO:tensorflow:global_step/sec: 417.524
INFO:tensorflow:loss = 0.5660492, step = 3400 (0.240 sec)
INFO:tensorflow:global_step/sec: 420.941
INFO:tensorflow:loss = 0.54761887, step = 3500 (0.238 sec)
INFO:tensorflow:global_step/sec: 407.277
INFO:tensorflow:loss = 0.546982, step = 3600 (0.245 sec)
INFO:tensorflow:global_step/sec: 405.199
INFO:tensorflow:loss = 0.5453528, step = 3700 (0.247 sec)
INFO:tensorflow:global_step/sec: 406.092
INFO:tensorflow:loss = 0.5401837, step = 3800 (0.246 sec)
INFO:tensorflow:global_step/sec: 416.753
INFO:tensorflow:loss = 0.53336906, step = 3900 (0.240 sec)
INFO:tensorflow:global_step/sec: 405.855
INFO:tensorflow:loss = 0.52575254, step = 4000 (0.246 sec)
INFO:tensorflow:global_step/sec: 421.175
INFO:tensorflow:loss = 0.5301929, step = 4100 (0.237 sec)
INFO:tensorflow:global_step/sec: 426.782
INFO:tensorflow:loss = 0.51990014, step = 4200 (0.234 sec)
INFO:tensorflow:global_step/sec: 419.357
INFO:tensorflow:loss = 0.50317734, step = 4300 (0.238 sec)
INFO:tensorflow:global_step/sec: 420.661
INFO:tensorflow:loss = 0.5168485, step = 4400 (0.238 sec)
INFO:tensorflow:global_step/sec: 431.962
INFO:tensorflow:loss = 0.5110451, step = 4500 (0.232 sec)
INFO:tensorflow:global_step/sec: 426.04
INFO:tensorflow:loss = 0.5175854, step = 4600 (0.235 sec)
INFO:tensorflow:global_step/sec: 424.821
INFO:tensorflow:loss = 0.4986134, step = 4700 (0.235 sec)
INFO:tensorflow:global_step/sec: 431.436
INFO:tensorflow:loss = 0.5033442, step = 4800 (0.232 sec)
INFO:tensorflow:global_step/sec: 422.301
INFO:tensorflow:loss = 0.50296384, step = 4900 (0.237 sec)
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 5000...
INFO:tensorflow:Saving checkpoints for 5000 into /tmp/tmpmtyfr7jr/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 5000...
INFO:tensorflow:Loss for final step: 0.49741185.

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

Zauważ, że owinąć swój input_fn połączenia w lambda do przechwytywania argumenty, zapewniając jednocześnie funkcję wejściową, która pobiera żadnych argumentów, zgodnie z oczekiwaniami, prognozy. Argument steps mówi metodzie, aby przerwała trenowanie po kilku krokach treningowych.

Oceń wytrenowany model

Teraz, gdy model został wytrenowany, możesz uzyskać statystyki dotyczące jego wydajności. Poniższy blok kodu ocenia dokładność wytrenowanego modelu na danych testowych:

 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 it's 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-07-23T01:36:17Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpmtyfr7jr/model.ckpt-5000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Inference Time : 0.21443s
INFO:tensorflow:Finished evaluation at 2020-07-23-01:36:17
INFO:tensorflow:Saving dict for global step 5000: accuracy = 0.53333336, average_loss = 0.5780506, global_step = 5000, loss = 0.5780506
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 5000: /tmp/tmpmtyfr7jr/model.ckpt-5000

Test set accuracy: 0.533


W przeciwieństwie do wywołania metody train nie przekazałeś argumentu steps do oceny. input_fn dla eval daje tylko jedną epokę danych.

eval_result Słownik zawiera również average_loss (średnia strata na próbkę), przy czym loss (średnia strata na mini-partii) oraz wartość estymatora za global_step (liczba iteracji szkolenia przeszedł).

Wykonywanie prognoz (wnioskowanie) na podstawie wytrenowanego modelu

Masz teraz wyszkolony model, który daje dobre wyniki oceny. Możesz teraz użyć wytrenowanego modelu, aby przewidzieć gatunek kwiatu tęczówki na podstawie niektórych nieoznakowanych pomiarów. Podobnie jak w przypadku szkolenia i oceny, tworzysz prognozy za pomocą pojedynczego wywołania funkcji:

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

Metoda predict zwraca iterowalną w Pythonie, co daje słownik wyników przewidywania dla każdego przykładu. Poniższy kod wypisuje kilka prognoz i ich prawdopodobieństw:

 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/tmpmtyfr7jr/model.ckpt-5000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Prediction is "Setosa" (73.1%), expected "Setosa"
Prediction is "Virginica" (48.9%), expected "Versicolor"
Prediction is "Virginica" (58.6%), expected "Virginica"