J'ai essayé le Tutoriel officiel de TensorFlow Suite du Tutoriel TensorFlow 1er
tf.trainAPI TensorFlow fournit un optimiseur qui modifie lentement chaque variable pour minimiser la fonction de perte.
Les paramètres de l'optimiseur ressemblent à ceci.
>>>optimizer = tf.train.GradientDescentOptimizer(0.01)
>>>train = optimizer.minimize(loss)
Apprenons 1000 fois pour le moment.
>>>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]))
Ensuite, les paramètres finaux du modèle sont obtenus.
sortie d'impression
[array([-0.9999969], dtype=float32), array([ 0.99999082], dtype=float32)]
Code source qui résume ce qui a été fait dans l'interpréteur Ce que je fais est un simple problème de régression
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})
#Je veux voir le processus d'apprentissage, alors je l'ai ajouté
if i%100 == 0:
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})
print("%d fois 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))
Quand tu cours
0 fois W: [-0.21999997] b: [-0.456] loss: 4.01814
100 fois W: [-0.84270465] b: [ 0.53753263] loss: 0.14288
200 fois W: [-0.95284992] b: [ 0.86137295] loss: 0.0128382
300 fois W: [-0.98586655] b: [ 0.95844597] loss: 0.00115355
400 fois W: [-0.99576342] b: [ 0.98754394] loss: 0.000103651
500 fois W: [-0.99873012] b: [ 0.99626648] loss: 9.3124e-06
600 fois W: [-0.99961936] b: [ 0.99888098] loss: 8.36456e-07
700 fois W: [-0.99988592] b: [ 0.9996646] loss: 7.51492e-08
800 fois W: [-0.99996579] b: [ 0.99989945] loss: 6.75391e-09
900 fois W: [-0.99998969] b: [ 0.99996972] loss: 6.12733e-10
W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11
Vous pouvez voir que vous apprenez. Il n'y a presque aucune erreur après environ 300 fois.
tf.estimator
tf.estimator est une bibliothèque TensorFlow pour simplifier le mécanisme d'apprentissage automatique suivant.
--Exécution de la boucle de formation --Exécution de la boucle d'évaluation --Gestion des ensembles de données
Le programme de régression linéaire précédent est simplifié.
import tensorflow as tf
#NumPy est souvent utilisé pour charger, manipuler et prétraiter les données.
import numpy as np
#Déclarez une liste de fonctionnalités. Il n'y a qu'une seule fonction numérique. Il existe de nombreux autres types de colonnes qui sont plus complexes et utiles.
feature_columns = [tf.feature_column.numeric_column("x", shape=[1])]
#L'estimateur est le frontal pour invoquer la formation (ajustement) et l'évaluation (inférence). Il existe de nombreux types prédéfinis comme la régression linéaire, la classification linéaire, de nombreux classificateurs de réseaux neuronaux et des régressions. Le code suivant fournit un estimateur pour la régression linéaire.
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns)
#TensorFlow fournit de nombreuses méthodes d'assistance pour le chargement et la configuration des ensembles de données.
#Nous utiliserons deux ensembles de données, un pour la formation et un pour l'évaluation.
#Le nombre de lots de données que nous voulons (num_Vous devez indiquer les époques des fonctions) et la taille de chaque lot.
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)
#Vous pouvez appeler 1000 étapes d'entraînement en appelant cette méthode et en transmettant l'ensemble de données d'entraînement.
estimator.train(input_fn=input_fn, steps=1000)
#Évaluation du modèle
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)
production
train metrics: {'loss': 1.2712867e-09, 'global_step': 1000}
eval metrics: {'loss': 0.0025279333, 'global_step': 1000}
Comment utiliser l'estimateur lors de la création d'un modèle de réseau neuronal par vous-même
import numpy as np
import tensorflow as tf
#Si vous déclarez une liste de fonctionnalités, il n'y a qu'une seule fonctionnalité réelle
def model_fn(features, labels, mode):
#Construire un modèle linéaire et prédire des valeurs
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 connecte le sous-graphe créé à la fonction appropriée.
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)
production
train metrics: {'loss': 1.227995e-11, 'global_step': 1000}
eval metrics: {'loss': 0.01010036, 'global_step': 1000}
Recommended Posts