Ich habe [TensorFlow Official Tutorial] ausprobiert (https://www.tensorflow.org/get_started/get_started) Fortsetzung von TensorFlow Tutorial 1st
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)]
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.
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}
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