Keras 快速指南

上一頁
下一頁

Keras - 簡介

深度學習是機器學習框架的一個主要子領域。機器學習是研究演算法設計，其靈感來自於人腦模型。深度學習在資料科學領域越來越流行，例如機器人技術、人工智慧 (AI)、音訊和影片識別以及影像識別。人工神經網路是深度學習方法的核心。深度學習由各種庫支援，例如 Theano、TensorFlow、Caffe、Mxnet 等。Keras 是一個最強大、最易於使用的 Python 庫之一，它構建在 TensorFlow、Theano 等流行的深度學習庫之上，用於建立深度學習模型。

Keras 概述

Keras 執行在 TensorFlow、Theano 或認知工具包 (CNTK) 等開源機器學習庫之上。Theano 是一個用於快速數值計算任務的 Python 庫。TensorFlow 是最著名的符號數學庫，用於建立神經網路和深度學習模型。TensorFlow 非常靈活，主要優點是分散式計算。CNTK 是微軟開發的深度學習框架。它使用 Python、C#、C++ 等庫或獨立的機器學習工具包。Theano 和 TensorFlow 非常強大的庫，但對於建立神經網路來說難以理解。

Keras 基於最小的結構，提供了一種簡潔易用的方法來建立基於 TensorFlow 或 Theano 的深度學習模型。Keras 旨在快速定義深度學習模型。Keras 是深度學習應用的最佳選擇。

特性

Keras 利用各種最佳化技術，使高階神經網路 API 更易於使用且效能更高。它支援以下特性：

  • 一致、簡單且可擴充套件的 API。

  • 結構簡潔 - 易於實現結果，無需任何多餘功能。

  • 它支援多個平臺和後端。

  • 它是一個使用者友好的框架，可在 CPU 和 GPU 上執行。

  • 高度可擴充套件的計算。

優勢

Keras 是一個功能強大且動態的框架，具有以下優點：

  • 更大的社群支援。

  • 易於測試。

  • Keras 神經網路是用 Python 編寫的，這使得事情更簡單。

  • Keras 支援卷積網路和迴圈網路。

  • 深度學習模型是離散元件，因此您可以以多種方式組合它們。

Keras - 安裝

本章介紹如何在您的機器上安裝 Keras。在開始安裝之前，讓我們先了解 Keras 的基本要求。

先決條件

您必須滿足以下要求：

  • 任何型別的作業系統 (Windows、Linux 或 Mac)
  • Python 3.5 或更高版本。

Python

Keras 是一個基於 Python 的神經網路庫，因此您的機器上必須安裝 Python。如果您的機器上已正確安裝 Python，則開啟您的終端並鍵入 python，您將看到類似於以下所示的響應：

Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) 
[MSC v.1900 64 bit (AMD64)] on win32 
Type "help", "copyright", "credits" or "license" for more information. 
>>>

目前最新版本為“3.7.2”。如果未安裝 Python，請訪問官方 Python 連結 - www.python.org 並根據您的作業系統下載最新版本並立即安裝到您的系統上。

Keras 安裝步驟

Keras 的安裝非常簡單。請按照以下步驟在您的系統上正確安裝 Keras。

步驟 1：建立虛擬環境

Virtualenv 用於管理不同專案的 Python 包。這將有助於避免破壞其他環境中安裝的包。因此，在開發 Python 應用程式時，始終建議使用虛擬環境。

Linux/Mac OS

Linux 或 Mac OS 使用者，轉到您的專案根目錄並鍵入以下命令以建立虛擬環境：

python3 -m venv kerasenv

執行上述命令後，將在您的安裝位置建立包含bin、lib 和 include 資料夾的“kerasenv”目錄。

Windows

Windows 使用者可以使用以下命令：

py -m venv keras

步驟 2：啟用環境

此步驟將配置您 shell 路徑中的 python 和 pip 可執行檔案。

Linux/Mac OS

現在我們已經建立了一個名為“kerasvenv”的虛擬環境。移動到該資料夾並鍵入以下命令：

$ cd kerasvenv kerasvenv $ source bin/activate

Windows

Windows 使用者移動到“kerasenv”資料夾並鍵入以下命令：

.\env\Scripts\activate

步驟 3：Python 庫

Keras 依賴於以下 Python 庫。

  • NumPy
  • Pandas
  • Scikit-learn
  • Matplotlib
  • SciPy
  • Seaborn

希望您已經在系統上安裝了所有上述庫。如果這些庫未安裝，則使用以下命令逐個安裝。

numpy

pip install numpy

您將看到以下響應：

Collecting numpy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
   numpy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

pandas

pip install pandas

我們將看到以下響應：

Collecting pandas 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
pandas-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

matplotlib

pip install matplotlib

我們將看到以下響應：

Collecting matplotlib 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
matplotlib-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scipy

pip install scipy

我們將看到以下響應：

Collecting scipy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8 
/scipy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scikit-learn

這是一個開源機器學習庫。它用於分類、迴歸和聚類演算法。在開始安裝之前，它需要以下內容：

  • Python 3.5 或更高版本
  • NumPy 1.11.0 或更高版本
  • SciPy 0.17.0 或更高版本
  • joblib 0.11 或更高版本。

現在，我們使用以下命令安裝 scikit-learn：

pip install -U scikit-learn

Seaborn

Seaborn 是一個很棒的庫，允許您輕鬆地視覺化您的資料。使用以下命令安裝：

pip install seaborn

您將看到類似於以下所示的訊息：

Collecting seaborn 
   Downloading 
https://files.pythonhosted.org/packages/a8/76/220ba4420459d9c4c9c9587c6ce607bf56c25b3d3d2de62056efe482dadc 
/seaborn-0.9.0-py3-none-any.whl (208kB) 100% 
   |████████████████████████████████| 215kB 4.0MB/s 
Requirement already satisfied: numpy> = 1.9.3 in 
./lib/python3.7/site-packages (from seaborn) (1.17.0) 
Collecting pandas> = 0.15.2 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/39/b7/441375a152f3f9929ff8bc2915218ff1a063a59d7137ae0546db616749f9/ 
pandas-0.25.0-cp37-cp37m-macosx_10_9_x86_64.
macosx_10_10_x86_64.whl (10.1MB) 100% 
   |████████████████████████████████| 10.1MB 1.8MB/s 
Requirement already satisfied: scipy>=0.14.0 in 
./lib/python3.7/site-packages (from seaborn) (1.3.0) 
Collecting matplotlib> = 1.4.3 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/c3/8b/af9e0984f
5c0df06d3fab0bf396eb09cbf05f8452de4e9502b182f59c33b/ 
matplotlib-3.1.1-cp37-cp37m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64 
.macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 100% 
   |████████████████████████████████| 14.4MB 1.4MB/s 
...................................... 
...................................... 
Successfully installed cycler-0.10.0 kiwisolver-1.1.0 
matplotlib-3.1.1 pandas-0.25.0 pyparsing-2.4.2 
python-dateutil-2.8.0 pytz-2019.2 seaborn-0.9.0

使用 Python 安裝 Keras

到現在為止，我們已經完成了 Keras 安裝的基本要求。現在，使用以下指定的相同步驟安裝 Keras：

pip install keras

退出虛擬環境

完成專案中的所有更改後，只需執行以下命令即可退出環境：

deactivate

Anaconda Cloud

我們相信您已經在機器上安裝了 Anaconda Cloud。如果未安裝 Anaconda，請訪問官方連結 https://www.anaconda.com/download 並根據您的作業系統選擇下載。

建立一個新的 conda 環境

啟動 Anaconda 提示符，這將開啟基礎 Anaconda 環境。讓我們建立一個新的 conda 環境。此過程類似於 virtualenv。在您的 conda 終端中鍵入以下命令：

conda create --name PythonCPU

如果需要，您也可以使用 GPU 建立和安裝模組。在本教程中，我們遵循 CPU 指令。

啟用 conda 環境

要啟用環境，請使用以下命令：

activate PythonCPU

安裝 Spyder

Spyder 是一個用於執行 Python 應用程式的 IDE。讓我們使用以下命令在我們的 conda 環境中安裝此 IDE：

conda install spyder

安裝 Python 庫

我們已經瞭解了 Keras 所需的 Python 庫 numpy、pandas 等。您可以使用以下語法安裝所有模組：

語法

conda install -c anaconda <module-name>

例如，您想安裝 pandas：

conda install -c anaconda pandas

使用相同的方法，嘗試自己安裝其餘的模組。

安裝 Keras

現在，一切看起來都很不錯，因此您可以使用以下命令開始 Keras 安裝：

conda install -c anaconda keras

啟動 Spyder

最後，在您的 conda 終端中使用以下命令啟動 Spyder：

spyder

為確保一切安裝正確，匯入所有模組，它將新增所有內容，如果出現任何錯誤，您將收到模組未找到錯誤訊息。

Keras - 後端配置

本章詳細解釋了 Keras 後端實現 TensorFlow 和 Theano。讓我們逐一瞭解每個實現。

TensorFlow

TensorFlow 是一個由 Google 開發的用於數值計算任務的開源機器學習庫。Keras 是構建在 TensorFlow 或 Theano 之上的高階 API。我們已經知道如何使用 pip 安裝 TensorFlow。

如果未安裝，您可以使用以下命令安裝：

pip install TensorFlow

一旦我們執行 keras，我們將看到配置檔案位於您的主目錄內部，然後轉到 .keras/keras.json。

keras.json

{ 
   "image_data_format": "channels_last", 
   "epsilon": 1e-07, "floatx": "float32", "backend": "tensorflow" 
}

這裡：

  • image_data_format 表示資料格式。

  • epsilon 表示數值常量。它用於避免除以零錯誤。

  • floatx 表示預設資料型別float32。您也可以使用set_floatx()方法將其更改為float16或float64。

  • image_data_format 表示資料格式。

假設，如果未建立檔案，則移動到該位置並使用以下步驟建立：

> cd home 
> mkdir .keras 
> vi keras.json

記住，您應該指定 .keras 作為其資料夾名稱，並將上述配置新增到 keras.json 檔案中。我們可以執行一些預定義的操作來了解後端功能。

Theano

Theano 是一個開源深度學習庫，允許您有效地評估多維陣列。我們可以使用以下命令輕鬆安裝：

pip install theano

預設情況下，keras 使用 TensorFlow 後端。如果要將後端配置從 TensorFlow 更改為 Theano，只需在 keras.json 檔案中將 backend = theano 更改即可。如下所示：

keras.json

{ 
   "image_data_format": "channels_last", 
   "epsilon": 1e-07, 
   "floatx": "float32", 
   "backend": "theano" 
}

現在儲存您的檔案，重新啟動您的終端並啟動 keras，您的後端將被更改。

>>> import keras as k 
using theano backend.

Keras - 深度學習概述

