自定义训练的演示，使用tf-data,Eager Execution和keras

1，机器学习的基本步骤

• Import and parse the data sets.
• Select the type of model.
• Train the model.
• Evaluate the model's effectiveness.
• Use the trained model to make predictions

2，eager mode的使用限制

Once eager execution is enabled, it cannot be disabled within the same program

3，tf_data_dataset

TensorFlow's Dataset API handles many common cases for loading data into a model

The default behavior is to shuffle the data (shuffle=True, shuffle_buffer_size=10000), and repeat the dataset forever (num_epochs=None)

batch_size = 32

# tf.data.experimental.make_csv_dataset

返回dataset的标准格式：The make_csv_dataset function returns a tf.data.Dataset of (features, label) pairs, where features is a dictionary: {'feature_name': value}

train_dataset = tf.contrib.data.make_csv_dataset(

train_dataset_fp,

batch_size,

column_names=column_names,

label_name=label_name,

num_epochs=1)

4，遍历一下

next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator
features, labels = next(iter(train_dataset))
features.get("sepal_length")

5，如何堆叠column即分列的feature的值为整行

def pack_features_vector(features, labels):

"""Pack the features into a single array."""

features = tf.stack(list(features.values()), axis=1)

return features, labels

6，

train_dataset = train_dataset.map(pack_features_vector)

for a,b in train_dataset:

print(a,b)

7，如何理解tf.data.Dataset.map()

7.1，定义

• map(

• map_func,

• num_parallel_calls=None

• )

7.2，例子

# NOTE: The following examples use `{ ... }` to represent the

# contents of a dataset.

a = { 1, 2, 3, 4, 5 }

a.map(lambda x: x + 1) = { 2, 3, 4, 5, 6 }

7.3，解释

This transformation applies map_func to each element of this dataset, and returns a new dataset containing the transformed elements, in the same order as they appeared in the input.

• import tensorflow as tf

• def fun(x):

• return x +1

• ds = tf.data.Dataset.range(5)

• ds = ds.map(fun)

8，选择model

model = tf.keras.Sequential([

tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)), # input shape required

tf.keras.layers.Dense(10, activation=tf.nn.relu),

tf.keras.layers.Dense(3)

])

predictions = model(features)

predictions[:5]

tf.nn.softmax(predictions[:5])

print("Prediction: {}".format(tf.argmax(predictions, axis=1)))

print(" Labels: {}".format(labels))

9，训练

9.1，确定损失函数

def loss(model, x, y):

y_ = model(x)

return tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_)

l = loss(model, features, labels)

print("Loss test: {}".format(l))

9.2，计算梯度

def grad(model, inputs, targets):

with tf.GradientTape() as tape:

loss_value = loss(model, inputs, targets)

return loss_value, tape.gradient(loss_value, model.trainable_variables)

9.3，优化器

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

global_step = tf.Variable(0)

loss_value, grads = grad(model, features, labels)

print("Step: {}, Initial Loss: {}".format(global_step.numpy(),

loss_value.numpy()))

optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step)

print("Step: {}, Loss: {}".format(global_step.numpy(),

loss(model, features, labels).numpy()))

10，迭代训练

## Note: Rerunning this cell uses the same model variables

from tensorflow import contrib

tfe = contrib.eager

# keep results for plotting

train_loss_results = []

train_accuracy_results = []

num_epochs = 201

for epoch in range(num_epochs):

epoch_loss_avg = tfe.metrics.Mean()

epoch_accuracy = tfe.metrics.Accuracy()

# Training loop - using batches of 32

for x, y in train_dataset:

# Optimize the model

loss_value, grads = grad(model, x, y)

optimizer.apply_gradients(zip(grads, model.trainable_variables),

global_step)

# Track progress

epoch_loss_avg(loss_value) # add current batch loss

# compare predicted label to actual label

epoch_accuracy(tf.argmax(model(x), axis=1, output_type=tf.int32), y)

# end epoch

train_loss_results.append(epoch_loss_avg.result())

train_accuracy_results.append(epoch_accuracy.result())

if epoch % 50 == 0:

print("Epoch {:03d}: Loss: {:.3f}, Accuracy: {:.3%}".format(epoch,

epoch_loss_avg.result(),

epoch_accuracy.result()))

11，评估

test_url = "https://storage.googleapis.com/download.tensorflow.org/data/iris_test.csv"

test_fp = tf.keras.utils.get_file(fname=os.path.basename(test_url),

origin=test_url)

test_dataset = tf.contrib.data.make_csv_dataset(

test_fp,

batch_size,

column_names=column_names,

label_name='species',

num_epochs=1,

shuffle=False)

test_dataset = test_dataset.map(pack_features_vector)

test_accuracy = tfe.metrics.Accuracy()

for (x, y) in test_dataset:

logits = model(x)

prediction = tf.argmax(logits, axis=1, output_type=tf.int32)

test_accuracy(prediction, y)

print("Test set accuracy: {:.3%}".format(test_accuracy.result()))

tf.stack([y,prediction],axis=1)

12，预测

predict_dataset = tf.convert_to_tensor([

[5.1, 3.3, 1.7, 0.5,],

[5.9, 3.0, 4.2, 1.5,],

[6.9, 3.1, 5.4, 2.1]

])

predictions = model(predict_dataset)

for i, logits in enumerate(predictions):

class_idx = tf.argmax(logits).numpy()

p = tf.nn.softmax(logits)[class_idx]

name = class_names[class_idx]

print("Example {} prediction: {} ({:4.1f}%)".format(i, name, 100*p))