Von der Estimator API zur TPUEstimator API migrieren

In dieser Anleitung wird beschrieben, wie Sie ein Modellprogramm mit der Estimator API in ein Programm mit der TPUEstimator API umwandeln. Hinweis: Einige der in diesem Dokument verlinkten Inhalte sind nur auf Englisch verfügbar.

Warnung: Die TPUEstimator API wird nur mit Tensorflow 1.x unterstützt. Wenn Sie Ihr Modell mit Tensorflow 2.x schreiben, verwenden Sie stattdessen Keras.

Überblick

Modellprogramme, die die TPUEstimator API verwenden, können die Tensor Processing Units (TPUs) voll ausnutzen, bleiben jedoch mit CPUs und GPUs kompatibel.

Nachdem Sie diese Anleitung beendet haben, wissen Sie:

  • wie Sie Ihren Code von der Verwendung der Estimator API in die TPUEstimator API konvertieren.
  • Wie Sie Vorhersagen auf Cloud TPU ausführen

Hinweis

Bevor Sie mit dieser Anleitung beginnen, prüfen Sie, ob Ihr Google Cloud-Projekt ordnungsgemäß eingerichtet ist.

In dieser Anleitung werden kostenpflichtige Komponenten der Google Cloud verwendet. Rufen Sie die Seite mit den Cloud TPU-Preisen auf, um Ihre Kosten abzuschätzen. Denken Sie daran, nicht mehr benötigte Ressourcen zu bereinigen, um unnötige Kosten zu vermeiden.

Ressourcen einrichten

Dieser Abschnitt enthält Informationen zum Einrichten von Cloud Storage-Speicher-, VM- und Cloud TPU-Ressourcen für Anleitungen.

Cloud Storage-Bucket erstellen

Zum Speichern der Daten, die Sie zum Trainieren Ihres Modells verwenden, und zum Speichern der Trainingsergebnisse benötigen Sie einen Cloud Storage-Bucket. Der in dieser Anleitung verwendete Befehl gcloud richtet Standardberechtigungen für das Cloud TPU-Dienstkonto ein. Wenn Sie weitere Berechtigungen benötigen, können Sie die Berechtigungen auf Zugriffsebene anpassen.

Der Bucket-Speicherort muss sich in derselben Region wie die virtuelle Maschine (VM) und der TPU-Knoten befinden. VMs und TPU-Knoten befinden sich in bestimmten Zonen, die Untergruppen innerhalb einer Region sind.

  1. Rufen Sie in der Google Cloud Console die Seite „Cloud Storage“ auf.

    Zur Cloud Storage-Seite

  2. Erstellen Sie durch die Angabe der folgenden Optionen einen neuen Bucket:

    • Eindeutiger Name Ihrer Wahl
    • Wählen Sie Region als Standorttyp und us-central1 als Speicherort (Zone) aus.
    • Standard-Speicherklasse: Standard
    • Speicherort: Geben Sie einen Bucket-Speicherort in derselben Region an, in der Sie den TPU-Knoten erstellen möchten. Welche TPU-Typen in welchen Zonen verfügbar sind, erfahren Sie unter TPU-Typen und Zonen.

TPU und VM erstellen

TPU-Ressourcen bestehen aus einer virtuellen Maschine (VM) und einer Cloud TPU, die denselben Namen haben. Diese Ressourcen müssen sich in derselben Region/Zone wie der gerade erstellte Bucket befinden.

