TensorFlow提供了众多的API，简单地可以分类为高阶API和低阶API. API太多太乱也是TensorFlow被诟病的重点之一，可能因为Google的工程师太多了，社区太活跃了~当然后来Google也意识到这个问题，在TensorFlow 2.0中有了很大的改善。本文就简要介绍一下TensorFlow的高阶API和低阶API使用，提供推荐的使用方式。

高阶API（For beginners）

The best place to start is with the user-friendly Keras sequential API. Build models by plugging together building blocks.

TensorFlow推荐使用Keras的sequence函数作为高阶API的入口进行模型的构建，就像堆积木一样：

import tensorflow as tf # 导入TensorFlow, 以及下面的常用Keras层

from tensorflow.keras.layers import Flatten, Dense, Dropout

# 加载并准备好MNIST数据集
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 将样本从0~255的整数转换为0~1的浮点数
x_train, x_test = x_train / 255.0, x_test / 255.0

# 将模型的各层堆叠起来，以搭建 tf.keras.Sequential 模型

model = tf.keras.models.Sequential([
Flatten(input_shape=(28, 28)),
Dense(128, activation='relu'),
Dropout(0.5),
Dense(10, activation='softmax')
])

# 为训练选择优化器和损失函数
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

# 训练并验证模型

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test, verbose=2)

输出的日志：

Train on 60000 samples

Epoch 1/5

60000/60000 [==============================] - 4s 72us/sample - loss: 0.2919 - accuracy: 0.9156

Epoch 2/5

60000/60000 [==============================] - 4s 58us/sample - loss: 0.1439 - accuracy: 0.9568

Epoch 3/5

60000/60000 [==============================] - 4s 58us/sample - loss: 0.1080 - accuracy: 0.9671

Epoch 4/5

60000/60000 [==============================] - 4s 59us/sample - loss: 0.0875 - accuracy: 0.9731

Epoch 5/5

60000/60000 [==============================] - 3s 58us/sample - loss: 0.0744 - accuracy: 0.9766

10000/1 - 1s - loss: 0.0383 - accuracy: 0.9765

[0.07581, 0.9765]

日志的最后一行有两个数 [0.07581, 0.9765]，0.07581是最终的loss值，也就是交叉熵；0.9765是测试集的accuracy结果，这个数字手写体模型的精度已经将近98%.

低阶API（For experts）

The Keras functional and subclassing APIs provide a define-by-run interface for customization and advanced research. Build your model, then write the forward and backward pass. Create custom layers, activations, and training loops.

说到TensorFlow低阶API，最先想到的肯定是tf.Session和著名的sess.run，但随着TensorFlow的发展，tf.Session最后出现在TensorFlow 1.15中，TensorFlow 2.0已经取消了这个API，如果非要使用的话只能使用兼容版本的tf.compat.v1.Session. 当然，还是推荐使用新版的API，这里也是用Keras，但是用的是subclass的相关API以及GradientTape. 下面会详细介绍。

import tensorflow as tf # 导入TensorFlow, 以及下面的常用Keras层
from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model

# 加载并准备好MNIST数据集
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 将样本从0~255的整数转换为0~1的浮点数
x_train, x_test = x_train / 255.0, x_test / 255.0

# 使用 tf.data 来将数据集切分为 batch 以及混淆数据集

batch_size = 32

train_ds = tf.data.Dataset.from_tensor_slices(
(x_train, y_train)).shuffle(10000).batch(batch_size)
test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(batch_size)

# 使用 Keras 模型子类化（model subclassing） API 构建 tf.keras 模型

class MyModel(Model):
def __init__(self):
super(MyModel, self).__init__()
self.flatten = Flatten()
self.d1 = Dense(128, activation='relu')
self.dropout = Dropout(0.5)
self.d2 = Dense(10, activation='softmax')

def call(self, x):
x = self.flatten(x)
x = self.d1(x)
x = self.dropout(x)
return self.d2(x)

model = MyModel()

# 为训练选择优化器和损失函数
loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

# 选择衡量指标来度量模型的损失值（loss）和准确率（accuracy）。这些指标在 epoch 上累积值，然后打印出整体结果
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

# 使用 tf.GradientTape 来训练模型
@tf.function
def train_step(images, labels):
with tf.GradientTape() as tape:
predictions = model(images)
loss = loss_object(labels, predictions)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))

train_loss(loss)
train_accuracy(labels, predictions)

# 使用 tf.GradientTape 来训练模型
@tf.function
def train_step(images, labels):
with tf.GradientTape() as tape:
predictions = model(images)
loss = loss_object(labels, predictions)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))

train_loss(loss)
train_accuracy(labels, predictions)

# 测试模型
@tf.function
def test_step(images, labels):
predictions = model(images)
t_loss = loss_object(labels, predictions)

test_loss(t_loss)
test_accuracy(labels, predictions)

EPOCHS = 5



for epoch in range(EPOCHS):

  for images, labels in train_ds:

    train_step(images, labels)



  for test_images, test_labels in test_ds:

    test_step(test_images, test_labels)



  template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'

  print (template.format(epoch+1,

                         train_loss.result(),

                         train_accuracy.result()*100,

                         test_loss.result(),

                         test_accuracy.result()*100))

输出：

Epoch 1, Loss: 0.13822732865810394, Accuracy: 95.84833526611328, Test Loss: 0.07067110389471054, Test Accuracy: 97.75

Epoch 2, Loss: 0.09080979228019714, Accuracy: 97.25, Test Loss: 0.06446609646081924, Test Accuracy: 97.95999908447266

Epoch 3, Loss: 0.06777264922857285, Accuracy: 97.93944549560547, Test Loss: 0.06325332075357437, Test Accuracy: 98.04000091552734

Epoch 4, Loss: 0.054447807371616364, Accuracy: 98.33999633789062, Test Loss: 0.06611879169940948, Test Accuracy: 98.00749969482422

Epoch 5, Loss: 0.04556874558329582, Accuracy: 98.60433197021484, Test Loss: 0.06510476022958755, Test Accuracy: 98.10400390625

可以看出，低阶API把整个训练的过程都暴露出来了，包括数据的shuffle（每个epoch重新排序数据使得训练数据随机化，避免周期性重复带来的影响）及组成训练batch，组建模型的数据通路，具体定义各种评估指标（loss, accuracy），计算梯度，更新梯度（这两步尤为重要）。如果用户需要对梯度或者中间过程做处理，甚至打印等，使用低阶API可以进行完全的控制。