[PYTHON] Ich habe das 2. TensorFlow-Tutorial ausprobiert

Ich habe [TensorFlow Official Tutorial] ausprobiert (https://www.tensorflow.org/get_started/get_started) Fortsetzung von TensorFlow Tutorial 1st

Einführung in TensorFlow

tf.trainAPI TensorFlow bietet einen Optimierer, der jede Variable langsam ändert, um die Verlustfunktion zu minimieren.

Die Optimierungseinstellungen sehen folgendermaßen aus.

>>>optimizer = tf.train.GradientDescentOptimizer(0.01)
>>>train = optimizer.minimize(loss)

Lassen Sie uns vorerst 1000 Mal lernen.

>>>sess.run(init) # reset values to incorrect defaults.
>>>for i in range(1000):
>>>  sess.run(train, {x: [1, 2, 3, 4], y: [0, -1, -2, -3]})
>>>print(sess.run([W, b]))

Dann werden die endgültigen Modellparameter erhalten.

Druckausgabe


[array([-0.9999969], dtype=float32), array([ 0.99999082], dtype=float32)]

Komplettes Programm

Quellcode, der zusammenfasst, was im Interpreter getan wurde Was ich tue, ist ein einfaches Regressionsproblem

import tensorflow as tf

# Model parameters
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)

# loss
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

# training data
x_train = [1, 2, 3, 4]
y_train = [0, -1, -2, -3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x: x_train, y: y_train})
  
  #Ich möchte den Lernprozess sehen, also habe ich ihn hinzugefügt
  if i%100 == 0:
      curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
      print("%d mal W.: %s b: %s loss: %s"%(i,curr_W, curr_b, curr_loss))

# evaluate training accuracy
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

Wenn du rennst

0 mal W.: [-0.21999997] b: [-0.456] loss: 4.01814
100 mal W.: [-0.84270465] b: [ 0.53753263] loss: 0.14288
200 mal W.: [-0.95284992] b: [ 0.86137295] loss: 0.0128382
300 mal W.: [-0.98586655] b: [ 0.95844597] loss: 0.00115355
400 mal W.: [-0.99576342] b: [ 0.98754394] loss: 0.000103651
500 mal W.: [-0.99873012] b: [ 0.99626648] loss: 9.3124e-06

600 mal W.: [-0.99961936] b: [ 0.99888098] loss: 8.36456e-07
700 mal W.: [-0.99988592] b: [ 0.9996646] loss: 7.51492e-08
800 mal W.: [-0.99996579] b: [ 0.99989945] loss: 6.75391e-09
900 mal W.: [-0.99998969] b: [ 0.99996972] loss: 6.12733e-10
W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

Sie können sehen, dass Sie lernen. Nach etwa 300 Mal tritt fast kein Fehler auf.

tf.estimator tf.estimator ist eine TensorFlow-Bibliothek zur Vereinfachung des folgenden maschinellen Lernmechanismus.

Grundlegende Verwendung

Das bisherige lineare Regressionsprogramm wird vereinfacht.

import tensorflow as tf
#NumPy wird häufig zum Laden, Bearbeiten und Vorverarbeiten von Daten verwendet.
import numpy as np

#Deklarieren Sie eine Liste der Funktionen. Es gibt nur eine numerische Funktion. Es gibt viele andere Arten von Spalten, die komplexer und nützlicher sind.
feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]

#Der Schätzer ist das Frontend für das Aufrufen von Training (Anpassung) und Bewertung (Inferenz). Es gibt viele vordefinierte Typen wie lineare Regression, lineare Klassifikation, viele Klassifikatoren für neuronale Netze und Regressionen. Der folgende Code bietet einen Schätzer für die lineare Regression.
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)

#TensorFlow bietet viele Hilfsmethoden zum Laden und Konfigurieren von Datasets.
#Wir werden zwei Datensätze verwenden, einen für das Training und einen für die Auswertung.
#Die Anzahl der gewünschten Datenstapel (num_Epochen) und die Größe jeder Charge müssen der Funktion mitgeteilt werden.
x_train = np.array([1., 2., 3., 4.])
y_train = np.array([0., -1., -2., -3.])
x_eval = np.array([2., 5., 8., 1.])
y_eval = np.array([-1.01, -4.1, -7, 0.])
input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=4, num_epochs=None, shuffle=True)
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=4, num_epochs=1000, shuffle=False)
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_eval}, y_eval, batch_size=4, num_epochs=1000, shuffle=False)

#Sie können 1000 Trainingsschritte aufrufen, indem Sie diese Methode aufrufen und den Trainingsdatensatz übergeben.
estimator.train(input_fn=input_fn, steps=1000)

#Modellbewertung
train_metrics = estimator.evaluate(input_fn=train_input_fn)
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("train metrics: %r"% train_metrics)
print("eval metrics: %r"% eval_metrics)

Ausgabe

train metrics: {'loss': 1.2712867e-09, 'global_step': 1000}
eval metrics: {'loss': 0.0025279333, 'global_step': 1000}

Benutzerdefiniertes Modell

Verwendung des Schätzers beim Erstellen eines neuronalen Netzwerkmodells

import numpy as np
import tensorflow as tf

#Wenn Sie eine Liste von Funktionen deklarieren, gibt es nur eine tatsächliche Funktion
def model_fn(features, labels, mode):
  #Erstellen Sie ein lineares Modell und sagen Sie Werte voraus
  W = tf.get_variable("W", [1], dtype=tf.float64)
  b = tf.get_variable("b", [1], dtype=tf.float64)
  y = W * features['x'] + b
  # Loss sub-graph
  loss = tf.reduce_sum(tf.square(y - labels))
  # Training sub-graph
  global_step = tf.train.get_global_step()
  optimizer = tf.train.GradientDescentOptimizer(0.01)
  train = tf.group(optimizer.minimize(loss),
                   tf.assign_add(global_step, 1))
  #EstimatorSpec verbindet den erstellten Untergraphen mit der entsprechenden Funktion.
  return tf.estimator.EstimatorSpec(
      mode=mode,
      predictions=y,
      loss=loss,
      train_op=train)