Sie können die VM und die TPU-Ressourcen mit gcloud-Befehlen oder über die Cloud Console einrichten. Weitere Informationen zum Verwalten von TPU-Ressourcen finden Sie unter TPUs erstellen und löschen.

  1. Öffnen Sie ein Cloud Shell-Fenster.

    Cloud Shell öffnen

  2. Konfigurieren Sie gcloud so, dass es Ihr Projekt verwendet. 

    $ gcloud config set project your-project
    Projekt, in dem Sie eine Cloud TPU erstellen möchten.

  3. Starten Sie mit dem Befehl gcloud eine Compute Engine-VM und eine Cloud TPU.

    $ gcloud compute tpus execution-groups create \
 --name=tpu-name \
 --zone=europe-west4-a \
 --tf-version=2.12.0 \
 --machine-type=n1-standard-1 \
 --accelerator-type=v3-8

    Beschreibung der Befehls-Flags

    name
    Der Name der zu erstellenden Cloud TPU.
    zone
    Die Zone, in der Sie die Cloud TPU erstellen möchten.
    tf-version
    Die Version von Tensorflow, die der Befehl gcloud auf Ihrer VM installiert.
    machine-type
    Der Maschinentyp der zu erstellenden Compute Engine-VM.
    accelerator-type
    Der Typ der zu erstellenden Cloud TPU.

    Weitere Informationen zum Befehl gcloud finden Sie in der gcloud-Referenz.

  4. Wenn der Befehl gcloud compute tpus execution-groups ausgeführt wurde, sollten Sie prüfen, ob die Shell-Eingabeaufforderung von username@projectname zu username@vm-name geändert wurde. Diese Änderung bedeutet, dass Sie jetzt bei Ihrer Compute Engine-VM angemeldet sind.

    gcloud compute ssh tpu-name --zone=europe-west4-a

Führen Sie im weiteren Verlauf dieser Anleitung jeden Befehl, der mit (vm)$ beginnt, in Ihrem VM-Sitzungsfenster aus.

pandas installieren

Installieren oder aktualisieren Sie pandas mit dem folgenden Befehl:

pip install pandas

Hyperparameter definieren

In diesem Codeabschnitt fügen Sie mehrere von TPUs benötigte Hyperparameter hinzu. Sie fügen diese Hyperparameter als Flags Ihrem Trainingsskript hinzu, sodass Sie sie zur Laufzeit ändern können.

Die hinzuzufügenden Parameter sind:

  • tpu. Dieser Parameter gibt den Namen oder die IP-Adresse des TPU-Knotens an, auf dem das Modell ausgeführt werden soll.
  • model_dir. Der Pfad zum Speichern von Modellprüfpunkten. Dieser Pfad muss ein Cloud Storage-Bucket sein.
  • iterations. Die Anzahl der Iterationen pro Trainingsschleife.
  • use_tpu. Gibt an, ob Sie das Modell abhängig von der Verfügbarkeit auf TPUs oder GPU/CPUs ausführen möchten.

Estimator API

# Model specific parameters
tf.flags.DEFINE_integer("batch_size",
    default=50,
    help="Batch size.")
tf.flags.DEFINE_integer("train_steps",
    default=1000,
    help="Total number of training steps.")
FLAGS = tf.flags.FLAGS

TPUEstimator API

# Cloud TPU Cluster Resolver flags
tf.flags.DEFINE_string(
    "tpu", default=None,
    help="The Cloud TPU to use for training. This should be the name used when "
    "creating the Cloud TPU. To find out the name of TPU, either use command "
    "'gcloud compute tpus list --zone=<zone-name>', or use "
    "'ctpu status --details' if you have created your Cloud TPU using 'ctpu up'.")

# Model specific parameters
tf.flags.DEFINE_string(
    "model_dir", default="",
    help="This should be the path of storage bucket which will be used as "
    "model_directory to export the checkpoints during training.")
tf.flags.DEFINE_integer(
    "batch_size", default=128,
    help="This is the global batch size and not the per-shard batch.")
tf.flags.DEFINE_integer(
    "train_steps", default=1000,
    help="Total number of training steps.")
tf.flags.DEFINE_integer(
    "eval_steps", default=4,
    help="Total number of evaluation steps. If `0`, evaluation "
    "after training is skipped.")

# TPU specific parameters.
tf.flags.DEFINE_bool(
    "use_tpu", default=True,
    help="True, if want to run the model on TPU. False, otherwise.")