深度學習是機器學習不斷發展的子領域。深度學習涉及逐層分析輸入，其中每一層逐漸提取關於輸入的更高級別的資訊。

讓我們來看一個簡單的影像分析場景。假設你的輸入影像被分割成一個矩形的畫素網格。第一層對畫素進行抽象。第二層理解影像中的邊緣。下一層從邊緣構建節點。然後，下一層從節點中找到分支。最後，輸出層將檢測完整的物體。在這裡，特徵提取過程從一層輸出到下一層的輸入。

透過這種方法，我們可以處理海量特徵，這使得深度學習成為一個非常強大的工具。深度學習演算法也適用於非結構化資料的分析。本章我們將學習深度學習的基礎知識。

人工神經網路

深度學習最流行和主要的方法是使用“人工神經網路”（ANN）。它們受到人腦模型的啟發，人腦是我們身體最複雜的器官。人腦由超過900億個被稱為“神經元”的微小細胞組成。神經元透過稱為“軸突”和“樹突”的神經纖維相互連線。軸突的主要作用是將資訊從一個神經元傳遞到它連線的另一個神經元。

同樣，樹突的主要作用是接收另一個神經元（它連線到的）的軸突傳遞的資訊。每個神經元處理少量資訊，然後將結果傳遞給另一個神經元，這個過程持續進行。這是我們人腦處理大量資訊（如語音、視覺等）並從中提取有用資訊的基本方法。

基於此模型，第一個人工神經網路（ANN）由心理學家弗蘭克·羅森布拉特於1958年發明。ANN由多個節點組成，類似於神經元。節點緊密相連並組織成不同的隱藏層。輸入層接收輸入資料，資料依次透過一個或多個隱藏層，最後輸出層預測關於輸入資料的有用資訊。例如，輸入可以是一張影像，輸出可以是影像中識別出的物體，例如“貓”。

單個神經元（在ANN中稱為感知器）可以表示如下：

Artificial Neural Networks

這裡：

  • 多個輸入以及權重代表樹突。

  • 輸入之和以及啟用函式代表神經元。總和實際上是指所有輸入的計算值，啟用函式代表一個函式，它將總和值修改為0、1或0到1。

  • 實際輸出代表軸突，輸出將被下一層的神經元接收。

在本節中，讓我們瞭解不同型別的人工神經網路。

多層感知器

多層感知器是最簡單形式的ANN。它由一個輸入層、一個或多個隱藏層以及一個輸出層組成。一層由多個感知器組成。輸入層基本上是輸入資料的一個或多個特徵。每個隱藏層包含一個或多個神經元，處理特徵的某些方面並將處理後的資訊傳送到下一個隱藏層。輸出層處理接收來自最後一個隱藏層的資料，並最終輸出結果。

Multi-Layer Perceptron

卷積神經網路 (CNN)

卷積神經網路是最流行的ANN之一。它廣泛用於影像和影片識別領域。它基於卷積的概念，這是一個數學概念。它與多層感知器幾乎相同，只是在全連線隱藏神經元層之前包含一系列卷積層和池化層。它具有三個重要的層：

  • 卷積層 - 它是主要的構建塊，並根據卷積函式執行計算任務。

  • 池化層 - 它位於卷積層旁邊，用於透過去除不必要的資訊來減小輸入的大小，以便可以更快地執行計算。

  • 全連線層 - 它位於一系列卷積層和池化層之後，並將輸入分類到不同的類別。

一個簡單的CNN可以表示如下：

CNN

這裡：

  • 使用了2個系列的卷積和池化層，它接收並處理輸入（例如影像）。

  • 使用單個全連線層，用於輸出資料（例如影像分類）。

迴圈神經網路 (RNN)

迴圈神經網路 (RNN) 用於解決其他ANN模型中的缺陷。大多數ANN不記得之前情況的步驟，並學習根據訓練中的上下文做出決策。同時，RNN儲存過去的資訊，其所有決策都是根據過去學到的知識做出的。

這種方法主要用於影像分類。有時，我們可能需要展望未來才能解決過去的問題。在這種情況下，雙向RNN有助於從過去學習並預測未來。例如，我們在多個輸入中具有手寫樣本。假設在一個輸入中存在混淆，那麼我們需要再次檢查其他輸入以識別正確的上下文，該上下文根據過去做出決策。

ANN 的工作流程

讓我們首先了解深度學習的不同階段，然後學習Keras如何在深度學習過程中提供幫助。

收集所需資料

深度學習需要大量的輸入資料才能成功學習並預測結果。因此，首先儘可能多地收集資料。

分析資料

分析資料並對資料有很好的理解。需要更好地理解資料才能選擇正確的ANN演算法。

選擇演算法（模型）

選擇最適合學習過程型別（例如影像分類、文字處理等）和可用輸入資料的演算法。演算法在Keras中由模型表示。演算法包括一個或多個層。ANN中的每一層都可以由Keras中的Keras層表示。

  • 準備資料 - 處理、過濾並僅從資料中選擇所需資訊。

  • 分割資料 - 將資料分割成訓練和測試資料集。測試資料將用於評估演算法/模型的預測（一旦機器學習）並交叉檢查學習過程的效率。

  • 編譯模型 - 編譯演算法/模型，以便可以進一步使用它來透過訓練進行學習，最終進行預測。此步驟要求我們選擇損失函式和最佳化器。損失函式和最佳化器用於學習階段以查詢誤差（與實際輸出的偏差）並進行最佳化，以便最大限度地減少誤差。

  • 擬合模型 - 實際學習過程將在此階段使用訓練資料集完成。

  • 預測未知值的結果 - 預測未知輸入資料（現有訓練和測試資料以外）的輸出。

  • 評估模型 - 透過預測測試資料的輸出並將預測與測試資料的實際結果進行交叉比較來評估模型。

  • 凍結、修改或選擇新演算法 - 檢查模型的評估是否成功。如果是，則儲存演算法以備將來預測使用。如果不是，則修改或選擇新的演算法/模型，最後再次訓練、預測和評估模型。重複此過程，直到找到最佳演算法（模型）。

上述步驟可以用下面的流程圖表示：

ANN

Keras - 深度學習

Keras提供了一個完整的框架來建立任何型別的神經網路。Keras既創新又易於學習。它支援從簡單的神經網路到非常大和複雜的神經網路模型。本章讓我們瞭解Keras框架的架構以及Keras如何在深度學習中提供幫助。

Keras 的架構

Keras API可以分為三大類：

  • 模型
  • 層
  • 核心模組

在Keras中，每個ANN都由Keras模型表示。反過來，每個Keras模型都是Keras層的組合，並表示ANN層，例如輸入層、隱藏層、輸出層、卷積層、池化層等。Keras模型和層訪問Keras模組以實現啟用函式、損失函式、正則化函式等。使用Keras模型、Keras層和Keras模組，可以簡單有效地表示任何ANN演算法（CNN、RNN等）。

下圖描述了模型、層和核心模組之間的關係：

Architecture of Keras

讓我們看看Keras模型、Keras層和Keras模組的概述。

模型

Keras模型有兩種型別，如下所示：

順序模型 - 順序模型基本上是Keras層的線性組合。順序模型簡單、最小，並且能夠表示幾乎所有可用的神經網路。

一個簡單的順序模型如下所示：

from keras.models import Sequential 
from keras.layers import Dense, Activation 

model = Sequential()  
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

其中：

  • 第1行從Keras模型匯入Sequential模型

  • 第2行匯入Dense層和Activation模組

  • 第4行使用Sequential API建立一個新的順序模型

  • 第5行新增一個具有relu啟用（使用Activation模組）函式的密集層（Dense API）。

Sequential模型公開Model類以建立自定義模型。我們可以使用子類化概念來建立我們自己的複雜模型。

函式式API - 函式式API主要用於建立複雜的模型。

層

Keras模型中的每個Keras層都代表實際提出的神經網路模型中的相應層（輸入層、隱藏層和輸出層）。Keras提供了許多預構建的層，以便可以輕鬆建立任何複雜的神經網路。一些重要的Keras層如下所示：

  • 核心層
  • 卷積層
  • 池化層
  • 迴圈層

使用sequential模型表示神經網路模型的簡單python程式碼如下：

from keras.models import Sequential 
from keras.layers import Dense, Activation, Dropout model = Sequential() 

model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(num_classes, activation = 'softmax'))

其中：

  • 第1行從Keras模型匯入Sequential模型

  • 第2行匯入Dense層和Activation模組

  • 第4行使用Sequential API建立一個新的順序模型

  • 第5行新增一個具有relu啟用（使用Activation模組）函式的密集層（Dense API）。

  • 第6行新增一個dropout層（Dropout API）來處理過擬合。

  • 第7行新增另一個具有relu啟用（使用Activation模組）函式的密集層（Dense API）。

  • 第8行新增另一個dropout層（Dropout API）來處理過擬合。

  • 第9行新增具有softmax啟用（使用Activation模組）函式的最終密集層（Dense API）。

Keras還提供選項來建立我們自己的自定義層。自定義層可以透過子類化Keras.Layer類來建立，這類似於子類化Keras模型。

核心模組

Keras還提供許多內建的神經網路相關函式來正確建立Keras模型和Keras層。一些函式如下：

  • 啟用模組 - 啟用函式是ANN中的一個重要概念，啟用模組提供了許多啟用函式，例如softmax、relu等。

  • 損失模組 - 損失模組提供損失函式，例如mean_squared_error、mean_absolute_error、poisson等。

  • 最佳化器模組 - 最佳化器模組提供最佳化器函式，例如adam、sgd等。

  • 正則化器 - 正則化器模組提供函式，例如L1正則化器、L2正則化器等。

讓我們在接下來的章節中詳細學習Keras模組。

Keras - 模組

正如我們前面所學，Keras模組包含預定義的類、函式和變數，這些對於深度學習演算法非常有用。本章讓我們學習Keras提供的模組。

可用模組

讓我們首先檢視Keras中可用的模組列表。

  • 初始化器 - 提供初始化器函式列表。我們可以在Keras的 *層章節* 中詳細學習它。在機器學習的模型建立階段。

  • 正則化器 (Regularizers) − 提供一系列正則化函式。詳情請參閱Keras 層章節。

  • 約束 (Constraints) − 提供一系列約束函式。詳情請參閱Keras 層章節。

  • 啟用函式 (Activations) − 提供一系列啟用函式。詳情請參閱Keras 層章節。

  • 損失函式 (Losses) − 提供一系列損失函式。詳情請參閱模型訓練章節。

  • 度量指標 (Metrics) − 提供一系列度量函式。詳情請參閱模型訓練章節。

  • 最佳化器 (Optimizers) − 提供一系列最佳化器函式。詳情請參閱模型訓練章節。

  • 回撥函式 (Callback) − 提供一系列回撥函式。可在訓練過程中使用它們來列印中間資料，並根據某些條件停止訓練（EarlyStopping 方法）。

  • 文字處理 (Text processing) − 提供將文字轉換為適用於機器學習的 NumPy 陣列的函式。可將其用於機器學習的資料準備階段。

  • 影像處理 (Image processing) − 提供將影像轉換為適用於機器學習的 NumPy 陣列的函式。可將其用於機器學習的資料準備階段。

  • 序列處理 (Sequence processing) − 提供根據給定輸入資料生成基於時間的函式。可將其用於機器學習的資料準備階段。

  • 後端 (Backend) − 提供後端庫（如 TensorFlow 和 Theano）的函式。

  • 實用工具 (Utilities) − 提供許多深度學習中常用的實用函式。

