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的入口进行模型的构建，就像堆积木一样：

# 导入TensorFlow, 以及下面的常用Keras层
import tensorflow as tf  
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. 下面会详细介绍。

# 导入TensorFlow, 以及下面的常用Keras层
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Conv2Dfrom 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.functiondef 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.functiondef 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.functiondef 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可以完全进行完全的控制。