tf.flags.DEFINE_integer(
    "iterations", default=500,
    help="Number of iterations per TPU training loop.")

Daten laden

In diesem Codeabschnitt wird angegeben, wie die Daten gelesen und geladen werden.

TPUs unterstützen die folgenden Datentypen:

  • tf.float32
  • tf.complex64
  • tf.int64
  • tf.bool
  • tf.bfloat64

Estimator API

def load_data(y_name='Species'):
  """Returns the iris dataset as (train_x, train_y), (test_x, test_y)."""
  train_path, test_path = maybe_download()

  train = pd.read_csv(train_path, names=CSV_COLUMN_NAMES, header=0)
  train_x, train_y = train, train.pop(y_name)

  test = pd.read_csv(test_path, names=CSV_COLUMN_NAMES, header=0)
  test_x, test_y = test, test.pop(y_name)

  return (train_x, train_y), (test_x, test_y)

TPUEstimator API

def load_data(y_name='Species'):
  """Returns the iris dataset as (train_x, train_y), (test_x, test_y)."""
  train_path, test_path = maybe_download()

  train = pd.read_csv(train_path, names=CSV_COLUMN_NAMES, header=0,
                      dtype={'SepalLength': pd.np.float32,
                             'SepalWidth': pd.np.float32,
                             'PetalLength': pd.np.float32,
                             'PetalWidth': pd.np.float32,
                             'Species': pd.np.int32})
  train_x, train_y = train, train.pop(y_name)

  test = pd.read_csv(test_path, names=CSV_COLUMN_NAMES, header=0,
                     dtype={'SepalLength': pd.np.float32,
                            'SepalWidth': pd.np.float32,
                            'PetalLength': pd.np.float32,
                            'PetalWidth': pd.np.float32,
                            'Species': pd.np.int32})
  test_x, test_y = test, test.pop(y_name)

  return (train_x, train_y), (test_x, test_y)

Eingabefunktionen definieren

Ein wesentlicher Unterschied zwischen der Estimator API und der TPUEstimator API ist die Funktionssignatur der Eingabefunktionen. Bei der Estimator API können Sie Eingabefunktionen mit einer beliebigen Anzahl von Parametern schreiben. Bei der TPUEstimator API können Eingabefunktionen nur den Parameter params aufnehmen. params enthält alle Schlüssel/Wert-Paare aus dem TPUEstimator-Objekt sowie zusätzliche Schlüssel wie batch_size.

Eine Möglichkeit, mit diesem Unterschied umzugehen, ist die Verwendung von Lambda-Funktionen beim Aufrufen der Eingabefunktionen. Bei Lambda-Funktionen sind nur geringfügige Änderungen an Ihren vorhandenen Eingabefunktionen erforderlich.

In den folgenden Abschnitten wird beschrieben, wie Sie Ihre Eingabefunktionen aktualisieren. Später werden Sie sehen, wie Sie mit Lambda-Funktionen diese Eingabefunktionen konvertieren, damit sie mit der TPUEstimator API funktionieren.

Trainingseingabefunktion

Bei der TPUEstimator API muss die Trainingseingabefunktion train_input_fn eine Anzahl von Eingabesamples zurückgeben, die nach der Anzahl der Cloud TPU-Kerne aufgeteilt werden können. Wenn Sie beispielsweise 8 Kerne verwenden, muss jede Batchgröße durch 8 teilbar sein.

Damit das funktioniert, verwendet der vorstehende Code die Funktion dataset.batch(batch_size, drop_remainder=True). Diese erstellt Batches gemäß dem Parameter batch_size und verwirft den Rest.

Estimator API

def train_input_fn(features, labels, batch_size):
  """An input function for training"""

  # Convert the inputs to a Dataset.
  dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels))

  # Shuffle, repeat, and batch the examples.
  dataset = dataset.shuffle(1000).repeat().batch(batch_size)

  # Return the dataset.
  return dataset