本章將介紹後端模組和實用工具模組。

後端模組

後端模組用於 Keras 後端操作。預設情況下，Keras 執行在 TensorFlow 後端之上。如果需要，可以切換到其他後端，如 Theano 或 CNTK。預設後端配置定義在根目錄下的 .keras/keras.json 檔案中。

可以使用以下程式碼匯入 Keras 後端模組：

>>> from keras import backend as k

如果使用預設後端 TensorFlow，則以下函式將返回如下所示的基於 TensorFlow 的資訊：

>>> k.backend() 
'tensorflow'
>>> k.epsilon() 
1e-07
>>> k.image_data_format() 
'channels_last'
>>> k.floatx() 
'float32'

讓我們簡要了解一些用於資料分析的重要後端函式：

get_uid()

這是預設圖的識別符號。定義如下：

>>> k.get_uid(prefix='') 
1 
>>> k.get_uid(prefix='') 2

reset_uids

用於重置 uid 值。

>>> k.reset_uids()

現在，再次執行 get_uid()。這將被重置，並再次更改為 1。

>>> k.get_uid(prefix='') 
1

placeholder

用於例項化一個佔位符張量。下面顯示了一個簡單的用於儲存 3 維形狀的佔位符：

>>> data = k.placeholder(shape = (1,3,3)) 
>>> data 
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32> 

If you use int_shape(), it will show the shape. 

>>> k.int_shape(data) (1, 3, 3)

dot

用於將兩個張量相乘。假設 a 和 b 是兩個張量，c 將是 ab 相乘的結果。假設 a 的形狀為 (4,2)，b 的形狀為 (2,3)。定義如下：

>>> a = k.placeholder(shape = (4,2)) 
>>> b = k.placeholder(shape = (2,3)) 
>>> c = k.dot(a,b) 
>>> c 
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32> 
>>>

ones

用於初始化所有值為一。

>>> res = k.ones(shape = (2,2)) 

#print the value 

>>> k.eval(res) 
array([[1., 1.], [1., 1.]], dtype = float32)

batch_dot

用於對批次資料執行乘積。輸入維度必須為 2 或更高。如下所示：

>>> a_batch = k.ones(shape = (2,3)) 
>>> b_batch = k.ones(shape = (3,2)) 
>>> c_batch = k.batch_dot(a_batch,b_batch) 
>>> c_batch 
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>

variable

用於初始化一個變數。讓我們在這個變數中執行簡單的轉置操作。

>>> data = k.variable([[10,20,30,40],[50,60,70,80]]) 
#variable initialized here 
>>> result = k.transpose(data) 
>>> print(result) 
Tensor("transpose_6:0", shape = (4, 2), dtype = float32) 
>>> print(k.eval(result)) 
   [[10. 50.] 
   [20. 60.] 
   [30. 70.] 
   [40. 80.]]

如果要從 NumPy 訪問：

>>> data = np.array([[10,20,30,40],[50,60,70,80]]) 

>>> print(np.transpose(data)) 
   [[10 50] 
   [20 60] 
   [30 70] 
   [40 80]] 

>>> res = k.variable(value = data) 
>>> print(res) 
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>

is_sparse(tensor)

用於檢查張量是否是稀疏的。

>>> a = k.placeholder((2, 2), sparse=True) 

>>> print(a) SparseTensor(indices =       
   Tensor("Placeholder_8:0", 
   shape = (?, 2), dtype = int64), 
values = Tensor("Placeholder_7:0", shape = (?,), 
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64)) 

>>> print(k.is_sparse(a)) True

to_dense()

用於將稀疏轉換為稠密。

>>> b = k.to_dense(a) 
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32) 
>>> print(k.is_sparse(b)) False

random_uniform_variable

使用均勻分佈的概念進行初始化。

k.random_uniform_variable(shape, mean, scale)

這裡：

  • shape − 以元組的形式表示行和列。

  • mean − 均勻分佈的均值。

  • scale − 均勻分佈的標準差。

讓我們看下面的示例用法：

>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1) 
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1) 
>>> c = k.dot(a, b) 
>>> k.int_shape(c) 
(2, 2)

實用工具模組

utils 提供了深度學習中常用的實用函式。utils 模組提供的一些方法如下：

HDF5Matrix

用於以 HDF5 格式表示輸入資料。

from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')

to_categorical

用於將類向量轉換為二進位制類矩陣。

>>> from keras.utils import to_categorical 
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> to_categorical(labels) 
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize 
>>> normalize([1, 2, 3, 4, 5]) 
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])

print_summary

用於列印模型的摘要。

from keras.utils import print_summary print_summary(model)

plot_model

用於建立模型的 dot 格式表示並將其儲存到檔案中。

from keras.utils import plot_model 
plot_model(model,to_file = 'image.png')

這個plot_model 將生成影像以瞭解模型的效能。

Keras - 層

如前所述，Keras 層是 Keras 模型的主要構建塊。每個層接收輸入資訊，進行一些計算，最後輸出轉換後的資訊。一層輸出將作為下一層的輸入。

介紹

Keras 層需要輸入形狀 (input_shape) 來理解輸入資料的結構，初始化器 (initializer) 來為每個輸入設定權重，以及啟用函式來轉換輸出使其非線性。在此期間，約束限制並指定生成輸入資料權重的範圍，而正則化器將透過在最佳化過程中動態地對權重施加懲罰來嘗試最佳化層（和模型）。

總而言之，Keras 層需要以下最少資訊才能建立一個完整的層。

  • 輸入資料的形狀
  • 層中的神經元/單元數量
  • 初始化器
  • 正則化器
  • 約束
  • 啟用函式

讓我們在下一章瞭解基本概念。在瞭解基本概念之前，讓我們使用 Sequential 模型 API 建立一個簡單的 Keras 層，以瞭解 Keras 模型和層的工作原理。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
from keras import regularizers 
from keras import constraints 

model = Sequential() 

model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform', 
   kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu')) 
model.add(Dense(16, activation = 'relu')) 
model.add(Dense(8))

其中：

  • 第 1-5 行匯入必要的模組。

  • 第 7 行使用 Sequential API 建立一個新模型。

  • 第 9 行建立一個新的Dense 層並將其新增到模型中。Dense 是 Keras 提供的入門級層，它接受神經元或單元的數量 (32) 作為其必需引數。如果該層是第一層，則還需要提供Input Shape (16,)。否則，前一層的輸出將用作下一層的輸入。所有其他引數都是可選的。

    • 第一個引數表示單元（神經元）的數量。

    • input_shape 表示輸入資料的形狀。

    • kernel_initializer 表示要使用的初始化器。he_uniform 函式設定為值。

    • kernel_regularizer 表示要使用的正則化器。設定為 None。

    • kernel_constraint 表示要使用的約束。MaxNorm 函式設定為值。

    • activation 表示要使用的啟用函式。relu 函式設定為值。

  • 第 10 行建立第二個具有 16 個單元的Dense 層，並將relu 設定為啟用函式。

  • 第 11 行建立具有 8 個單元的最終 Dense 層。

層的基本概念

讓我們瞭解層的根本概念以及 Keras 如何支援每個概念。

輸入形狀

在機器學習中，所有型別的輸入資料（如文字、影像或影片）都將首先轉換為數字陣列，然後饋送到演算法中。輸入數字可以是一維陣列、二維陣列（矩陣）或多維陣列。可以使用shape（整數元組）指定維度資訊。例如，(4,2) 表示具有四行兩列的矩陣。

>>> import numpy as np 
>>> shape = (4, 2) 
>>> input = np.zeros(shape) 
>>> print(input) 
[
   [0. 0.] 
   [0. 0.] 
   [0. 0.] 
   [0. 0.]
] 
>>>

類似地，(3,4,2) 表示具有三個 4x2 矩陣集合（兩行四列）的三維矩陣。

