今年 3 月份，谷歌在 Tensorflow Developer Summit 2019 大會上釋出 TensorFlow 2。0 Alpha 版。作為當前最為流行的深度學習框架，2。0 Alpha 版的正式釋出引人關注。近兩個月，網上已經出現了大量 TensorFlow 2。0 英文教程。在此文章中，機器之心為大家推薦一個持續更新的中文教程，以便大家學習。
雖然，自 TensorFlow 2。0 釋出以來，我們總是能夠聽到「TensorFlow 2。0 就是 keras」、「說的很好，但我用 PyTorch」類似的吐槽。但毋庸置疑，TensorFlow 依然是當前最主流的深度學習框架（感興趣的讀者可檢視機器之心文章：2019 年，TensorFlow 被拉下馬了嗎？）。
整體而言，為了吸引使用者，TensorFlow 2。0 從簡單、強大、可擴充套件三個層面進行了重新設計。特別是在簡單化方面，TensorFlow 2。0 提供更簡化的 API、注重 Keras、結合了 Eager execution。
過去一段時間，機器之心為大家編譯介紹了部分英文教程，例如：
如何在 TensorFlow 2。0 中構建強化學習智慧體
TensorFlow 2。0 到底怎麼樣？簡單的影象分類任務探一探
此文章中，機器之心為大家推薦一個持續更新的中文教程，方便大家更系統的學習、使用 TensorFlow 2。0 ：
知乎專欄地址：
https：//
zhuanlan。zhihu。com/c_10
91021863043624960
Github 專案地址：
https：//
github。com/czy36mengfei
/tensorflow2_tutorials_chinese
該教程是 NLP 愛好者 Doit 在知乎上開的一個專欄，由作者從 TensorFlow2。0 官方教程的個人學習復現筆記整理而來。作者將此教程分為了三類：TensorFlow 2。0 基礎教程、TensorFlow 2。0 深度學習實踐、TensorFlow 2。0 基礎網路結構。
以基礎教程為例，作者整理了 Keras 快速入門教程、eager 模式、Autograph 等。目前為止，該中文教程已經包含 20 多篇文章，作者還在持續更新中，感興趣的讀者可以 follow。
該中文教程當前目錄
以下是作者整理的「Keras 快速入門」教程內容。
Keras 快速入門
Keras 是一個用於構建和訓練深度學習模型的高階 API。它可用於快速設計原型、高階研究和生產。
keras 的 3 個優點： 方便使用者使用、模組化和可組合、易於擴充套件
1. 匯入 tf.keras
tensorflow2 推薦使用 keras 構建網路，常見的神經網路都包含在 keras。layer 中 （最新的 tf。keras 的版本可能和 keras 不同）
import tensorflow as tf
from tensorflow。keras import layers
print（tf。__version__）
print（tf。keras。__version__）
2. 構建簡單模型
2。1 模型堆疊
最常見的模型型別是層的堆疊：tf。keras。Sequential 模型\
model = tf。keras。Sequential（）
model。add（layers。Dense（32， activation=‘relu’））
model。add（layers。Dense（32， activation=‘relu’））
model。add（layers。Dense（10， activation=‘softmax’））
2。2 網路配置
tf。keras。layers 中網路配置：
activation：設定層的啟用函式。此引數由內建函式的名稱指定，或指定為可呼叫物件。預設情況下，系統不會應用任何啟用函式。
kernel_initializer 和 bias_initializer：建立層權重（核和偏差）的初始化方案。此引數是一個名稱或可呼叫物件，預設為 “Glorot uniform” 初始化器。
kernel_regularizer 和 bias_regularizer：應用層權重（核和偏差）的正則化方案，例如 L1 或 L2 正則化。預設情況下，系統不會應用正則化函式。
layers。Dense（32， activation=‘sigmoid’）
layers。Dense（32， activation=tf。sigmoid）
layers。Dense（32， kernel_initializer=‘orthogonal’）
layers。Dense（32， kernel_initializer=tf。keras。initializers。glorot_normal）
layers。Dense（32， kernel_regularizer=tf。keras。regularizers。l2（0。01））
layers。Dense（32， kernel_regularizer=tf。keras。regularizers。l1（0。01））
3. 訓練和評估
3。1 設定訓練流程
構建好模型後，透過呼叫 compile 方法配置該模型的學習流程：
model = tf。keras。Sequential（）
model。add（layers。Dense（32， activation=‘relu’））
model。add（layers。Dense（32， activation=‘relu’））
model。add（layers。Dense（10， activation=‘softmax’））
model。compile（optimizer=tf。keras。optimizers。Adam（0。001），
loss=tf。keras。losses。categorical_crossentropy，
metrics=［tf。keras。metrics。categorical_accuracy］）
3。2 輸入 Numpy 資料
import numpy as np
train_x = np。random。random（（1000， 72））
train_y = np。random。random（（1000， 10））
val_x = np。random。random（（200， 72））
val_y = np。random。random（（200， 10））
model。fit（train_x， train_y， epochs=10， batch_size=100，
validation_data=（val_x， val_y））
3。3tf。data 輸入資料
dataset = tf。data。Dataset。from_tensor_slices（（train_x， train_y））
dataset = dataset。batch（32）
dataset = dataset。repeat（）
val_dataset = tf。data。Dataset。from_tensor_slices（（val_x， val_y））
val_dataset = val_dataset。batch（32）
val_dataset = val_dataset。repeat（）
model。fit（dataset， epochs=10， steps_per_epoch=30，
validation_data=val_dataset， validation_steps=3）
3。4 評估與預測
test_x = np。random。random（（1000， 72））
test_y = np。random。random（（1000， 10））
model。evaluate（test_x， test_y， batch_size=32）
test_data = tf。data。Dataset。from_tensor_slices（（test_x， test_y））
test_data = test_data。batch（32）。repeat（）
model。evaluate（test_data， steps=30）
# predict
result = model。predict（test_x， batch_size=32）
print（result）
4. 構建高階模型
4。1 函式式 api
tf。keras。Sequential 模型是層的簡單堆疊，無法表示任意模型。使用 Keras 函式式 API 可以構建複雜的模型拓撲，例如：
多輸入模型，
多輸出模型，
具有共享層的模型（同一層被呼叫多次），
具有非序列資料流的模型（例如，殘差連線）。
使用函式式 API 構建的模型具有以下特徵：
層例項可呼叫並返回張量。
輸入張量和輸出張量用於定義 tf。keras。Model 例項。x此模型的訓練方式和 Sequential 模型一樣。
input_x = tf。keras。Input（shape=（72，））
hidden1 = layers。Dense（32， activation=‘relu’）（input_x）
hidden2 = layers。Dense（16， activation=‘relu’）（hidden1）
pred = layers。Dense（10， activation=‘softmax’）（hidden2）
model = tf。keras。Model（inputs=input_x， outputs=pred）
model。compile（optimizer=tf。keras。optimizers。Adam（0。001），
loss=tf。keras。losses。categorical_crossentropy，
metrics=［‘accuracy’］）
model。fit（train_x， train_y， batch_size=32， epochs=5）
4。2 模型子類化
透過對 tf。keras。Model 進行子類化並定義您自己的前向傳播來構建完全可自定義的模型。在 init 方法中建立層並將它們設定為類例項的屬性。在 call 方法中定義前向傳播
class MyModel（tf。keras。Model）：
def __init__（self， num_classes=10）：
super（MyModel， self）。__init__（name=‘my_model’）
self。num_classes = num_classes
self。layer1 = layers。Dense（32， activation=‘relu’）
self。layer2 = layers。Dense（num_classes， activation=‘softmax’）
def call（self， inputs）：
h1 = self。layer1（inputs）
out = self。layer2（h1）
return out
def compute_output_shape（self， input_shape）：
shape = tf。TensorShapej（input_shape）。as_list（）
shape［-1］ = self。num_classes
return tf。TensorShape（shape）
model = MyModel（num_classes=10）
model。compile（optimizer=tf。keras。optimizers。RMSprop（0。001），
loss=tf。keras。losses。categorical_crossentropy，
metrics=［‘accuracy’］）
model。fit（train_x， train_y， batch_size=16， epochs=5）
4。3 自定義層
透過對 tf。keras。layers。Layer 進行子類化並實現以下方法來建立自定義層：
build：建立層的權重。使用 add_weight 方法新增權重。
call：定義前向傳播。
compute_output_shape：指定在給定輸入形狀的情況下如何計算層的輸出形狀。或者，可以透過實現 get_config 方法和 from_config 類方法序列化層。
class MyLayer（layers。Layer）：
def __init__（self， output_dim， **kwargs）：
self。output_dim = output_dim
super（MyLayer， self）。__init__（**kwargs）
def build（self， input_shape）：
shape = tf。TensorShape（（input_shape［1］， self。output_dim））
self。kernel = self。add_weight（name=‘kernel1’， shape=shape，
initializer=‘uniform’， trainable=True）
super（MyLayer， self）。build（input_shape）
def call（self， inputs）：
return tf。matmul（inputs， self。kernel）
def compute_output_shape（self， input_shape）：
shape = tf。TensorShape（input_shape）。as_list（）
shape［-1］ = self。output_dim
return tf。TensorShape（shape）
def get_config（self）：
base_config = super（MyLayer， self）。get_config（）
base_config［‘output_dim’］ = self。output_dim
return base_config
@classmethod
def from_config（cls， config）：
return cls（**config）
model = tf。keras。Sequential（
［
MyLayer（10），
layers。Activation（‘softmax’）
］）
model。compile（optimizer=tf。keras。optimizers。RMSprop（0。001），
loss=tf。keras。losses。categorical_crossentropy，
metrics=［‘accuracy’］）
model。fit（train_x， train_y， batch_size=16， epochs=5）
4。4 回撥
callbacks = ［
tf。keras。callbacks。EarlyStopping（patience=2， monitor=‘val_loss’），
tf。keras。callbacks。TensorBoard（log_dir=‘。/logs’）
］
model。fit（train_x， train_y， batch_size=16， epochs=5，
callbacks=callbacks， validation_data=（val_x， val_y））
5 保持和恢復
5。1 權重儲存
model = tf。keras。Sequential（［
layers。Dense（64， activation=‘relu’），
layers。Dense（10， activation=‘softmax’）］）
model。compile（optimizer=tf。keras。optimizers。Adam（0。001），
loss=‘categorical_crossentropy’，
metrics=［‘accuracy’］）
model。save_weights（‘。/weights/model’）
model。load_weights（‘。/weights/model’）
model。save_weights（‘。/model。h5’）
model。load_weights（‘。/model。h5’）
5。2 儲存網路結構
# 序列化成json
import json
import pprint
json_str = model。to_json（）
pprint。pprint（json。loads（json_str））
fresh_model = tf。keras。models。model_from_json（json_str）
# 保持為yaml格式 #需要提前安裝pyyaml
yaml_str = model。to_yaml（）
print（yaml_str）
fresh_model = tf。keras。models。model_from_yaml（yaml_str）
5。3 儲存整個模型
model = tf。keras。Sequential（［
layers。Dense（10， activation=‘softmax’， input_shape=（72，）），
layers。Dense（10， activation=‘softmax’）
］）
model。compile（optimizer=‘rmsprop’，
loss=‘categorical_crossentropy’，
metrics=［‘accuracy’］）
model。fit（train_x， train_y， batch_size=32， epochs=5）
model。save（‘all_model。h5’）
model = tf。keras。models。load_model（‘all_model。h5’）
6. 將 keras 用於 Estimator
Estimator API 用於針對分散式環境訓練模型。它適用於一些行業使用場景，例如用大型資料集進行分散式訓練並匯出模型以用於生產
model = tf。keras。Sequential（［layers。Dense（10，activation=‘softmax’），
layers。Dense（10，activation=‘softmax’）］）
model。compile（optimizer=tf。keras。optimizers。RMSprop（0。001），
loss=‘categorical_crossentropy’，
metrics=［‘accuracy’］）
estimator = tf。keras。estimator。model_to_estimator（model）