TPUEstimator API

def train_input_fn(features, labels, batch_size):
  """An input function for training."""

  # Convert the inputs to a Dataset.
  dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels))

  # Shuffle, repeat, and batch the examples.
  dataset = dataset.shuffle(1000).repeat()

  dataset = dataset.batch(batch_size, drop_remainder=True)

  # Return the dataset.
  return dataset

Bewertungseingabefunktion

In diesem Schritt aktualisieren Sie die Bewertungseingabefunktion eval_input_fn, damit die Eingabesamples nach der Anzahl der TPU-Kerne aufgeteilt werden können. Verwenden Sie dazu die Funktion dataset.batch(batch_size, drop_remainder=True).

Estimator API

def eval_input_fn(features, labels, batch_size):
  """An input function for evaluation or prediction"""
  features=dict(features)
  if labels is None:
      # No labels, use only features.
      inputs = features
  else:
      inputs = (features, labels)

  # Convert the inputs to a Dataset.
  dataset = tf.data.Dataset.from_tensor_slices(inputs)

  # Batch the examples
  assert batch_size is not None, "batch_size must not be None"
  dataset = dataset.batch(batch_size)

  # Return the dataset.
  return dataset

TPUEstimator API

 def eval_input_fn(features, labels, batch_size):
    """An input function for evaluation."""
    features = dict(features)
    inputs = (features, labels)

    # Convert the inputs to a Dataset.
    dataset = tf.data.Dataset.from_tensor_slices(inputs)
    dataset = dataset.shuffle(1000).repeat()

    dataset = dataset.batch(batch_size, drop_remainder=True)

    # Return the dataset.
    return dataset

Vorhersageeingabefunktion

Für Vorhersagen in TPUEstimators muss das Eingabe-Dataset Tensoren mit der zusätzlichen äußeren Dimension von batch_size haben. Deshalb ist es erforderlich, dass Sie eine Vorhersageeingabefunktion mit den Parametern features und batch_size hinzufügen. Bei dieser Funktion können Sie weniger Eingabesamples als batch_size verwenden.

Eine Vorhersageeingabefunktion ist optional, wenn Sie die Estimator API verwenden.

Estimator API

Eine Vorhersageeingabefunktion ist für die Estimator API optional, da die Bewertungsfunktion eval_input_fn diese Aufgabe ausführt.

TPUEstimator API

  def predict_input_fn(features, batch_size):
    """An input function for prediction."""

    dataset = tf.data.Dataset.from_tensor_slices(features)
    dataset = dataset.batch(batch_size)
    return dataset

Benutzerdefinierte Modellfunktionen aktualisieren

Als Nächstes müssen Sie die benutzerdefinierte Modellfunktion aktualisieren:

  • Ersetzen Sie Instanzen von tf.estimator.EstimatorSpec, um tf.contrib.tpu.TPUEstimatorSpec zu verwenden.
  • Entfernen Sie alle Instanzen von tf.summary. Die TPUEstimator API unterstützt keine benutzerdefinierten Zusammenfassungen für TensorBoard. Grundlegende Zusammenfassungen werden jedoch automatisch in Ereignisdateien im Modellverzeichnis aufgezeichnet.
  • Verpacken Sie das Optimierungstool mit tf.contrib.tpu.CrossShardOptimizer. Der CrossShardOptimizer verwendet allreduce, um Gradienten zusammenzufassen und das Ergebnis an jeden Shard zu senden. Da der CrossShardOptimizer nicht mit dem lokalen Training kompatibel ist, müssen Sie auch das Flag use_tpu prüfen.

Estimator API