estimator = tf.estimator.Estimator(model_fn=model_fn)
# define our data sets
x_train = np.array([1., 2., 3., 4.])
y_train = np.array([0., -1., -2., -3.])
x_eval = np.array([2., 5., 8., 1.])
y_eval = np.array([-1.01, -4.1, -7, 0.])
input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=4, num_epochs=None, shuffle=True)
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_train}, y_train, batch_size=4, num_epochs=1000, shuffle=False)
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    {"x": x_eval}, y_eval, batch_size=4, num_epochs=1000, shuffle=False)

# train
estimator.train(input_fn=input_fn, steps=1000)
# Here we evaluate how well our model did.
train_metrics = estimator.evaluate(input_fn=train_input_fn)
eval_metrics = estimator.evaluate(input_fn=eval_input_fn)
print("train metrics: %r"% train_metrics)
print("eval metrics: %r"% eval_metrics)

Ausgabe

train metrics: {'loss': 1.227995e-11, 'global_step': 1000}
eval metrics: {'loss': 0.01010036, 'global_step': 1000}

Recommended Posts

Ich habe das 2. TensorFlow-Tutorial ausprobiert
Ich habe das TensorFlow-Tutorial als erstes ausprobiert
TensorFlow Tutorial Ich habe MNIST 3rd ausprobiert
Ich habe das MNIST-Tutorial von tensorflow für Anfänger ausprobiert.
TensorFlow Tutorial Ich habe CNN 4th ausprobiert
Ich habe zum ersten Mal Tensorflow ausprobiert
Ich habe versucht, TensorFlow auszuführen
Ich habe versucht, das TensorFlow-Tutorial mit Kommentaren auszuführen (_TensorFlow_2_0_Einführung für Anfänger).
Ich habe die Changefinder-Bibliothek ausprobiert!
Ich habe versucht, Magenta / TensorFlow zu verwenden
Ich habe das TensorFlow-Tutorial mit Kommentaren ausgeführt (Textklassifizierung von Filmkritiken).
Ich habe versucht, den für TensorFlow geschriebenen Code nach Theano zu portieren
Ich habe versucht, mit TensorFlow den Durchschnitt mehrerer Spalten zu ermitteln
Ich habe versucht, das CNN-Modell von TensorFlow mit TF-Slim umzugestalten
Ich habe die neuartige API von Naruro ausprobiert
TensorFlow Tutorial Tutorial
Ich habe versucht, den Ball zu bewegen
Ich habe versucht, die checkio-API zu verwenden
Ich habe versucht, den Abschnitt zu schätzen.
[Für Anfänger] Ich habe versucht, die Tensorflow-Objekterkennungs-API zu verwenden
Ich habe den asynchronen Server von Django 3.0 ausprobiert
Ich habe versucht, Autoencoder mit TensorFlow zu implementieren
Ich habe versucht, den Befehl umask zusammenzufassen
Ich habe versucht, AutoEncoder mit TensorFlow zu visualisieren
Ich versuchte das Weckwort zu erkennen
Ich habe versucht, ○ ✕ mit TensorFlow zu spielen
Ich habe das OSS-Visualisierungstool superset ausprobiert
Ich habe versucht, Text mit TensorFlow zu klassifizieren
Ich habe versucht, die grafische Modellierung zusammenzufassen.
Ich habe versucht, das Umfangsverhältnis π probabilistisch abzuschätzen
Ich habe versucht, die COTOHA-API zu berühren
Python: Ich habe das Problem des Handlungsreisenden ausprobiert
Ich habe versucht, mit Pillow mit dem Bild zu spielen
Ich habe das Python Tornado Testing Framework ausprobiert
Ich habe versucht, die BigQuery-Speicher-API zu verwenden
Ich habe versucht, das Gesichtsbild mit sparse_image_warp von TensorFlow Addons zu transformieren
Ich habe versucht zu kratzen
Ich habe AutoKeras ausprobiert
Ich habe es mit Papiermühle versucht
Ich habe versucht, Django-Slack
Ich habe es mit Django versucht
Ich habe es mit Spleeter versucht
Ich habe es mit cgo versucht
Ich habe versucht, das Bild mit Python + OpenCV zu "glätten"
Ich habe Web Scraping versucht, um die Texte zu analysieren.
Ich habe die Pivot-Table-Funktion von Pandas ausprobiert
[Python] Ich habe versucht, den Funktionsnamen durch den Funktionsnamen zu ersetzen
Ich habe versucht, die Wetterkarte einer Clusteranalyse zu unterziehen
Ich habe versucht, die Qiita-API von Anfang an zu aktivieren
vprof - Ich habe versucht, den Profiler für Python zu verwenden
Ich habe versucht, das Bild mit Python + OpenCV zu "differenzieren"
Ich habe versucht, beim Trocknen der Wäsche zu optimieren
Ich habe versucht, die Daten mit Zwietracht zu speichern
Ich habe versucht, "Birthday Paradox" mit Python zu simulieren
Ich habe die Methode der kleinsten Quadrate in Python ausprobiert
Ich habe mit TensorFlow eine nicht negative Matrixzerlegung (NMF) versucht
Ich habe zuerst die SARS-Analyse vor dem Corona-Virus versucht
Ich habe versucht, die Google Cloud Vision-API zu verwenden
Ich habe zum ersten Mal versucht, Python zu programmieren.