# 三、TensorFlow 2 和 ANN 技術 在本章中，我們將討論并舉例說明 TensorFlow 2 的那些部分，這些部分對于構建，訓練和評估人工神經網絡及其推理的利用目的是必需的。 最初，我們不會提供完整的申請。 相反，在將所有概念和技術放在一起并在隨后的章節中介紹完整的模型之前，我們將重點關注它們。 在本章中，我們將介紹以下主題： * 將數據呈現給**人工神經網絡**（**ANN**） * 神經網絡層 * 梯度下降算法的梯度計算 * 損失函數 # 將數據呈現給人工神經網絡 Google 推薦的將數據呈現給 TensorFlow ANN 的規范方法是通過由`tf.data.Dataset`對象和`tf.data.Iterator`方法組成的數據管道。 `tf.data.Dataset`對象由一系列元素組成，其中每個元素包含一個或多個張量對象。 `tf.data.Iterator`是一種用于遍歷數據集以便可以訪問其中的連續單個元素的方法。 我們將研究構建數據管道的兩種重要方法，首先是從內存中的 **NumPy** 數組，其次是從**逗號分隔值**（**CSV**）文件。 我們還將研究二進制 TFRecord 格式。 # 將 NumPy 數組與數據集結合使用 首先讓我們看一些簡單的例子。 這是一個 NumPy 數組： ```py import tensorflow as tf import numpy as np num_items = 11 num_list1 = np.arange(num_items) num_list2 = np.arange(num_items,num_items*2) ``` 這是使用`from_tensor_slices()`方法創建數據集的方法： ```py num_list1_dataset = tf.data.Dataset.from_tensor_slices(num_list1) ``` 這是使用`make_one_shot_iterator()`方法在其上創建`iterator`的方法： ```py iterator = tf.compat.v1.data.make_one_shot_iterator(num_list1_dataset) ``` 這是使用`get_next`方法將它們一起使用的方法： ```py for item in num_list1_dataset: num = iterator1.get_next().numpy() print(num) ``` 請注意，由于我們使用的是**單次**迭代器，因此在同一程序運行中兩次執行此代碼會引發錯誤。 也可以使用`batch`方法批量訪問數據。 請注意，第一個參數是每個批次中要放置的元素數，第二個參數是不言自明的`drop_remainder`參數： ```py num_list1_dataset = tf.data.Dataset.from_tensor_slices(num_list1).batch(3, drop_remainder = False) iterator = tf.compat.v1.data.make_one_shot_iterator(num_list1_dataset) for item in num_list1_dataset: num = iterator.get_next().numpy() print(num) ``` 還有一種`zip`方法，可用于一起顯示特征和標簽： ```py dataset1 = [1,2,3,4,5] dataset2 = ['a','e','i','o','u'] dataset1 = tf.data.Dataset.from_tensor_slices(dataset1) dataset2 = tf.data.Dataset.from_tensor_slices(dataset2) zipped_datasets = tf.data.Dataset.zip((dataset1, dataset2)) iterator = tf.compat.v1.data.make_one_shot_iterator(zipped_datasets) for item in zipped_datasets: num = iterator.get_next() print(num) ``` 我們可以使用`concatenate`方法如下連接兩個數據集： ```py ds1 = tf.data.Dataset.from_tensor_slices([1,2,3,5,7,11,13,17]) ds2 = tf.data.Dataset.from_tensor_slices([19,23,29,31,37,41]) ds3 = ds1.concatenate(ds2) print(ds3) iterator = tf.compat.v1.data.make_one_shot_iterator(ds3) for i in range(14): num = iterator.get_next() print(num) ``` 我們還可以完全取消迭代器，如下所示： ```py epochs=2 for e in range(epochs): for item in ds3: print(item) ``` 請注意，此處的外部循環不會引發錯誤，因此在大多數情況下將是首選方法。 # 將逗號分隔值（CSV）文件與數據集一起使用 CSV 文件是一種非常流行的數據存儲方法。 TensorFlow 2 包含靈活的方法來處理它們。 這里的主要方法是`tf.data.experimental.CsvDataset`。 # CSV 示例 1 使用以下參數，我們的數據集將由`filename`文件每一行中的兩項組成，均為浮點類型，忽略文件的第一行，并使用第 1 列和第 2 列（當然，列編號為 ，從 0 開始）： ```py filename = ["./size_1000.csv"] record_defaults = [tf.float32] * 2 # two required float columns dataset = tf.data.experimental.CsvDataset(filename, record_defaults, header=True, select_cols=[1,2]) for item in dataset: print(item) ``` # CSV 示例 2 在此示例中，使用以下參數，我們的數據集將包含一個必需的浮點數，一個默認值為`0.0`的可選浮點和一個`int`，其中 CSV 文件中沒有標題，而只有列 1 ，2 和 3 被導入： ```py #file Chapter_2.ipynb filename = "mycsvfile.txt" record_defaults = [tf.float32, tf.constant([0.0], dtype=tf.float32), tf.int32,] dataset = tf.data.experimental.CsvDataset(filename, record_defaults, header=False, select_cols=[1,2,3]) for item in dataset: print(item) ``` # CSV 示例 3 對于最后一個示例，我們的`dataset`將由兩個必需的浮點數和一個必需的字符串組成，其中 CSV 文件具有`header`變量： ```py filename = "file1.txt" record_defaults = [tf.float32, tf.float32, tf.string ,] dataset = tf.data.experimental.CsvDataset(filename, record_defaults, header=False) or item in dataset: print(item[0].numpy(), item[1].numpy(),item[2].numpy().decode() ) # decode as string is in binary format. ``` # TFRecord 另一種流行的存儲數據選擇是 TFRecord 格式。 這是一個二進制文件格式。 對于大文件，這是一個不錯的選擇，因為二進制文件占用的磁盤空間更少，復制所需的時間更少，并且可以非常有效地從磁盤讀取。 所有這些都會對數據管道的效率以及模型的訓練時間產生重大影響。 該格式還以多種方式與 TensorFlow 一起進行了優化。 這有點復雜，因為在存儲之前必須將數據轉換為二進制格式，并在回讀時將其解碼。 # TFRecord 示例 1 我們在此處顯示的第一個示例將演示該技術的基本內容。 （文件為`TFRecords.ipynb`）。 由于 TFRecord 文件是二進制字符串序列，因此必須在保存之前指定其結構，以便可以正確地寫入并隨后回讀。 TensorFlow 為此具有兩個結構，即`tf.train.Example`和`tf.train.SequenceExample`。 您要做的是將每個數據樣本存儲在這些結構之一中，然后對其進行序列化，然后使用`tf.python_io.TFRecordWriter`將其保存到磁盤。 在下面的示例中，浮點數組`data`被轉換為二進制格式，然后保存到磁盤。 `feature`是一個字典，包含在序列化和保存之前傳遞給`tf.train.Example`的數據。 “TFRecord 示例 2”中顯示了更詳細的示例： TFRecords 支持的字節數據類型為`FloatList`，`Int64List`和`BytesList`。 ```py # file: TFRecords.ipynb import tensorflow as tf import numpy as np data=np.array([10.,11.,12.,13.,14.,15.]) def npy_to_tfrecords(fname,data): writer = tf.io.TFRecordWriter(fname) feature={} feature['data'] = tf.train.Feature(float_list=tf.train.FloatList(value=data)) example = tf.train.Example(features=tf.train.Features(feature=feature)) serialized = example.SerializeToString() writer.write(serialized) writer.close() npy_to_tfrecords("./myfile.tfrecords",data) ``` 讀回記錄的代碼如下。 構造了`parse_function`函數，該函數對從文件讀回的數據集進行解碼。 這需要一個字典（`keys_to_features`），其名稱和結構與保存的數據相同： ```py dataset = tf.data.TFRecordDataset("./myfile.tfrecords") def parse_function(example_proto): keys_to_features = {'data':tf.io.FixedLenSequenceFeature([], dtype = tf.float32, allow_missing = True) } parsed_features = tf.io.parse_single_example(serialized=example_proto, features=keys_to_features) return parsed_features['data'] dataset = dataset.map(parse_function) iterator = tf.compat.v1.data.make_one_shot_iterator(dataset) # array is retrieved as one item item = iterator.get_next() print(item) print(item.numpy()) print(item[2].numpy()) ``` # TFRecord 示例 2 在這個例子中，我們看一下這個字典給出的更復雜的記錄結構： ```py filename = './students.tfrecords' data = { 'ID': 61553, 'Name': ['Jones', 'Felicity'], 'Scores': [45.6, 97.2] } ``` 使用此方法，我們可以再次使用`Feature()`方法構造一個`tf.train.Example`類。 注意我們如何編碼字符串： ```py ID = tf.train.Feature(int64_list=tf.train.Int64List(value=[data['ID']])) Name = tf.train.Feature(bytes_list=tf.train.BytesList(value=[n.encode('utf-8') for n in data['Name']])) Scores = tf.train.Feature(float_list=tf.train.FloatList(value=data['Scores'])) example = tf.train.Example(features=tf.train.Features(feature={'ID': ID, 'Name': Name, 'Scores': Scores })) ``` 將此記錄串行化并將其寫入光盤與“TFRecord 示例 1”相同： ```py writer = tf.io.TFRecordWriter(filename) writer.write(example.SerializeToString()) writer.close() ``` 為了回讀這一點，我們只需要構造我們的`parse_function`函數即可反映記錄的結構： ```py dataset = tf.data.TFRecordDataset("./students.tfrecords") def parse_function(example_proto): keys_to_features = {'ID':tf.io.FixedLenFeature([], dtype = tf.int64), 'Name':tf.io.VarLenFeature(dtype = tf.string), 'Scores':tf.io.VarLenFeature(dtype = tf.float32) } parsed_features = tf.io.parse_single_example(serialized=example_proto, features=keys_to_features) return parsed_features["ID"], parsed_features["Name"],parsed_features["Scores"] ``` 下一步與之前相同： ```py dataset = dataset.map(parse_function) iterator = tf.compat.v1.data.make_one_shot_iterator(dataset) item = iterator.get_next() # record is retrieved as one item print(item) ``` 輸出如下： ```py (<tf.Tensor: id=264, shape=(), dtype=int64, numpy=61553>, <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x7f1bfc7567b8>, <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x7f1bfc771e80>) ``` 現在我們可以從`item`中提取數據（注意，必須解碼（從字節開始）字符串，其中 Python 3 的默認值為`utf8`）。 還要注意，字符串和浮點數數組將作為稀疏數組返回，并且要從記錄中提取它們，我們使用稀疏數組`value`方法： ```py print("ID: ",item[0].numpy()) name = item[1].values.numpy() name1= name[0].decode()returned name2 = name[1].decode('utf8') print("Name:",name1,",",name2) print("Scores: ",item[2].values.numpy()) ``` # 單熱編碼 **單熱編碼**（**OHE**）是根據數據標簽構造張量的方法，在每個標簽中，與標簽值相對應的每個元素中的數字為 1，其他地方為 0； 也就是說，張量中的位之一是熱的（1）。 # OHE 示例 1 在此示例中，我們使用`tf.one_hot()`方法將十進制值`5`轉換為一個單編碼的值`0000100000`： ```py y = 5 y_train_ohe = tf.one_hot(y, depth=10).numpy() print(y, "is ",y_train_ohe,"when one-hot encoded with a depth of 10") # 5 is 00000100000 when one-hot encoded with a depth of 10 ``` # OHE 示例 2 在下面的示例中，還使用從時尚 MNIST 數據集導入的示例代碼很好地展示了這一點。 原始標簽是從 0 到 9 的整數，因此，例如`2`的標簽在進行一次熱編碼時變為`0010000000`，但請注意索引與該索引處存儲的標簽之間的區別： ```py import tensorflow as tf from tensorflow.python.keras.datasets import fashion_mnist tf.enable_eager_execution() width, height, = 28,28 n_classes = 10 # load the dataset (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() split = 50000 #split feature training set into training and validation sets (y_train, y_valid) = y_train[:split], y_train[split:] # one-hot encode the labels using TensorFlow. # then convert back to numpy for display y_train_ohe = tf.one_hot(y_train, depth=n_classes).numpy() y_valid_ohe = tf.one_hot(y_valid, depth=n_classes).numpy() y_test_ohe = tf.one_hot(y_test, depth=n_classes).numpy() # show difference between the original label and a one-hot-encoded label i=5 print(y_train[i]) # 'ordinary' number value of label at index i=5 is 2 # 2 # note the difference between the *index* of 5 and the *label* at that index which is 2 print(y_train_ohe[i]) # # 0\. 0\. 1\. 0\. 0.0 .0 .0\. 0\. 0. ``` 接下來，我們將檢查神經網絡的基本數據結構：神經元的**層**。 # 層 ANN 使用的基本數據結構是**層**，許多相互連接的層構成了一個完整的 ANN。 可以將一層設想為神經元的數組，盡管使用單詞*神經元*可能會產生誤導，因為在人腦神經元和構成一層的人工神經元之間只有很少的對應關系。 記住這一點，我們將在下面使用術語*神經元*。 與任何計算機處理單元一樣，神經元的特征在于其輸入和輸出。 通常，神經元具有許多輸入和一個輸出值。 每個輸入連接均帶有權重`w[i]`。 下圖顯示了一個神經元。 重要的是要注意，激活函數`f`對于平凡的 ANN 而言是非線性的。 網絡中的一般神經元接收來自其他神經元的輸入，并且每個神經元的權重為`w[i]`，如圖所示，網絡*通過調整這些權重來學習權重*，以便輸入生成所需的輸出：  圖 1：人工神經元 通過將輸入乘以權重，將偏差乘以其權重相加，然后應用激活函數，可以得出神經元的輸出（請參見下圖）。 下圖顯示了如何配置各個人工神經元和層以創建 ANN：  圖 2：人工神經網絡 層的輸出由以下公式給出：  在此， `W`是輸入的權重， `X`是輸入向量， `f`是非線性激活函數。 層的類型很多，支持大量的 ANN 模型結構。 可以在[這個頁面](https://www.tensorflow.org/api_docs/python/tf/keras/layers)中找到非常全面的列表。 在這里，我們將研究一些更流行的方法，以及 TensorFlow 如何實現它們。 # 密集（完全連接）層 **密集層**是完全連接的層。 這意味著上一層中的所有神經元都連接到下一層中的所有神經元。 在密集的網絡中，所有層都是密集的。 （如果網絡具有三個或更多隱藏層，則稱為**深度網絡**）。 `layer = tf.keras.layers.Dense(n)`行構成了一個密集層，其中`n`是輸出單元的數量。 注意，密集層是一維的。 請參考“模型”的部分。 # 卷積層 **卷積層**是一層，其中層中的神經元通過使用通常為正方形的過濾器分組為小塊，并通過在該層上滑動過濾器來創建。 每個色塊由*卷積*，即乘以濾波器并相加。 簡而言之，**卷積網**或 **ConvNets** 已經證明自己非常擅長圖像識別和處理。 對于圖像，卷積層具有部分簽名`tf.keras.layers.Conv2D(filters, kernel_size, strides=1, padding='valid')`。 因此，在下面的示例中，該第一層具有一個大小為`(1, 1)`的過濾器，并且其填充`'valid'`。 其他填充可能性是`'same'`。 區別在于，使用`'same'`填充，必須在外部填充該層（通常用零填充），以便在卷積發生后，輸出大小與該層大小相同。 如果使用`'valid'`填充，則不會進行填充，并且如果跨度和內核大小的組合不能完全適合該層，則該層將被截斷。 輸出大小小于正在卷積的層： ```py seqtial_Net = tf.keras.Sequential([tf.keras.layers.Conv2D( 1, (1, 1), strides = 1, padding='valid') ``` # 最大池化層 當窗口在層上滑動時，**最大池化層**在其窗口內取最大值，這與卷積發生的方式幾乎相同。 空間數據（即圖像）的最大池簽名如下： ```py tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None) ``` 因此，要使用默認值，您只需擁有以下內容： ```py layer = tf.keras.maxPooling2D() ``` # 批量歸一化層和丟棄層 **批量歸一化**是一個接受輸入并輸出相同數量的輸出的層，其中激活的平均值和單位方差為零，因為這對學習有益。 批量標準化規范了激活，使它們既不會變得很小也不會爆炸性地變大，這兩種情況都阻止了網絡的學習。 `BatchNormalization`層的簽名如下： ```py tf.keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None) ``` 因此，要使用默認值，只需使用以下命令： ```py layer = tf.keras.layers.BatchNormalization() ``` **丟棄層**是其中一定百分比的神經元在訓練過程中（而不是在推理過程中）隨機關閉的層。 由于不鼓勵單個神經元對其輸入進行專門化，因此這迫使網絡在泛化方面變得更好。 `Dropout`層的簽名如下： ```py tf.keras.layers.Dropout(rate, noise_shape=None, seed=None) ``` `rate`參數是神經元被關閉的部分。 因此，要使用它，例如，您需要： ```py layer = tf.keras.layers.Dropout(rate = 0.5) ``` 隨機選擇的 50% 的神經元將被關閉。 # Softmax 層 **softmax 層**是其中每個輸出單元的激活對應于輸出單元與給定標簽匹配的概率的層。 因此，具有最高激活值的輸出神經元是網絡的預測。 當要學習的類互斥時使用此函數，以使 softmax 層輸出的概率總計為 1。 它被實現為在密集層上的激活。 因此，例如，我們有以下內容： ```py model2.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax)) ``` 這將添加具有 10 個神經元的密集 softmax 層，其中神經元的激活總數為 1。 接下來，我們將進一步討論激活函數。 # 激活函數 重要的是要注意，神經網絡具有非線性激活函數，即應用于神經元加權輸入之和的函數。 除了平凡的神經網絡模型外，線性激活單元無法將輸入層映射到輸出層。 有許多常用的激活函數，包括 Sigmoid，tanh，ReLU 和泄漏的 ReLU。 一個很好的總結，以及這些函數的圖表，[可以在這里找到](https://towardsdatascience.com/activation-functions-neural-networks-1cbd9f8d91d6)。 # 建立模型 使用 Keras 創建 ANN 模型的方法有四種： * **方法 1** ：參數已傳遞給`tf.keras.Sequential` * **方法 2** ：使用`tf.keras.Sequential`的`.add`方法 * **方法 3** ：使用 Keras 函數式 API * **方法 4** ：通過將`tf.keras.Model`對象子類化 有關這四種方法的詳細信息，請參考第 2 章“TensorFlow 2 的高級 API，Keras”。 # 梯度下降算法的梯度計算 TenorFlow 的一大優勢是它能夠自動計算梯度以用于梯度下降算法，這當然是大多數機器學習模型的重要組成部分。 TensorFlow 提供了許多用于梯度計算的方法。 啟用急切執行時，有四種自動計算梯度的方法（它們也適用于圖模式）： 1. `tf.GradientTape`：上下文記錄了計算，因此您可以調用`tf.gradient()`來獲取記錄時針對任何可訓練變量計算的任何張量的梯度 2. `tfe.gradients_function()`：采用一個函數（例如`f()`）并返回一個梯度函數（例如`fg()`），該函數可以計算`f()`的輸出相對于`f()`或其部分參數的梯度 3. `tfe.implicit_gradients()`：這非常相似，但是`fg()`會針對這些輸出所依賴的所有可訓練變量計算`f()`輸出的梯度 4. `tfe.implicit_value_and_gradients()`：幾乎相同，但`fg()`也返回函數`f()`的輸出 我們將看看其中最流行的`tf.GradientTape`。 同樣，在其上下文中，隨著計算的進行，對這些計算進行記錄（錄音），以便可以使用`tf.gradient()`重放磁帶，并實現適當的自動微分。 在以下代碼中，當計算`sum`方法時，磁帶將在`tf.GradientTape()`上下文中記錄計算結果，以便可以通過調用`tape.gradient()`找到自動微分。 注意在`[weight1_grad] = tape.gradient(sum, [weight1])`中的此示例中如何使用列表。 默認情況下，僅可以調用`tape.gradient()`： ```py # by default, you can only call tape.gradient once in a GradientTape context weight1 = tf.Variable(2.0) def weighted_sum(x1): return weight1 * x1 with tf.GradientTape() as tape: sum = weighted_sum(7.) [weight1_grad] = tape.gradient(sum, [weight1]) print(weight1_grad.numpy()) # 7 , weight1*x diff w.r.t. weight1 is x, 7.0, also see below. ``` 在下一個示例中，請注意，參數`persistent=True`已傳遞給`tf.GradientTape()`。 這使我們可以多次調用`tape.gradient()`。 同樣，我們在`tf.GradientTape`上下文中計算一個加權和，然后調用`tape.gradient()`來計算每項相對于`weight`變量的導數： ```py # if you need to call tape.gradient() more than once # use GradientTape(persistent=True) weight1 = tf.Variable(2.0) weight2 = tf.Variable(3.0) weight3 = tf.Variable(5.0) def weighted_sum(x1, x2, x3): return weight1*x1 + weight2*x2 + weight3*x3 with tf.GradientTape(persistent=True) as tape: sum = weighted_sum(7.,5.,6.) [weight1_grad] = tape.gradient(sum, [weight1]) [weight2_grad] = tape.gradient(sum, [weight2]) [weight3_grad] = tape.gradient(sum, [weight3]) print(weight1_grad.numpy()) #7.0 print(weight2_grad.numpy()) #5.0 print(weight3_grad.numpy()) #6.0 ``` 接下來，我們將研究損失函數。 這些是在訓練神經網絡模型期間優化的函數。 # 損失函數 `loss`函數（即，誤差測量）是訓練 ANN 的必要部分。 它是網絡在訓練期間計算出的輸出與其所需輸出的差異程度的度量。 通過微分`loss`函數，我們可以找到一個量，通過該量可以調整各層之間的連接權重，以使 ANN 的計算輸出與所需輸出更緊密匹配。 最簡單的`loss`函數是均方誤差： ， 在此， `y`是實際標簽值，`y_hat`是預測標簽值。 特別值得注意的是分類交叉熵`loss`函數，它由以下方程式給出：  當所有可能的類別中只有一類正確時，使用`loss`函數；當`softmax`函數用作 ANN 的最后一層的輸出時，將使用此`loss`函數。 請注意，這兩個函數可以很好地微分，這是反向傳播所要求的。 # 總結 在本章中，我們研究了許多支持神經網絡創建和使用的技術。 我們涵蓋了到 ANN 的數據表示，ANN 的各層，創建模型，梯度下降算法的梯度計算，損失函數以及保存和恢復模型的內容。 這些主題是在開發神經網絡模型時將在后續章節中遇到的概念和技術的重要前提。 確實，在下一章中，我們將通過探索許多監督的學習場景，包括線性回歸，邏輯回歸和 K 近鄰，來認真地使用 TensorFlow。