def my_model(features, labels, mode, params):
  """DNN with three hidden layers, and dropout of 0.1 probability."""

  # Create three fully connected layers each layer having a dropout
  # probability of 0.1.
  net = tf.feature_column.input_layer(features, params['feature_columns'])
  for units in params['hidden_units']:
      net = tf.layers.dense(net, units=units, activation=tf.nn.relu)

  # Compute logits (1 per class).
  logits = tf.layers.dense(net, params['n_classes'], activation=None)

  # Compute predictions.
  predicted_classes = tf.argmax(logits, 1)
  if mode == tf.estimator.ModeKeys.PREDICT:
      predictions = {
          'class_ids': predicted_classes[:, tf.newaxis],
          'probabilities': tf.nn.softmax(logits),
          'logits': logits,
      }
      return tf.estimator.EstimatorSpec(mode, predictions=predictions)

  # Compute loss.
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels,
                                                logits=logits)

  # Compute evaluation metrics.
  accuracy = tf.metrics.accuracy(labels=labels,
                                 predictions=predicted_classes,
                                 name='acc_op')
  metrics = {'accuracy': accuracy}
  tf.summary.scalar('accuracy', accuracy[1])
  if mode == tf.estimator.ModeKeys.EVAL:
      return tf.estimator.EstimatorSpec(
          mode, loss=loss, eval_metric_ops=metrics)

  # Create training op.
  if mode == tf.estimator.ModeKeys.TRAIN
      optimizer = tf.train.AdagradOptimizer(learning_rate=0.1)
      train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())
      return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)

TPUEstimator API

def my_model(features, labels, mode, params):
  """Deep Neural Network(DNN) model.

  This is a DNN Model with 3 hidden layers. First 2 hidden layers are having
  10 neurons in each. And number of neurons in the last layer is equal to the
  number of output classes. This is a densely connected network where each
  neuron of previous layer is connected to each neuron of next layer.

  Args:
    features: Feature values for input samples.
    labels: label/class assigned to the corresponding input sample.
    mode: "TRAIN"/"EVAL"/"PREDICT"
    params: Dictionary used to pass extra parameters to model function from
      the main function.

  Returns:
    TPUEstimatorSpec object.

  """

  # Create three fully connected layers.
  net = tf.feature_column.input_layer(features, params["feature_columns"])
  for units in params["hidden_units"]:
    net = tf.layers.dense(net, units=units, activation=tf.nn.relu)

  # Compute logits (1 per class).
  logits = tf.layers.dense(net, params["n_classes"], activation=None)

  # Compute predictions.
  predicted_classes = tf.argmax(logits, 1)
  if mode == tf.estimator.ModeKeys.PREDICT:
    predictions = {
        "class_ids": predicted_classes[:, tf.newaxis],
        "probabilities": tf.nn.softmax(logits),
        "logits": logits,
    }
    return tf.contrib.tpu.TPUEstimatorSpec(mode, predictions=predictions)

  # Compute loss.
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels,
                                                logits=logits)

  if mode == tf.estimator.ModeKeys.EVAL:
    return tf.contrib.tpu.TPUEstimatorSpec(
        mode=mode, loss=loss, eval_metrics=(metric_fn, [labels, logits]))

  # Create training op.
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.AdagradOptimizer(learning_rate=0.1)
    if FLAGS.use_tpu:
      optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer)
    train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())
    return tf.contrib.tpu.TPUEstimatorSpec(mode, loss=loss, train_op=train_op)

Bewertungsmesswertfunktion hinzufügen

Ein weiterer Unterschied zwischen der Estimator API und der TPUEstimator API besteht darin, wie sie mit Metriken umgehen. Mit der Estimator API können Sie Metriken als normales Wörterbuch übergeben. Für die TPUEstimator API müssen Sie stattdessen eine Funktion verwenden.

Estimator API

Optional. Die Funktion my_model generiert die Messwerte.

TPUEstimator API

  def metric_fn(labels, logits):
    """Function to return metrics for evaluation."""

    predicted_classes = tf.argmax(logits, 1)
    accuracy = tf.metrics.accuracy(labels=labels,
                                   predictions=predicted_classes,
                                   name="acc_op")
    return {"accuracy": accuracy}

Hauptfunktion aktualisieren