>>> import numpy as np 
>>> shape = (3, 4, 2) 
>>> input = np.zeros(shape) 
>>> print(input)
[
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>

要建立模型的第一層（或模型的輸入層），應指定輸入資料的形狀。

初始化器

在機器學習中，將為所有輸入資料分配權重。初始化器模組提供不同的函式來設定這些初始權重。一些Keras 初始化器函式如下：

Zeros

為所有輸入資料生成0。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Zeros() 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

其中，kernel_initializer 表示模型核心的初始化器。

Ones

為所有輸入資料生成1。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Ones() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Constant

為所有輸入資料生成使用者指定的常數值（例如，5）。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Constant(value = 0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

其中，value 表示常數值

RandomNormal

使用輸入資料的正態分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomNormal(mean=0.0, 
stddev = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

其中：

  • mean 表示要生成的隨機值的均值

  • stddev 表示要生成的隨機值的標準差

  • seed 表示生成隨機數的值

RandomUniform

使用輸入資料的均勻分佈生成值。

from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

其中：

  • minval 表示要生成的隨機值的較低界限

  • maxval 表示要生成的隨機值的較高界限

TruncatedNormal

使用輸入資料的截斷正態分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

VarianceScaling

根據層的輸入形狀和輸出形狀以及指定的比例生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.VarianceScaling(
   scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   skernel_initializer = my_init))

其中：

  • scale 表示比例因子

  • mode 表示fan_in、fan_out 和fan_avg 值中的任意一個

  • distribution 表示normal 或uniform 之一

VarianceScaling

它使用以下公式查詢正態分佈的stddev 值，然後使用正態分佈查詢權重：

stddev = sqrt(scale / n)

其中n表示：

  • 對於 mode = fan_in，輸入單元的數量

  • 對於 mode = fan_out，輸出單元的數量

  • 對於 mode = fan_avg，輸入和輸出單元的平均數量

類似地，它使用以下公式查詢均勻分佈的limit，然後使用均勻分佈查詢權重：

limit = sqrt(3 * scale / n)

lecun_normal

使用輸入資料的 Lecun 正態分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式查詢stddev，然後應用正態分佈

stddev = sqrt(1 / fan_in)

其中，fan_in 表示輸入單元的數量。

lecun_uniform

使用輸入資料的 Lecun 均勻分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.lecun_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式查詢limit，然後應用均勻分佈

limit = sqrt(3 / fan_in)

其中：

  • fan_in 表示輸入單元的數量

  • fan_out 表示輸出單元的數量

glorot_normal

使用輸入資料的 Glorot 正態分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.glorot_normal(seed=None) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

它使用以下公式查詢stddev，然後應用正態分佈

stddev = sqrt(2 / (fan_in + fan_out))

其中：

  • fan_in 表示輸入單元的數量

  • fan_out 表示輸出單元的數量

glorot_uniform

使用輸入資料的 Glorot 均勻分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.glorot_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式查詢limit，然後應用均勻分佈

limit = sqrt(6 / (fan_in + fan_out))

其中：

  • fan_in 表示輸入單元的數量。

  • fan_out 表示輸出單元的數量

he_normal

使用輸入資料的 He 正態分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式查詢stddev，然後應用正態分佈。

stddev = sqrt(2 / fan_in)

其中，fan_in 表示輸入單元的數量。

he_uniform

使用輸入資料的 He 均勻分佈生成值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.he_normal(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

它使用以下公式查詢limit，然後應用均勻分佈。

limit = sqrt(6 / fan_in)

其中，fan_in 表示輸入單元的數量。

Orthogonal

生成一個隨機正交矩陣。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Orthogonal(gain = 1.0, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

其中，gain 表示矩陣的乘法因子。

單位矩陣

生成單位矩陣。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

約束

在機器學習中，會在最佳化階段對引數（權重）設定約束。<>約束模組提供不同的函式來設定層的約束。一些約束函式如下所示。

非負約束 (NonNeg)

約束權重為非負數。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init)
)

其中，kernel_constraint 表示要用於該層的約束。

單位範數約束 (UnitNorm)

約束權重為單位範數。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.UnitNorm(axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

最大範數約束 (MaxNorm)

約束權重範數小於或等於給定值。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.MaxNorm(max_value = 2, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

其中：

  • max_value 表示上限

  • axis 表示應用約束的維度。例如，在形狀 (2,3,4) 中，axis 0 表示第一維度，1 表示第二維度，2 表示第三維度。

最小最大範數約束 (MinMaxNorm)

約束權重範數在指定的最小值和最大值之間。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

其中，rate 表示應用權重約束的速率。

正則化器

在機器學習中，正則化器用於最佳化階段。它在最佳化過程中對層引數施加一些懲罰。Keras 正則化模組提供以下函式來設定層的懲罰。正則化僅按層應用。

L1 正則化器 (L1 Regularizer)

它提供基於 L1 的正則化。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l1(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

其中，kernel_regularizer 表示應用權重約束的速率。

L2 正則化器 (L2 Regularizer)

它提供基於 L2 的正則化。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

L1 和 L2 正則化器 (L1 and L2 Regularizer)

它同時提供基於 L1 和 L2 的正則化。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,),
   kernel_regularizer = my_regularizer))

啟用函式

在機器學習中，啟用函式是一種特殊的函式，用於確定特定神經元是否被啟用。基本上，啟用函式對輸入資料進行非線性變換，從而使神經元能夠更好地學習。神經元的輸出取決於啟用函式。

正如你回憶起單感知器的概念一樣，感知器（神經元）的輸出只是啟用函式的結果，它接受所有輸入與其對應權重的乘積之和，以及任何可用的整體偏差。

result = Activation(SUMOF(input * weight) + bias)

因此，啟用函式在模型的成功學習中起著重要作用。Keras 在 activations 模組中提供了許多啟用函式。讓我們學習該模組中所有可用的啟用函式。

線性 (linear)

應用線性函式。什麼也不做。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'linear', input_shape = (784,)))

其中，activation 指的是層的啟用函式。它可以透過函式名簡單地指定，層將使用相應的啟用器。

指數線性單元 (elu)

應用指數線性單元。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'elu', input_shape = (784,)))

縮放指數線性單元 (selu)

應用縮放指數線性單元。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'selu', input_shape = (784,)))

修正線性單元 (relu)

應用修正線性單元。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

Softmax (softmax)

應用 Softmax 函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))

Softplus (softplus)

應用 Softplus 函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))

Softsign (softsign)

應用 Softsign 函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))

雙曲正切 (tanh)

應用雙曲正切函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))

Sigmoid (sigmoid)

應用 Sigmoid 函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))

硬 Sigmoid (hard_sigmoid)

應用硬 Sigmoid 函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))

指數 (exponential)

應用指數函式。

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))
序號 (Sr.No) 層和描述 (Layers & Description)
1

稠密層 (Dense Layer)

稠密層是常規的全連線神經網路層。
2

Dropout 層 (Dropout Layers)

Dropout是機器學習中的一個重要概念。
3

扁平化層 (Flatten Layers)

Flatten 用於扁平化輸入。
4

重塑層 (Reshape Layers)

Reshape 用於更改輸入的形狀。
5

置換層 (Permute Layers)

Permute 也用於使用模式更改輸入的形狀。
6

重複向量層 (RepeatVector Layers)

RepeatVector 用於將輸入重複設定的次數 n。
7

Lambda 層 (Lambda Layers)

Lambda 用於使用表示式或函式轉換輸入資料。
8

卷積層

Keras 包含許多用於建立基於卷積的 ANN 的層，通常稱為卷積神經網路 (CNN)。
9

池化層 (Pooling Layer)

它用於對時間資料執行最大池化操作。
10

區域性連線層 (Locally connected layer)

區域性連線層類似於 Conv1D 層，但不同之處在於 Conv1D 層的權重是共享的，而這裡的權重是不共享的。
11

合併層 (Merge Layer)

它用於合併輸入列表。
12

嵌入層 (Embedding Layer)

它在輸入層執行嵌入操作。

Keras - 自定義層

Keras 允許建立我們自己的自定義層。建立新層後，它可以在任何模型中使用，沒有任何限制。讓我們在本節學習如何建立新層。

Keras 提供了一個基本的層類 Layer，可以對其進行子類化以建立我們自己的自定義層。讓我們建立一個簡單的層，它將根據正態分佈查詢權重，然後在訓練期間進行查詢輸入與其權重乘積之和的基本計算。

步驟 1：匯入必要的模組

首先，讓我們匯入必要的模組：

from keras import backend as K 
from keras.layers import Layer

這裡：

  • backend 用於訪問dot 函式。

  • Layer 是基類，我們將對其進行子類化以建立我們的層。

步驟 2：定義層類

讓我們透過子類化Layer 類建立一個新類MyCustomLayer：

class MyCustomLayer(Layer): 
   ...

步驟 3：初始化層類

讓我們按如下所示初始化我們的新類：

def __init__(self, output_dim, **kwargs):    
   self.output_dim = output_dim 
   super(MyCustomLayer, self).__init__(**kwargs)

這裡：

  • 第 2 行設定輸出維度。

  • 第 3 行呼叫基類或超類的init 函式。

步驟 4：實現 build 方法

build 是主要方法，其唯一目的是正確構建層。它可以執行與層的內部工作相關的任何操作。完成自定義功能後，我們可以呼叫基類的build 函式。我們的自定義build 函式如下所示：

def build(self, input_shape): 
   self.kernel = self.add_weight(name = 'kernel', 
      shape = (input_shape[1], self.output_dim), 
      initializer = 'normal', trainable = True) 
   super(MyCustomLayer, self).build(input_shape)

這裡：

  • 第 1 行定義了帶有一個引數input_shape 的build 方法。輸入資料的形狀由 input_shape 指示。

  • 第 2 行建立與輸入形狀對應的權重，並將其設定在 kernel 中。這是我們層的自定義功能。它使用“normal”初始化器建立權重。

  • 第 6 行呼叫基類build 方法。

步驟 5：實現 call 方法

call 方法在訓練過程中執行層的精確工作。

我們的自定義call 方法如下所示：

def call(self, input_data): 
   return K.dot(input_data, self.kernel)

這裡：

  • 第 1 行定義了帶有一個引數input_data 的call 方法。input_data 是我們層的輸入資料。

  • 第 2 行返回輸入資料input_data 和我們層的核心self.kernel 的點積。

步驟 6：實現 compute_output_shape 方法

def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

這裡：

  • 第 1 行定義了帶有一個引數input_shape 的compute_output_shape 方法。

  • 第 2 行使用輸入資料的形狀和初始化層時設定的輸出維度來計算輸出形狀。

實現build、call 和compute_output_shape 完成了建立自定義層。最終完整的程式碼如下所示：

from keras import backend as K from keras.layers import Layer
class MyCustomLayer(Layer): 
   def __init__(self, output_dim, **kwargs): 
      self.output_dim = output_dim 
      super(MyCustomLayer, self).__init__(**kwargs) 
   def build(self, input_shape): self.kernel = 
      self.add_weight(name = 'kernel', 
      shape = (input_shape[1], self.output_dim), 
      initializer = 'normal', trainable = True) 
      super(MyCustomLayer, self).build(input_shape) # 
      Be sure to call this at the end 
   def call(self, input_data): return K.dot(input_data, self.kernel) 
   def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

使用我們的自定義層

讓我們使用我們的自定義層建立一個簡單的模型，如下所示：

from keras.models import Sequential 
from keras.layers import Dense 

model = Sequential() 
model.add(MyCustomLayer(32, input_shape = (16,))) 
model.add(Dense(8, activation = 'softmax')) model.summary()

這裡：

  • 我們的MyCustomLayer 使用 32 個單元和(16,) 作為輸入形狀新增到模型中。

執行應用程式將列印如下所示的模型摘要：

Model: "sequential_1" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
my_custom_layer_1 (MyCustomL (None, 32) 512 
_________________________________________________________________
dense_1 (Dense) (None, 8) 264 
================================================================= 
Total params: 776 
Trainable params: 776 
Non-trainable params: 0 
_________________________________________________________________

Keras - 模型

如前所述，Keras 模型表示實際的神經網路模型。Keras 提供兩種模式來建立模型，簡單易用的順序 API 以及更靈活和高階的函式式 API。讓我們在本節學習如何使用順序和函式式 API 建立模型。

順序 API (Sequential)

順序 API 的核心思想是簡單地按順序排列 Keras 層，因此它被稱為順序 API。大多數 ANN 的層也是按順序排列的，資料按給定順序從一層流向另一層，直到資料最終到達輸出層。

可以透過簡單地呼叫Sequential() API 來建立一個 ANN 模型，如下所示：

from keras.models import Sequential 
model = Sequential()

新增層 (Add layers)

要新增一個層，只需使用 Keras 層 API 建立一個層，然後將該層透過 add() 函式傳遞，如下所示：

from keras.models import Sequential 

model = Sequential() 
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer) 
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer) 
output_layer = Dense(8) 
model.add(output_layer)

在這裡，我們建立了一個輸入層、一個隱藏層和一個輸出層。

訪問模型 (Access the model)

Keras 提供了一些方法來獲取模型資訊，例如層、輸入資料和輸出資料。它們如下所示：

  • model.layers - 將模型的所有層作為列表返回。

>>> layers = model.layers 
>>> layers 
[
   <keras.layers.core.Dense object at 0x000002C8C888B8D0>, 
   <keras.layers.core.Dense object at 0x000002C8C888B7B8>
   <keras.layers.core.Dense object at 0x 000002C8C888B898>
]

  • model.inputs - 將模型的所有輸入張量作為列表返回。

>>> inputs = model.inputs 
>>> inputs 
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]

  • model.outputs - 將模型的所有輸出張量作為列表返回。

>>> outputs = model.outputs 
>>> outputs 
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]

  • model.get_weights - 將所有權重作為 NumPy 陣列返回。

  • model.set_weights(weight_numpy_array) - 設定模型的權重。

序列化模型 (Serialize the model)

Keras 提供了將模型序列化為物件以及 json 並稍後再次載入它的方法。它們如下所示：

  • get_config() - 將模型作為物件返回。

config = model.get_config()

  • from_config() - 它接受模型配置物件作為引數，並相應地建立模型。

new_model = Sequential.from_config(config)

  • to_json() - 將模型作為 json 物件返回。

>>> json_string = model.to_json() 
>>> json_string '{"class_name": "Sequential", "config": 
{"name": "sequential_10", "layers": 
[{"class_name": "Dense", "config": 
{"name": "dense_13", "trainable": true, "batch_input_shape": 
[null, 8], "dtype": "float32", "units": 32, "activation": "linear", 
"use_bias": true, "kernel_initializer": 
{"class_name": "Vari anceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf 
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, 
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true, 
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true, 
"kern el_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
"bias_initia lizer": {"class_name": "Zeros", 
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}}, 
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true, 
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true, 
"kernel_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}}, 
"bias_initializer": {"class_name": "Zeros", "config": {}}, 
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer": 
null, "kernel_constraint": null, "bias_constraint": 
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}' 
>>>

  • model_from_json() - 接受模型的 json 表示，並建立一個新模型。

from keras.models import model_from_json 
new_model = model_from_json(json_string)

  • to_yaml() - 將模型作為 yaml 字串返回。

>>> yaml_string = model.to_yaml() 
>>> yaml_string 'backend: tensorflow\nclass_name: 
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n 
activation: linear\n activity_regular izer: null\n batch_input_shape: 
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n 
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype: 
float32\n kernel_constraint: null\n 
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n 
trainable: true\n units: 32\n 
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n 
config : {}\n bias_regularizer: null\n dtype: float32\n 
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n 
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n 
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n 
units: 64\n use_bias: true\n - class_name: Dense\n config:\n 
activation: linear\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n 
class_name: Zeros\n config: {}\n bias_regu larizer: null\n 
dtype: float32\n kernel_constraint: null\n 
kernel_initializer:\n class_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n 
trainable: true\n units: 8\n 
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n' 
>>>

  • model_from_yaml() - 接受模型的 yaml 表示，並建立一個新模型。

from keras.models import model_from_yaml 
new_model = model_from_yaml(yaml_string)

模型摘要 (Summarise the model)

瞭解模型對於正確使用它進行訓練和預測非常重要。Keras 提供了一個簡單的方法 summary，用於獲取有關模型及其層的完整資訊。

上一節中建立的模型的摘要如下所示：

>>> model.summary() Model: "sequential_10" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
dense_13 (Dense) (None, 32) 288 
_________________________________________________________________ 
dense_14 (Dense) (None, 64) 2112 
_________________________________________________________________ 
dense_15 (Dense) (None, 8) 520 
================================================================= 
Total params: 2,920 
Trainable params: 2,920 
Non-trainable params: 0 
_________________________________________________________________ 
>>>

訓練和預測模型 (Train and Predict the model)

模型提供用於訓練、評估和預測過程的函式。它們如下所示：

  • compile - 配置模型的學習過程。

  • fit - 使用訓練資料訓練模型。

  • evaluate - 使用測試資料評估模型。

  • predict - 預測新輸入的結果。

函式式 API (Functional API)

順序API用於逐層建立模型。函式式API是建立更復雜模型的另一種方法。在函式式模型中，您可以定義共享層的多個輸入或輸出。首先，我們為模型建立一個例項，並連線到各層以訪問模型的輸入和輸出。本節簡要介紹函式式模型。

建立模型

使用以下模組匯入輸入層：

>>> from keras.layers import Input

現在，使用以下程式碼建立指定模型輸入維度形狀的輸入層：

>>> data = Input(shape=(2,3))

使用以下模組為輸入定義層：

>>> from keras.layers import Dense

使用以下程式碼行為輸入新增密集層：

>>> layer = Dense(2)(data) 
>>> print(layer) 
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)

使用以下模組定義模型：

from keras.models import Model

透過指定輸入層和輸出層，以函式式方式建立模型：

model = Model(inputs = data, outputs = layer)

建立簡單模型的完整程式碼如下所示：

from keras.layers import Input 
from keras.models import Model 
from keras.layers import Dense 

data = Input(shape=(2,3)) 
layer = Dense(2)(data) model = 
Model(inputs=data,outputs=layer) model.summary() 
_________________________________________________________________ 
Layer (type)               Output Shape               Param # 
================================================================= 
input_2 (InputLayer)       (None, 2, 3)               0 
_________________________________________________________________ 
dense_2 (Dense)            (None, 2, 2)               8 
================================================================= 
Total params: 8 
Trainable params: 8 
Non-trainable params: 0 
_________________________________________________________________

Keras - 模型編譯

前面我們學習瞭如何使用順序API和函式式API建立模型的基礎知識。本章將解釋如何編譯模型。編譯是建立模型的最後一步。編譯完成後，我們可以進入訓練階段。

讓我們學習一些有助於更好地理解編譯過程的概念。

損失函式

在機器學習中，**損失函式**用於查詢學習過程中的誤差或偏差。Keras在模型編譯過程中需要損失函式。

Keras在**losses**模組中提供了許多損失函式，如下所示：

  • 均方誤差 (mean_squared_error)
  • 平均絕對誤差 (mean_absolute_error)
  • 平均絕對百分比誤差 (mean_absolute_percentage_error)
  • 均方對數誤差 (mean_squared_logarithmic_error)
  • 平方鉸鏈損失 (squared_hinge)
  • 鉸鏈損失 (hinge)
  • 分類鉸鏈損失 (categorical_hinge)
  • 對數餘弦損失 (logcosh)
  • Huber損失 (huber_loss)
  • 分類交叉熵 (categorical_crossentropy)
  • 稀疏分類交叉熵 (sparse_categorical_crossentropy)
  • 二元交叉熵 (binary_crossentropy)
  • Kullback-Leibler 散度 (kullback_leibler_divergence)
  • 泊松損失 (poisson)
  • 餘弦相似度 (cosine_proximity)
  • is_categorical_crossentropy

以上所有損失函式都接受兩個引數：

  • **y_true** - 真實標籤（張量）

  • **y_pred** - 預測值，形狀與**y_true**相同

使用損失函式前，請按如下所示匯入losses模組：

from keras import losses

最佳化器

在機器學習中，**最佳化**是一個重要的過程，它透過比較預測值和損失函式來最佳化輸入權重。Keras提供了一些最佳化器模組， *optimizers* ，如下所示：

**SGD** - 隨機梯度下降最佳化器。

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

**RMSprop** - RMSProp 最佳化器。

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

**Adagrad** - Adagrad 最佳化器。

keras.optimizers.Adagrad(learning_rate = 0.01)

**Adadelta** - Adadelta 最佳化器。

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

**Adam** - Adam 最佳化器。

keras.optimizers.Adam(
   learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

**Adamax** - 來自Adam的Adamax最佳化器。

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

**Nadam** - Nesterov Adam 最佳化器。

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

使用最佳化器前，請按如下所示匯入optimizers模組：

from keras import optimizers

評估指標

在機器學習中，**評估指標**用於評估模型的效能。它類似於損失函式，但不用於訓練過程。Keras在**metrics**模組中提供了許多評估指標，如下所示：

  • 準確率 (accuracy)
  • 二元準確率 (binary_accuracy)
  • 分類準確率 (categorical_accuracy)
  • 稀疏分類準確率 (sparse_categorical_accuracy)
  • Top-k 分類準確率 (top_k_categorical_accuracy)
  • 稀疏 Top-k 分類準確率 (sparse_top_k_categorical_accuracy)
  • 餘弦相似度 (cosine_proximity)
  • 克隆指標 (clone_metric)

與損失函式類似，評估指標也接受以下兩個引數：

  • **y_true** - 真實標籤（張量）

  • **y_pred** - 預測值，形狀與**y_true**相同

使用評估指標前，請按如下所示匯入metrics模組：

from keras import metrics

編譯模型

Keras模型提供了一個方法**compile()**來編譯模型。**compile()**方法的引數及其預設值如下所示：

compile(
   optimizer, 
   loss = None, 
   metrics = None, 
   loss_weights = None, 
   sample_weight_mode = None, 
   weighted_metrics = None, 
   target_tensors = None
)

重要的引數如下：

  • 損失函式
  • 最佳化器
  • 評估指標

編譯模型的示例程式碼如下：

from keras import losses 
from keras import optimizers 
from keras import metrics 

model.compile(loss = 'mean_squared_error',  
   optimizer = 'sgd', metrics = [metrics.categorical_accuracy])

其中：

  • 損失函式設定為**mean_squared_error**

  • 最佳化器設定為**sgd**

  • 評估指標設定為**metrics.categorical_accuracy**

模型訓練

模型使用NumPy陣列透過**fit()**進行訓練。此fit函式的主要目的是用於評估模型的訓練效果。它也可以用於繪製模型效能圖。其語法如下：

model.fit(X, y, epochs = , batch_size = )

這裡：

  • **X, y** - 用於評估資料的元組。

  • **epochs** - 模型在訓練期間需要評估的次數。

  • **batch_size** - 訓練例項數。

讓我們用一個簡單的NumPy隨機資料示例來演示這個概念。

建立資料

讓我們使用以下命令使用NumPy建立x和y的隨機資料：

import numpy as np 

x_train = np.random.random((100,4,8)) 
y_train = np.random.random((100,10))

現在，建立隨機驗證資料：

x_val = np.random.random((100,4,8)) 
y_val = np.random.random((100,10))

建立模型

讓我們建立一個簡單的順序模型：

from keras.models import Sequential model = Sequential()

新增層 (Add layers)

建立要新增到模型的層：

from keras.layers import LSTM, Dense 

# add a sequence of vectors of dimension 16 
model.add(LSTM(16, return_sequences = True)) 
model.add(Dense(10, activation = 'softmax'))

編譯模型

現在模型已定義。您可以使用以下命令進行編譯：

model.compile(
   loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)

應用fit()

現在我們應用fit()函式來訓練我們的資料：

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

建立多層感知器人工神經網路 (MLP ANN)

我們已經學習瞭如何建立、編譯和訓練Keras模型。

讓我們運用我們的知識建立一個基於MLP的簡單人工神經網路。

資料集模組

在建立模型之前，我們需要選擇一個問題，收集所需的資料並將資料轉換為NumPy陣列。收集資料後，我們可以準備模型並使用收集到的資料對其進行訓練。資料收集是機器學習中最困難的階段之一。Keras提供了一個特殊的模組datasets，用於下載線上機器學習資料以進行訓練。它從線上伺服器獲取資料，處理資料並將資料作為訓練集和測試集返回。讓我們檢查Keras資料集模組提供的資料。該模組中可用的資料如下：

  • CIFAR10 小型影像分類
  • CIFAR100 小型影像分類
  • IMDB 電影評論情感分類
  • 路透社新聞主題分類
  • MNIST 手寫數字資料庫
  • Fashion-MNIST 時尚服裝資料庫
  • 波士頓房價迴歸資料集

讓我們使用**MNIST 手寫數字資料庫** (或minst)作為我們的輸入。minst包含60,000張28x28的灰度影像。它包含10個數字。它還包含10,000張測試影像。

可以使用以下程式碼載入資料集：

from keras.datasets import mnist 

(x_train, y_train), (x_test, y_test) = mnist.load_data()

其中

  • **第1行**從keras資料集模組匯入**minst**。

  • **第3行**呼叫**load_data**函式，該函式將從線上伺服器獲取資料，並將其作為2個元組返回。第一個元組**(x_train, y_train)**表示形狀為**(樣本數, 28, 28)**的訓練資料及其形狀為**(樣本數,)**的數字標籤。第二個元組**(x_test, y_test)**表示形狀相同的測試資料。

其他資料集也可以使用類似的API獲取，每個API返回的資料也類似，只是資料的形狀不同。資料的形狀取決於資料的型別。

建立模型

讓我們選擇一個簡單的多層感知器(MLP)，如下所示，並嘗試使用Keras建立模型。

Create Model

模型的核心特徵如下：

  • 輸入層包含784個值 (28 x 28 = 784)。

  • 第一隱藏層，**Dense**包含512個神經元和'relu'啟用函式。

  • 第二隱藏層，**Dropout**的值為0.2。

  • 第三隱藏層，再次是Dense，包含512個神經元和'relu'啟用函式。

  • 第四隱藏層，**Dropout**的值為0.2。

  • 第五層也是最後一層包含10個神經元和'softmax'啟用函式。

  • 使用**categorical_crossentropy**作為損失函式。

  • 使用**RMSprop()**作為最佳化器。

  • 使用**accuracy**作為評估指標。

  • 使用128作為批次大小。

  • 使用20作為迭代次數。

步驟1 - 匯入模組

讓我們匯入必要的模組。

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np

步驟2 - 載入資料

讓我們匯入mnist資料集。

(x_train, y_train), (x_test, y_test) = mnist.load_data()

步驟3 - 處理資料

讓我們根據我們的模型更改資料集，以便它可以輸入到我們的模型中。

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

其中

  • **reshape**用於將輸入從(28, 28)元組重塑為(784,)

  • **to_categorical**用於將向量轉換為二元矩陣

步驟4 - 建立模型

讓我們建立實際的模型。

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))

步驟5 - 編譯模型

讓我們使用選擇的損失函式、最佳化器和評估指標來編譯模型。

model.compile(loss = 'categorical_crossentropy',     
   optimizer = RMSprop(), 
   metrics = ['accuracy'])

步驟6 - 訓練模型

讓我們使用**fit()**方法訓練模型。

history = model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 20, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

最終想法

我們已經建立了模型，載入了資料，並將資料訓練到模型中。我們仍然需要評估模型並預測未知輸入的輸出，這將在接下來的章節中學習。

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np 

(x_train, y_train), (x_test, y_test) = mnist.load_data() 

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10) 

model = Sequential() 
model.add(Dense(512, activation='relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', 
   optimizer = RMSprop(), 
   metrics = ['accuracy']) 

history = model.fit(x_train, y_train, 
   batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

執行應用程式將輸出以下內容：

Train on 60000 samples, validate on 10000 samples Epoch 1/20 
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453 
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023 
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744 
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599 
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504 
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20 
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438 
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20 
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391 
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364 
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308 
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289 
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279 
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260 
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257 
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229 
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20 
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235 
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214 
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219 
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190 
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197 
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198 
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828

Keras - 模型評估和模型預測

本章介紹Keras中的模型評估和模型預測。

讓我們首先了解模型評估。

模型評估

評估是在模型開發過程中檢查模型是否最適合給定問題和相應資料的一個過程。Keras模型提供了一個函式evaluate，用於執行模型評估。它有三個主要引數：

  • 測試資料
  • 測試資料標籤
  • verbose - true 或 false

讓我們使用測試資料評估我們在上一章中建立的模型。

score = model.evaluate(x_test, y_test, verbose = 0) 

print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

執行上述程式碼將輸出以下資訊。

0

測試準確率為98.28%。我們已經建立了一個識別手寫數字的最佳模型。積極的一面是，我們仍然可以改進我們的模型。

模型預測

**預測**是最後一步，也是我們期望的模型生成結果。Keras提供了一個方法predict來獲取訓練模型的預測結果。predict方法的簽名如下：

predict(
   x, 
   batch_size = None, 
   verbose = 0, 
   steps = None, 
   callbacks = None, 
   max_queue_size = 10, 
   workers = 1, 
   use_multiprocessing = False
)

這裡，除了第一個引數（指的是未知輸入資料）外，所有引數都是可選的。為了獲得正確的預測，應保持形狀不變。

讓我們使用以下程式碼對我們在上一章中建立的MLP模型進行預測：

pred = model.predict(x_test) 
pred = np.argmax(pred, axis = 1)[:5] 
label = np.argmax(y_test,axis = 1)[:5] 

print(pred) 
print(label)

這裡：

  • **第1行**使用測試資料呼叫predict函式。

  • **第2行**獲取前五個預測結果。

  • **第3行**獲取測試資料的前五個標籤。

  • **第5-6行**列印預測結果和實際標籤。

上述應用程式的輸出如下：

[7 2 1 0 4] 
[7 2 1 0 4]

兩個陣列的輸出相同，這表明我們的模型正確預測了前五張影像。

Keras - 卷積神經網路

讓我們將模型從MLP修改為**卷積神經網路 (CNN)**，用於我們之前的數字識別問題。

CNN可以表示為：

Convolution Neural Network

模型的核心特徵如下：

  • 輸入層包含(1, 8, 28)個值。

  • 第一層，Conv2D包含32個過濾器和‘relu’啟用函式，核心大小為(3,3)。

  • 第二層，Conv2D包含64個過濾器和‘relu’啟用函式，核心大小為(3,3)。

  • 第三層，MaxPooling池大小為(2, 2)。

  • 第五層，使用Flatten將所有輸入展平為一維。

  • 第六層，Dense包含128個神經元和‘relu’啟用函式。

  • 第七層，Dropout值為0.5。

  • 第八層也是最後一層包含10個神經元和‘softmax’啟用函式。

  • 使用**categorical_crossentropy**作為損失函式。

  • 使用Adadelta()作為最佳化器。

  • 使用**accuracy**作為評估指標。

  • 使用128作為批次大小。

  • 使用20作為迭代次數。

步驟1 - 匯入模組

讓我們匯入必要的模組。

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout, Flatten 
from keras.layers import Conv2D, MaxPooling2D 
from keras import backend as K 
import numpy as np

步驟2 - 載入資料

讓我們匯入mnist資料集。

(x_train, y_train), (x_test, y_test) = mnist.load_data()

步驟3 - 處理資料

讓我們根據我們的模型更改資料集，以便它可以輸入到我們的模型中。

img_rows, img_cols = 28, 28 

if K.image_data_format() == 'channels_first': 
   x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) 
   x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) 
   input_shape = (1, img_rows, img_cols) 
else: 
   x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) 
   x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) 
   input_shape = (img_rows, img_cols, 1) 
   
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 

y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

資料處理與MPL模型類似，只是輸入資料形狀和影像格式配置不同。

步驟4 - 建立模型

讓我們建立實際模型。

model = Sequential() 
model.add(Conv2D(32, kernel_size = (3, 3),  
   activation = 'relu', input_shape = input_shape)) 
model.add(Conv2D(64, (3, 3), activation = 'relu')) 
model.add(MaxPooling2D(pool_size = (2, 2))) 
model.add(Dropout(0.25)) model.add(Flatten()) 
model.add(Dense(128, activation = 'relu')) 
model.add(Dropout(0.5)) 
model.add(Dense(10, activation = 'softmax'))

步驟5 - 編譯模型

讓我們使用選擇的損失函式、最佳化器和評估指標來編譯模型。

model.compile(loss = keras.losses.categorical_crossentropy, 
   optimizer = keras.optimizers.Adadelta(), metrics = ['accuracy'])

步驟6 - 訓練模型

讓我們使用fit()方法訓練模型。

model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 12, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

執行應用程式將輸出以下資訊：

Train on 60000 samples, validate on 10000 samples Epoch 1/12 
60000/60000 [==============================] - 84s 1ms/step - loss: 0.2687 
- acc: 0.9173 - val_loss: 0.0549 - val_acc: 0.9827 Epoch 2/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0899 
- acc: 0.9737 - val_loss: 0.0452 - val_acc: 0.9845 Epoch 3/12 
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0666 
- acc: 0.9804 - val_loss: 0.0362 - val_acc: 0.9879 Epoch 4/12 
60000/60000 [==============================] - 81s 1ms/step - loss: 0.0564 
- acc: 0.9830 - val_loss: 0.0336 - val_acc: 0.9890 Epoch 5/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0472 
- acc: 0.9861 - val_loss: 0.0312 - val_acc: 0.9901 Epoch 6/12 
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0414 
- acc: 0.9877 - val_loss: 0.0306 - val_acc: 0.9902 Epoch 7/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0375 
-acc: 0.9883 - val_loss: 0.0281 - val_acc: 0.9906 Epoch 8/12 
60000/60000 [==============================] - 91s 2ms/step - loss: 0.0339 
- acc: 0.9893 - val_loss: 0.0280 - val_acc: 0.9912 Epoch 9/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325 
- acc: 0.9901 - val_loss: 0.0260 - val_acc: 0.9909 Epoch 10/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0284 
- acc: 0.9910 - val_loss: 0.0250 - val_acc: 0.9919 Epoch 11/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0287 
- acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9916 Epoch 12/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0265 
- acc: 0.9920 - val_loss: 0.0249 - val_acc: 0.9922

步驟7 - 評估模型

讓我們使用測試資料評估模型。

score = model.evaluate(x_test, y_test, verbose = 0) 

print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

執行以上程式碼將輸出以下資訊：

Test loss: 0.024936060590433316 
Test accuracy: 0.9922

測試精度為99.22%。我們已經建立了一個最佳模型來識別手寫數字。

步驟8 - 預測

最後，如下預測影像中的數字：

pred = model.predict(x_test) 
pred = np.argmax(pred, axis = 1)[:5] 
label = np.argmax(y_test,axis = 1)[:5] 

print(pred) 
print(label)

上述應用程式的輸出如下：

[7 2 1 0 4] 
[7 2 1 0 4]

兩個陣列的輸出相同，這表明我們的模型正確預測了前五張影像。

Keras - 使用多層感知器 (MPL) 進行迴歸預測

本章，讓我們編寫一個簡單的基於MPL的ANN進行迴歸預測。到目前為止，我們只進行了基於分類的預測。現在，我們將嘗試透過分析之前的（連續）值及其影響因素來預測下一個可能的值。

迴歸MPL可以表示如下：

MPL

模型的核心特徵如下：

  • 輸入層包含(13,)個值。

  • 第一層，Dense包含64個單元和‘relu’啟用函式，以及‘normal’核心初始化器。

  • 第二層，Dense包含64個單元和‘relu’啟用函式。

  • 輸出層，Dense包含1個單元。

  • 使用mse作為損失函式。

  • 使用RMSprop作為最佳化器。

  • 使用**accuracy**作為評估指標。

  • 使用128作為批次大小。

  • 使用500個epochs。

步驟1 - 匯入模組

讓我們匯入必要的模組。

import keras 

from keras.datasets import boston_housing 
from keras.models import Sequential 
from keras.layers import Dense 
from keras.optimizers import RMSprop 
from keras.callbacks import EarlyStopping 
from sklearn import preprocessing 
from sklearn.preprocessing import scale

步驟2 - 載入資料

讓我們匯入波士頓房價資料集。

(x_train, y_train), (x_test, y_test) = boston_housing.load_data()

這裡：

boston_housing是Keras提供的資料集。它代表波士頓地區的一組住房資訊，每個都有13個特徵。

步驟3 - 處理資料

讓我們根據我們的模型更改資料集，以便我們可以將其饋送到我們的模型中。資料可以使用以下程式碼更改：

x_train_scaled = preprocessing.scale(x_train) 
scaler = preprocessing.StandardScaler().fit(x_train) 
x_test_scaled = scaler.transform(x_test)

在這裡，我們使用sklearn.preprocessing.scale函式對訓練資料進行了歸一化。preprocessing.StandardScaler().fit函式返回一個標量，其中包含訓練資料的歸一化均值和標準差，我們可以使用scalar.transform函式將其應用於測試資料。這也會使用與訓練資料相同的設定來歸一化測試資料。

步驟4 - 建立模型

讓我們建立實際的模型。

model = Sequential() 
model.add(Dense(64, kernel_initializer = 'normal', activation = 'relu',
input_shape = (13,))) 
model.add(Dense(64, activation = 'relu')) model.add(Dense(1))

步驟5 - 編譯模型

讓我們使用選擇的損失函式、最佳化器和評估指標來編譯模型。

model.compile(
   loss = 'mse', 
   optimizer = RMSprop(), 
   metrics = ['mean_absolute_error']
)

步驟6 - 訓練模型

讓我們使用fit()方法訓練模型。

history = model.fit(
   x_train_scaled, y_train,    
   batch_size=128, 
   epochs = 500, 
   verbose = 1, 
   validation_split = 0.2, 
   callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20)]
)

在這裡，我們使用了回撥函式EarlyStopping。此回撥的目的是監控每個epoch期間的損失值，並將其與之前的epoch損失值進行比較，以找到訓練的改進。如果在patience次內沒有改進，則整個過程將停止。

執行應用程式將給出以下資訊作為輸出：

Train on 323 samples, validate on 81 samples Epoch 1/500 2019-09-24 01:07:03.889046: I 
tensorflow/core/platform/cpu_feature_guard.cc:142] 
Your CPU supports instructions that this 
TensorFlow binary was not co mpiled to use: AVX2 323/323 
[==============================] - 0s 515us/step - loss: 562.3129 
- mean_absolute_error: 21.8575 - val_loss: 621.6523 - val_mean_absolute_erro 
r: 23.1730 Epoch 2/500 
323/323 [==============================] - 0s 11us/step - loss: 545.1666 
- mean_absolute_error: 21.4887 - val_loss: 605.1341 - val_mean_absolute_error 
: 22.8293 Epoch 3/500 
323/323 [==============================] - 0s 12us/step - loss: 528.9944 
- mean_absolute_error: 21.1328 - val_loss: 588.6594 - val_mean_absolute_error 
: 22.4799 Epoch 4/500 
323/323 [==============================] - 0s 12us/step - loss: 512.2739 
- mean_absolute_error: 20.7658 - val_loss: 570.3772 - val_mean_absolute_error 
: 22.0853 Epoch 5/500
323/323 [==============================] - 0s 9us/step - loss: 493.9775 
- mean_absolute_error: 20.3506 - val_loss: 550.9548 - val_mean_absolute_error: 21.6547 
.......... 
.......... 
.......... 
Epoch 143/500 
323/323 [==============================] - 0s 15us/step - loss: 8.1004 
- mean_absolute_error: 2.0002 - val_loss: 14.6286 - val_mean_absolute_error: 
2. 5904 Epoch 144/500 
323/323 [==============================] - 0s 19us/step - loss: 8.0300 
- mean_absolute_error: 1.9683 - val_loss: 14.5949 - val_mean_absolute_error: 
2. 5843 Epoch 145/500 
323/323 [==============================] - 0s 12us/step - loss: 7.8704 
- mean_absolute_error: 1.9313 - val_loss: 14.3770 - val_mean_absolute_error: 2. 4996

步驟7 - 評估模型

讓我們使用測試資料評估模型。

score = model.evaluate(x_test_scaled, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

執行以上程式碼將輸出以下資訊：

Test loss: 21.928471583946077 Test accuracy: 2.9599233234629914

步驟7 - 評估模型

讓我們使用測試資料評估模型。

score = model.evaluate(x_test_scaled, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

執行以上程式碼將輸出以下資訊：

Test loss: 21.928471583946077 
Test accuracy: 2.9599233234629914

步驟8 - 預測

最後，使用測試資料進行預測，如下所示：

prediction = model.predict(x_test_scaled) 
print(prediction.flatten()) 
print(y_test)

上述應用程式的輸出如下：

[ 7.5612316 17.583357 21.09344 31.859276 25.055613 18.673872 26.600405 22.403967 19.060272 22.264952 
17.4191 17.00466 15.58924 41.624374 20.220217 18.985565 26.419338 19.837091 19.946192 36.43445 
12.278508 16.330965 20.701359 14.345301 21.741161 25.050423 31.046402 27.738455 9.959419 20.93039 
20.069063 14.518344 33.20235 24.735163 18.7274 9.148898 15.781284 18.556862 18.692865 26.045074 
27.954073 28.106823 15.272034 40.879818 29.33896 23.714525 26.427515 16.483374 22.518442 22.425386 
33.94826 18.831465 13.2501955 15.537227 34.639984 27.468002 13.474407 48.134598 34.39617 
22.8503124.042334 17.747198 14.7837715 18.187277 23.655672 22.364983 13.858193 22.710032 14.371148 
7.1272087 35.960033 28.247292 25.3014 14.477208 25.306196 17.891165 20.193708 23.585173 34.690193 
12.200583 20.102983 38.45882 14.741723 14.408362 17.67158 18.418497 21.151712 21.157492 22.693687 
29.809034 19.366991 20.072294 25.880817 40.814568 34.64087 19.43741 36.2591 50.73806 26.968863 43.91787 
32.54908 20.248306 ] [ 7.2 18.8 19. 27. 22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50. 20.8 24.3 24.2 
19.8 19.1 22.7 12. 10.2 20. 18.5 20.9 23. 27.5 30.1 9.5 22. 21.2 14.1 33.1 23.4 20.1 7.4 15.4 23.8 20.1 
24.5 33. 28.4 14.1 46.7 32.5 29.6 28.4 19.8 20.2 25. 35.4 20.3 9.7 14.5 34.9 26.6 7.2 50. 32.4 21.6 29.8 
13.1 27.5 21.2 23.1 21.9 13. 23.2 8.1 5.6 21.7 29.6 19.6 7. 26.4 18.9 20.9 28.1 35.4 10.2 24.3 43.1 17.6 
15.4 16.2 27.1 21.4 21.5 22.4 25. 16.6 18.6 22. 42.8 35.1 21.5 36. 21.9 24.1 50. 26.7 25. ]

兩個陣列的輸出大約有10-30%的差異，這表明我們的模型預測在合理的範圍內。

Keras - 使用 LSTM 迴圈神經網路 (RNN) 進行時間序列預測

在本章中，讓我們編寫一個簡單的基於長短期記憶 (LSTM) 的 RNN 來進行序列分析。序列是一組值，其中每個值對應於特定時間例項。讓我們考慮一個閱讀句子的簡單示例。閱讀和理解句子涉及按給定順序閱讀單詞，並嘗試理解每個單詞及其在給定上下文中的含義，最後以積極或消極的情緒理解句子。

在這裡，單詞被視為值，第一個值對應於第一個單詞，第二個值對應於第二個單詞，依此類推，並且順序將嚴格保持。序列分析經常用於自然語言處理中，以查詢給定文字的情緒分析。

讓我們建立一個LSTM模型來分析IMDB電影評論並找出其積極/消極情緒。

序列分析的模型可以表示如下：

Sequence Analysis

模型的核心特徵如下：

  • 使用具有128個特徵的嵌入層作為輸入層。

  • 第一層，Dense包含128個單元，正常dropout和迴圈dropout設定為0.2。

  • 輸出層，Dense包含1個單元和‘sigmoid’啟用函式。

  • 使用binary_crossentropy作為損失函式。

  • 使用adam作為最佳化器。

  • 使用**accuracy**作為評估指標。

  • 使用32作為批次大小。

  • 使用15個epochs。

  • 使用80作為單詞的最大長度。

  • 使用2000作為給定句子中單詞的最大數量。

步驟1：匯入模組

讓我們匯入必要的模組。

from keras.preprocessing import sequence 
from keras.models import Sequential 
from keras.layers import Dense, Embedding 
from keras.layers import LSTM 
from keras.datasets import imdb

步驟2：載入資料

讓我們匯入imdb資料集。

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words = 2000)

這裡：

  • imdb是Keras提供的資料集。它代表電影及其評論的集合。

  • num_words代表評論中單詞的最大數量。

步驟3：處理資料

讓我們根據我們的模型更改資料集，以便可以將其饋送到我們的模型中。可以使用以下程式碼更改資料：

x_train = sequence.pad_sequences(x_train, maxlen=80) 
x_test = sequence.pad_sequences(x_test, maxlen=80)

這裡：

sequence.pad_sequences將形狀為(data)的輸入資料列表轉換為形狀為(data, timesteps)的二維NumPy陣列。基本上，它將timesteps概念新增到給定資料中。它生成長度為maxlen的timesteps。

步驟4：建立模型

讓我們建立實際的模型。

model = Sequential() 
model.add(Embedding(2000, 128)) 
model.add(LSTM(128, dropout = 0.2, recurrent_dropout = 0.2)) 
model.add(Dense(1, activation = 'sigmoid'))

這裡：

我們使用了Embedding層作為輸入層，然後添加了LSTM層。最後，使用Dense層作為輸出層。

步驟5：編譯模型

讓我們使用選擇的損失函式、最佳化器和評估指標來編譯模型。

model.compile(loss = 'binary_crossentropy', 
   optimizer = 'adam', metrics = ['accuracy'])

步驟6：訓練模型

讓我們使用fit()方法訓練模型。

model.fit(
   x_train, y_train, 
   batch_size = 32, 
   epochs = 15, 
   validation_data = (x_test, y_test)
)

執行應用程式將輸出以下資訊：

Epoch 1/15 2019-09-24 01:19:01.151247: I 
tensorflow/core/platform/cpu_feature_guard.cc:142] 
Your CPU supports instructions that this 
TensorFlow binary was not co mpiled to use: AVX2 
25000/25000 [==============================] - 101s 4ms/step - loss: 0.4707 
- acc: 0.7716 - val_loss: 0.3769 - val_acc: 0.8349 Epoch 2/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.3058 
- acc: 0.8756 - val_loss: 0.3763 - val_acc: 0.8350 Epoch 3/15 
25000/25000 [==============================] - 91s 4ms/step - loss: 0.2100 
- acc: 0.9178 - val_loss: 0.5065 - val_acc: 0.8110 Epoch 4/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.1394 
- acc: 0.9495 - val_loss: 0.6046 - val_acc: 0.8146 Epoch 5/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0973 
- acc: 0.9652 - val_loss: 0.5969 - val_acc: 0.8147 Epoch 6/15 
25000/25000 [==============================] - 98s 4ms/step - loss: 0.0759 
- acc: 0.9730 - val_loss: 0.6368 - val_acc: 0.8208 Epoch 7/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0578 
- acc: 0.9811 - val_loss: 0.6657 - val_acc: 0.8184 Epoch 8/15 
25000/25000 [==============================] - 97s 4ms/step - loss: 0.0448 
- acc: 0.9850 - val_loss: 0.7452 - val_acc: 0.8136 Epoch 9/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0324 
- acc: 0.9894 - val_loss: 0.7616 - val_acc: 0.8162Epoch 10/15 
25000/25000 [==============================] - 100s 4ms/step - loss: 0.0247 
- acc: 0.9922 - val_loss: 0.9654 - val_acc: 0.8148 Epoch 11/15 
25000/25000 [==============================] - 99s 4ms/step - loss: 0.0169 
- acc: 0.9946 - val_loss: 1.0013 - val_acc: 0.8104 Epoch 12/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0154 
- acc: 0.9948 - val_loss: 1.0316 - val_acc: 0.8100 Epoch 13/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0113 
- acc: 0.9963 - val_loss: 1.1138 - val_acc: 0.8108 Epoch 14/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0106 
- acc: 0.9971 - val_loss: 1.0538 - val_acc: 0.8102 Epoch 15/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0090 
- acc: 0.9972 - val_loss: 1.1453 - val_acc: 0.8129 
25000/25000 [==============================] - 10s 390us/step

步驟7 - 評估模型

讓我們使用測試資料評估模型。

score, acc = model.evaluate(x_test, y_test, batch_size = 32) 
   
print('Test score:', score) 
print('Test accuracy:', acc)

執行以上程式碼將輸出以下資訊：

Test score: 1.145306069601178 
Test accuracy: 0.81292

Keras - 應用

Keras應用程式模組用於為深度神經網路提供預訓練模型。Keras模型用於預測、特徵提取和微調。本章詳細解釋了Keras應用程式。

預訓練模型

訓練模型包含兩部分：模型架構和模型權重。模型權重是大型檔案，因此我們必須從ImageNet資料庫下載並提取特徵。一些流行的預訓練模型列在下面：

  • ResNet
  • VGG16
  • MobileNet
  • InceptionResNetV2
  • InceptionV3

載入模型

Keras預訓練模型可以很容易地載入，如下所示：

import keras 
import numpy as np 

from keras.applications import vgg16, inception_v3, resnet50, mobilenet 

#Load the VGG model 
vgg_model = vgg16.VGG16(weights = 'imagenet') 

#Load the Inception_V3 model 
inception_model = inception_v3.InceptionV3(weights = 'imagenet') 

#Load the ResNet50 model 
resnet_model = resnet50.ResNet50(weights = 'imagenet') 

#Load the MobileNet model mobilenet_model = mobilenet.MobileNet(weights = 'imagenet')

載入模型後，我們可以立即將其用於預測目的。讓我們在接下來的章節中檢查每個預訓練模型。

使用ResNet模型進行即時預測

ResNet是一個預訓練模型。它使用ImageNet進行訓練。ResNet模型權重在ImageNet上預訓練。它具有以下語法：

keras.applications.resnet.ResNet50 (
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

這裡：

  • include_top指的是網路頂部的全連線層。

  • weights指的是在ImageNet上進行預訓練。

  • input_tensor指的是可選的Keras張量，用作模型的影像輸入。

  • input_shape指的是可選的形狀元組。此模型的預設輸入大小為224x224。

  • classes指的是可選的用於對影像進行分類的類別數。

讓我們透過編寫一個簡單的示例來了解模型：

步驟1：匯入模組

讓我們載入必要的模組，如下所示：

>>> import PIL 
>>> from keras.preprocessing.image import load_img 
>>> from keras.preprocessing.image import img_to_array 
>>> from keras.applications.imagenet_utils import decode_predictions 
>>> import matplotlib.pyplot as plt 
>>> import numpy as np 
>>> from keras.applications.resnet50 import ResNet50 
>>> from keras.applications import resnet50

步驟2：選擇輸入

讓我們選擇一個輸入影像，Lotus，如下所示：

>>> filename = 'banana.jpg' 
>>> ## load an image in PIL format 
>>> original = load_img(filename, target_size = (224, 224)) 
>>> print('PIL image size',original.size)
PIL image size (224, 224) 
>>> plt.imshow(original) 
<matplotlib.image.AxesImage object at 0x1304756d8> 
>>> plt.show()

在這裡，我們載入了一個影像(banana.jpg)並顯示它。

步驟3：將影像轉換為NumPy陣列

讓我們將我們的輸入Banana轉換為NumPy陣列，以便可以將其傳遞給模型以進行預測。

>>> #convert the PIL image to a numpy array 
>>> numpy_image = img_to_array(original) 

>>> plt.imshow(np.uint8(numpy_image)) 
<matplotlib.image.AxesImage object at 0x130475ac8> 

>>> print('numpy array size',numpy_image.shape) 
numpy array size (224, 224, 3) 

>>> # Convert the image / images into batch format 
>>> image_batch = np.expand_dims(numpy_image, axis = 0) 

>>> print('image batch size', image_batch.shape) 
image batch size (1, 224, 224, 3)
>>>

步驟4：模型預測

讓我們將我們的輸入饋送到模型以獲取預測

>>> prepare the image for the resnet50 model >>> 
>>> processed_image = resnet50.preprocess_input(image_batch.copy()) 

>>> # create resnet model 
>>>resnet_model = resnet50.ResNet50(weights = 'imagenet') 
>>> Downloavding data from https://github.com/fchollet/deep-learning-models/releas
es/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5 
102858752/102853048 [==============================] - 33s 0us/step 

>>> # get the predicted probabilities for each class 
>>> predictions = resnet_model.predict(processed_image) 

>>> # convert the probabilities to class labels 
>>> label = decode_predictions(predictions) 
Downloading data from https://storage.googleapis.com/download.tensorflow.org/
data/imagenet_class_index.json 
40960/35363 [==================================] - 0s 0us/step 

>>> print(label)

輸出

[
   [
      ('n07753592', 'banana', 0.99229723), 
      ('n03532672', 'hook', 0.0014551596), 
      ('n03970156', 'plunger', 0.0010738898), 
      ('n07753113', 'fig', 0.0009359837) , 
      ('n03109150', 'corkscrew', 0.00028538404)
   ]
]

在這裡，模型正確地將影像預測為香蕉。

Keras - 預訓練模型

在本章中，我們將學習Keras中的預訓練模型。讓我們從VGG16開始。

VGG16

VGG16是另一個預訓練模型。它也使用ImageNet進行訓練。載入模型的語法如下：

keras.applications.vgg16.VGG16(
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

此模型的預設輸入大小為224x224。

MobileNetV2

MobileNetV2是另一個預訓練模型。它也使用ImageNet進行訓練。

載入模型的語法如下：

keras.applications.mobilenet_v2.MobileNetV2 (
   input_shape = None, 
   alpha = 1.0, 
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   pooling = None, 
   classes = 1000
)

這裡：

alpha控制網路的寬度。如果值小於1，則減少每一層中的過濾器數量。如果值大於1，則增加每一層中的過濾器數量。如果alpha = 1，則每一層都使用論文中的預設過濾器數量。

此模型的預設輸入大小為224x224。

InceptionResNetV2

InceptionResNetV2是另一個預訓練模型。它也使用ImageNet進行訓練。載入模型的語法如下：

keras.applications.inception_resnet_v2.InceptionResNetV2 (
   include_top = True, 
   weights = 'imagenet',
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000)

此模型可以使用“channels_first”資料格式（通道、高度、寬度）或“channels_last”資料格式（高度、寬度、通道）構建。

此模型的預設輸入大小為299x299。

InceptionV3

InceptionV3是另一個預訓練模型。它也使用ImageNet進行訓練。載入模型的語法如下：

keras.applications.inception_v3.InceptionV3 (
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

這裡：

此模型的預設輸入大小為299x299。

結論

Keras是一個非常簡單、可擴充套件且易於實現的神經網路API，可用於構建具有高階抽象的深度學習應用程式。Keras是深度學習模型的最佳選擇。

列印頁面
上一頁
下一頁
廣告
© . All rights reserved.