TPUs konfigurieren

In diesem Schritt konfigurieren Sie den TPU-Cluster.

Mit den den Hyperparametern zugewiesenen Werten können Sie den Cluster konfigurieren. Weitere Informationen finden Sie unter Hyperparameter definieren. Legen Sie außerdem die folgenden Werte fest:

  • allow_soft_placement: Wenn dieser Parameter auf "true" gesetzt ist, kann TensorFlow ein GPU-Gerät verwenden, wenn keine TPU verfügbar ist. Wenn ein GPU-Gerät ebenfalls nicht verfügbar ist, wird ein CPU-Gerät verwendet.
  • log_device_placement: Dieser Parameter gibt an, dass TensorFlow Geräteplatzierungen protokollieren soll.

Estimator API

Nicht erforderlich, da dieser Codeabschnitt nur TPUs betrifft.

TPUEstimator API

# Resolve TPU cluster and runconfig for this.
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
    FLAGS.tpu)

run_config = tf.contrib.tpu.RunConfig(
    model_dir=FLAGS.model_dir,
    cluster=tpu_cluster_resolver,
    session_config=tf.ConfigProto(
        allow_soft_placement=True, log_device_placement=True),
    tpu_config=tf.contrib.tpu.TPUConfig(FLAGS.iterations),
)

Dem Klassifizierer TPU-spezifische Parameter hinzufügen

In diesem Abschnitt des Codes aktualisieren Sie die Klassifizierervariable für die Verwendung der TPUEstimator-Klasse. Fügen Sie für diese Änderungen die folgenden Parameter hinzu:

  • use_tpu
  • train_batch_size
  • eval_batch_size
  • predict_batch_size
  • config

Estimator API

  # Build 2 hidden layer DNN with 10, 10 units respectively.
  classifier = tf.estimator.Estimator(
      model_fn=my_model,
      params={
          'feature_columns': my_feature_columns,
          # Two hidden layers of 10 nodes each.
          'hidden_units': [10, 10],
          # The model must choose between 3 classes.
          'n_classes': 3,
      })

TPUEstimator API

  # Build 2 hidden layer DNN with 10, 10 units respectively.
  classifier = tf.contrib.tpu.TPUEstimator(
      model_fn=my_model,
      use_tpu=FLAGS.use_tpu,
      train_batch_size=FLAGS.batch_size,
      eval_batch_size=FLAGS.batch_size,
      predict_batch_size=FLAGS.batch_size,
      config=run_config,
      params={
          # Name of the feature columns in the input data.
          "feature_columns": my_feature_columns,
          # Two hidden layers of 10 nodes each.
          "hidden_units": [10, 10],
          # The model must choose between 3 classes.
          "n_classes": 3,
          "use_tpu": FLAGS.use_tpu,
      })

Trainingsmethode anrufen

Die nächste Änderung ist die Aktualisierung der Trainingsmethode. Zum Aufrufen der Funktion train_input_fn wird eine Lambda-Funktion verwendet. Diese Methode erleichtert die Verwendung Ihrer vorhandenen Funktionen mit der TPUEstimator API.

Ändern Sie außerdem den Parameter "steps" in max_steps. Im nächsten Abschnitt verwenden Sie den Parameter "steps" noch einmal, um die Anzahl der Bewertungsschritte anzugeben.

Estimator API

  # Train the Model.
  classifier.train(
      input_fn=lambda:iris_data.train_input_fn(
          train_x, train_y, FLAGS.batch_size),
      steps=FLAGS.train_steps)

TPUEstimator API

  # Train the Model.
  classifier.train(
      input_fn=lambda params: iris_data.train_input_fn(
          train_x, train_y, params["batch_size"]),
      max_steps=FLAGS.train_steps)

Bewertungsmethode aufrufen

Diese Änderung ähnelt der, die Sie an der Trainingsmethode vorgenommen haben. Die Verwendung einer Lambda-Funktion erleichtert wiederum die Verwendung einer vorhandenen Bewertungseingabefunktion.

Darüber hinaus müssen Sie den Parameter steps in den Wert ändern, der über das Befehlszeilen-Flag eval_steps festgelegt wurde.

Estimator API

  # Evaluate the model.
  eval_result = classifier.evaluate(
      input_fn=lambda:iris_data.eval_input_fn(
          test_x, test_y, FLAGS.batch_size))

  print('\nTest set accuracy: {accuracy:0.3f}\n'.format(**eval_result))

TPUEstimator API

  # Evaluate the model.
  eval_result = classifier.evaluate(
      input_fn=lambda params: iris_data.eval_input_fn(
          test_x, test_y, params["batch_size"]),
      steps=FLAGS.eval_steps)

Vorhersagemethode aufrufen

Wie auch bei Schulungs- und Bewertungsmethoden müssen Sie die Vorhersagemethode aktualisieren. Die Verwendung einer Lambda-Funktion erleichtert wiederum die Verwendung einer vorhandenen Auswertungseingabefunktion.

Estimator API

  # Generate predictions from the model
  predictions = classifier.predict(
      input_fn=lambda: iris_data.eval_input_fn(
          iris_data.PREDICTION_INPUT_DATA,
          labels=None,
          batch_size=FLAGS.batch_size))

  for pred_dict, expec in zip(predictions, iris_data.PREDICTION_OUTPUT_DATA):
      template = ('\nPrediction is "{}" ({:.1f}%), expected "{}"')

      class_id = pred_dict['class_ids'][0]
      probability = pred_dict['probabilities'][class_id]

      print(template.format(iris_data.SPECIES[class_id],
                            100 * probability, expec))

TPUEstimator API

  # Generate predictions from the model
  predictions = classifier.predict(
      input_fn=lambda params: iris_data.predict_input_fn(
          iris_data.PREDICTION_INPUT_DATA, params["batch_size"]))

  for pred_dict, expec in zip(predictions, iris_data.PREDICTION_OUTPUT_DATA):
    template = ("\nPrediction is \"{}\" ({:.1f}%), expected \"{}\"")

    class_id = pred_dict["class_ids"][0]
    probability = pred_dict["probabilities"][class_id]

    print(template.format(iris_data.SPECIES[class_id],
                          100 * probability, expec))

Bereinigen

So vermeiden Sie, dass Ihrem GCP-Konto die in diesem Thema verwendeten Ressourcen in Rechnung gestellt werden:

  1. Trennen Sie die Verbindung zur Compute Engine-VM:

    (vm)$ exit

    Die Eingabeaufforderung sollte nun username@projectname lauten, womit angezeigt wird, dass Sie sich in Cloud Shell befinden.

  2. Führen Sie in Cloud Shell den Befehl ctpu delete mit dem Flag "--zone" aus, das Sie auch beim Einrichten der Cloud TPU angegeben haben, um die Compute Engine-VM und die Cloud TPU zu löschen:

    $ ctpu delete [optional: --zone]

  3. Führen Sie ctpu status aus, um zu bestätigen, dass keine Instanzen zugeordnet wurden. So vermeiden Sie unnötige Gebühren für die TPU-Nutzung. Der Löschvorgang kann einige Minuten dauern. Eine Antwort wie die folgende gibt an, dass keine weiteren Instanzen vorhanden sind:

    $ ctpu status --zone=europe-west4-a

    2018/04/28 16:16:23 WARNING: Setting zone to "--zone=europe-west4-a"
No instances currently exist.
    Compute Engine VM:     --
    Cloud TPU:             --

  4. Führen Sie gsutil wie angegeben aus und ersetzen Sie bucket-name durch den Namen des Cloud Storage-Buckets, den Sie für diese Anleitung erstellt haben:

    $ gsutil rm -r gs://bucket-name

Weitere Informationen

Mehr über die Estimator- und TPUEstimator APIs finden Sie in den folgenden Themen: