使用 ONNX 與混合精確度技術最佳化 PyTorch 模型訓練及佈署

– 13 分鐘閱讀

隨著深度學習模型日益複雜，模型的訓練、最佳化和佈署變得越來越重要。本文將介紹如何使用 ONNX 進行模型序列化和轉換，以及如何使用混合精確度訓練技術來加速訓練並降低記憶體需求。同時，我們也將探討如何使用 Flask 和 ngrok 佈署模型，以及如何使用 Gradio 建立機器學習網頁應用。這些技術可以幫助我們更有效地管理和佈署深度學習模型，提高模型的效能和可用性。深度學習模型的訓練和佈署通常涉及多個框架和平臺，ONNX 提供了跨框架的模型表示，簡化了模型的轉換和佈署流程。混合精確度訓練技術可以有效地利用 GPU 資源，加速訓練過程並降低記憶體消耗，對於大型模型的訓練尤為重要。Flask 和 ngrok 提供了便捷的模型佈署方式，可以快速搭建線上服務，方便模型的測試和使用。Gradio 則簡化了機器學習網頁應用的開發流程，方便使用者與模型互動。

序列化和反序列化模型

以下是使用ONNX序列化和反序列化模型的示例：

import onnx

# 序列化模型
with open('model.onnx', 'wb') as f:
    f.write(onnx_model.SerializeToString())

# 反序列化模型
with open('model.onnx', 'rb') as f:
    onnx_model = onnx.load(f)

使用ONNX進行模型轉換

ONNX可以用於將模型從一個框架轉換為另一個框架。以下是使用ONNX將PyTorch模型轉換為ONNX模型的示例：

import torch
from torchvision.models import mobilenet_v3_small, MobileNet_V3_Small_Weights
import torch.onnx as onnx

# 載入預訓練模型
torch_model = mobilenet_v3_small(weights=MobileNet_V3_Small_Weights.DEFAULT)

# 匯出模型為ONNX格式
onnx.export(
    model=torch_model,
    args=torch.randn(1, 3, 224, 224),
    f="torch_model.onnx",
    export_params=True
)

在上面的示例中，torch.onnx.export函式用於將PyTorch模型匯出為ONNX格式。args引數指定了一個虛擬的輸入張量，該張量用於推斷模型的計算圖結構和張量大小。export_params引數指定是否匯出模型的權重。

載入和驗證ONNX模型

以下是使用ONNX載入和驗證模型的示例：

import onnx

# 載入ONNX模型
onnx_model = onnx.load("torch_model.onnx")

# 驗證模型
onnx.checker.check_model(onnx_model)

在上面的示例中，onnx.load函式用於載入ONNX模型，onnx.checker.check_model函式用於驗證模型的正確性。

圖表翻譯：

  graph LR
    A[PyTorch模型] -->|匯出|> B[ONNX模型]
    B -->|載入|> C[ONNX框架]
    C -->|驗證|> D[模型驗證]

在上面的圖表中，PyTorch模型被匯出為ONNX模型，然後被載入ONNX框架中。最後，模型被驗證以確保其正確性。

使用 ONNX 進行模型序列化

ONNX（Open Neural Network Exchange）是一種開源的模型序列化格式，允許使用者將不同框架（如 PyTorch、TensorFlow）訓練的模型轉換為統一的格式，以便於模型的佈署和推理。下面我們將介紹如何使用 ONNX 將 PyTorch 和 TensorFlow 模型進行序列化。

PyTorch 模型序列化

首先，我們需要安裝 onnx 套件：

pip install onnx

然後，我們可以使用 onnx.load() 函式將 PyTorch 模型載入為 ONNX 模型：

import onnx

torch_model_onnx = onnx.load('torch_model.onnx')
onnx.checker.check_model(torch_model_onnx)

TensorFlow 模型序列化

TensorFlow 沒有內建的 ONNX 序列化支援，因此我們需要使用 tf2onnx 套件：

import tensorflow as tf
import tf2onnx

tf_model = tf.keras.applications.MobileNetV3Small(
    weights='imagenet',
    input_shape=(224, 224, 3),
)

model_onnx = tf2onnx.convert.from_tensorflow(
    model=tf_model,
    input_signature=[tf.TensorSpec([1, 224, 224, 3])])
onnx.save(model_onnx, 'tf_model.onnx')

模型視覺化

我們可以使用 Netron 進行模型視覺化：

netron torch_model.onnx

Netron 支援 ONNX、TensorFlow Lite 和 PyTorch 等格式。

Machine Learning Operations (MLOps)

MLOps 是一種將機器學習模型佈署到生產環境的方法。它涉及模型的訓練、測試、佈署和監控等過程。

Introducing TensorBoard

TensorBoard 是一個根據 Web 的工具，提供了機器學習實驗的視覺化和工具。它支援 TensorFlow 和 PyTorch 等框架。

TensorBoard 的功能

  • Metrics（如損失和準確率）追蹤和視覺化
  • 模型圖視覺化
  • 時間序列直方圖
  • 低維嵌入投影

使用 TensorBoard

首先，我們需要安裝 tensorboard 套件：

pip install tensorboard

然後，我們可以使用 tensorboard 命令啟動 TensorBoard 服務：

tensorboard --logdir ./logs

接著，我們可以在瀏覽器中存取 http://localhost:6006 來檢視 TensorBoard 的介面。

在 Keras 中使用 TensorBoard

我們可以在 Keras 中使用 TensorBoard 回呼函式來將模型的訓練過程記錄到日誌檔案中：

from tensorflow.keras.callbacks import TensorBoard

tensorboard = TensorBoard(log_dir='./logs')

model.fit(X_train, y_train, epochs=10, callbacks=[tensorboard])

這樣，我們就可以在 TensorBoard 中檢視模型的訓練過程了。

使用TensorBoard進行模型訓練視覺化

TensorBoard是一個強大的視覺化工具，能夠幫助我們瞭解模型的訓練過程和效能。下面，我們將介紹如何使用TensorBoard進行模型訓練視覺化。

Keras中的TensorBoard

在Keras中，使用TensorBoard進行模型訓練視覺化非常簡單。首先，我們需要建立一個TensorBoard回呼函式：

tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs/tb/' + datetime.datetime.now().strftime('%Y%m%d-%H%M%S'),
    update_freq='epoch',
    histogram_freq=1,
    write_graph=True,
    write_images=True,
    write_steps_per_second=True,
    profile_batch=0,
    embeddings_freq=0
)

這個回呼函式會將模型的訓練過程記錄到指定的日誌檔案中。然後，我們可以使用model.fit()方法進行模型訓練，並將TensorBoard回呼函式增加到回呼函式列表中：

model.fit(
    train_batches,
    epochs=epochs,
    validation_data=test_batches,
    callbacks=[tensorboard_callback],
    steps_per_epoch=steps_per_epoch,
    validation_steps=validation_steps
)

PyTorch中的TensorBoard

在PyTorch中，使用TensorBoard進行模型訓練視覺化需要使用torch.utils.tensorboard模組。首先，我們需要建立一個SummaryWriter例項：

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter(
    log_dir='logs/tb/' + datetime.datetime.now().strftime('%Y%m%d-%H%M%S')
)

然後，我們可以使用writer例項將模型的訓練過程記錄到日誌檔案中。例如，我們可以使用writer.add_scalar()方法將模型的損失函式記錄到日誌檔案中：

writer.add_scalar('loss', loss.item(), global_step=step)

TensorBoard UI

TensorBoard提供了一個強大的UI，能夠幫助我們視覺化模型的訓練過程和效能。下面是一個例子：

Accuracy

TensorBoard可以顯示模型的準確率隨著訓練過程的變化。下面是一個例子：

  • Train Accuracy：模型在訓練集上的準確率
  • Test Accuracy：模型在測試集上的準確率

Loss

TensorBoard可以顯示模型的損失函式隨著訓練過程的變化。下面是一個例子：

  • Train Loss：模型在訓練集上的損失函式
  • Test Loss：模型在測試集上的損失函式

Weights

TensorBoard可以顯示模型的權重隨著訓練過程的變化。下面是一個例子：

  • Weights：模型的權重

Graph

TensorBoard可以顯示模型的計算圖。下面是一個例子：

  • Graph：模型的計算圖

使用TensorBoard進行模型視覺化

TensorBoard是一種強大的視覺化工具，能夠幫助我們瞭解模型的訓練過程和效能。下面是如何使用TensorBoard進行模型視覺化的步驟：

首先，需要匯入TensorBoard的相關模組：

import torch
from torch.utils.tensorboard import SummaryWriter

接下來，需要建立一個SummaryWriter物件，該物件負責將模型的訓練過程和效能資料寫入TensorBoard的日誌檔案中：

writer = SummaryWriter()

然後，需要在模型的訓練迴圈中增加模型的圖形和訓練資料。例如：

model = mobilenet_v3_small(weights=MobileNet_V3_Small_Weights.IMAGENET1K_V1)
for i, (inputs, labels) in enumerate(data_loader):
    # 訓練迴圈程式碼
    writer.add_graph(model, inputs)
    writer.add_scalar('train/accuracy', total_acc, global_step=epoch)
    writer.add_scalar('train/loss', total_loss, global_step=epoch)

這樣，就可以使用TensorBoard進行模型視覺化了。TensorBoard提供了多種視覺化工具，包括圖形、標量、影像、張量、直方圖等。

開發邊緣裝置的神經網路模型

TensorFlow Lite（TF Lite）是一種強大的工具，能夠幫助我們開發邊緣裝置的神經網路模型。TF Lite提供了多種功能，包括：

  • 支援多種平臺和語言，包括Android、iOS、Web和Python。
  • 最佳化效能。
  • 提供端對端的解決方案管道。
  • 支援自定義操作。

TF Lite模型可以透過以下方式開發：

  • 選擇一個現有的模型，並使用Model Maker對其進行特徵工程和轉移學習。
  • 將一個完整的TensorFlow模型轉換為TF Lite格式。

TF Lite模型可以包含可選的元資料，包括：

  • 人類可讀的部分：提供模型的額外訊息。
  • 輸入訊息：描述輸入資料的格式和必要的預處理步驟。
  • 輸出訊息：描述輸出資料的格式和必要的後處理步驟。

這些元資料可以被用於建立模型的包裝器，以便在目標平臺上使用。

使用Model Maker進行模型訓練

Model Maker是一種強大的工具，能夠幫助我們使用TF Lite模型進行模型訓練。下面是如何使用Model Maker進行模型訓練的步驟：

首先，需要匯入Model Maker的相關模組：

from mediapipe_model_maker import image_classifier

接下來，需要建立一個Dataset物件，該物件負責載入和預處理資料：

dataset = image_classifier.Dataset.from_folder(dataset_path)

然後，需要將資料分割為訓練集和驗證集：

train_data, validation_data = dataset.split(0.9)

這樣，就可以使用Model Maker進行模型訓練了。Model Maker提供了多種功能，包括特徵工程、轉移學習和模型評估。

  flowchart TD
    A[開始] --> B[載入資料]
    B --> C[預處理資料]
    C --> D[分割資料]
    D --> E[模型訓練]
    E --> F[模型評估]

圖表翻譯：

此圖表示使用Model Maker進行模型訓練的流程。首先，需要載入資料，然後進行預處理，接下來分割資料為訓練集和驗證集，最後進行模型訓練和評估。

內容解密：

在這個例子中，我們使用Model Maker進行模型訓練。首先，需要匯入Model Maker的相關模組，然後建立一個Dataset物件，負責載入和預處理資料。接下來，需要將資料分割為訓練集和驗證集，最後進行模型訓練和評估。Model Maker提供了多種功能，包括特徵工程、轉移學習和模型評估。

機器學習操作（MLOps）簡介

機器學習操作（MLOps）是一種將機器學習模型從開發到佈署的過程。它涉及到資料準備、模型訓練、模型評估、模型佈署和模型監控等步驟。

機器學習模型開發

在機器學習模型開發中，首先需要準備資料。這包括資料收集、資料預處理和資料分割等步驟。接下來，需要定義模型的超引數，例如訓練次數、批次大小等。然後，需要選擇合適的模型，例如EfficientNet等。

模型訓練

模型訓練是機器學習中的一個重要步驟。它涉及到使用訓練資料對模型進行訓練，目的是使模型能夠學習到資料中的模式和關係。在訓練過程中，需要監控模型的效能，例如準確率、損失函式等。

模型評估

模型評估是用於評估模型在測試資料上的效能。它涉及到使用測試資料對模型進行評估，目的是評估模型的泛化能力。

模型佈署

模型佈署是指將訓練好的模型佈署到生產環境中。這涉及到將模型轉換為可執行的格式，例如TFLite等。

模型監控

模型監控是指在模型佈署後，對模型的效能進行監控和評估。這涉及到收集模型的執行資料，例如預測結果、輸入資料等，然後使用這些資料對模型的效能進行評估和最佳化。

MediaPipe Python API

MediaPipe是一個開源的機器學習框架，提供了一個簡單的API用於機器學習模型的開發和佈署。MediaPipe Python API提供了一個簡單的方式用於建立和佈署機器學習模型。

ImageClassifier

ImageClassifier是一個MediaPipe的類別，提供了一個簡單的方式用於影像分類別。它支援多種模型，包括EfficientNet等。

模型建立和訓練

建立一個ImageClassifier模型需要定義模型的超引數，例如訓練次數、批次大小等。然後，需要選擇合適的模型，例如EfficientNet等。接下來，需要訓練模型，使用訓練資料對模型進行訓練。

模型評估和佈署

模型評估是用於評估模型在測試資料上的效能。它涉及到使用測試資料對模型進行評估，目的是評估模型的泛化能力。模型佈署是指將訓練好的模型佈署到生產環境中。

內容解密：

以上內容介紹了機器學習操作（MLOps）的基本概念和過程，包括資料準備、模型訓練、模型評估、模型佈署和模型監控等步驟。MediaPipe Python API和ImageClassifier是兩個重要的工具，提供了一個簡單的方式用於機器學習模型的開發和佈署。

圖表翻譯：

  graph LR
    A[資料準備] --> B[模型訓練]
    B --> C[模型評估]
    C --> D[模型佈署]
    D --> E[模型監控]

此圖表示了機器學習操作（MLOps）的基本過程，包括資料準備、模型訓練、模型評估、模型佈署和模型監控等步驟。

混合精確度訓練最佳化

混合精確度訓練是一種在深度學習中常用的技術，能夠加速訓練過程並減少記憶體使用。以下是使用 PyTorch 實作混合精確度訓練的步驟：

啟用混合精確度訓練

要啟用混合精確度訓練，需要使用 torch.cuda.amp 模組。首先，需要建立一個 GradScaler 物件，該物件負責管理梯度的縮放：

scaler = torch.cuda.amp.GradScaler()

自動混合精確度訓練

接下來，需要使用 torch.autocast 上下文管理器來啟用自動混合精確度訓練。這個上下文管理器會自動將模型的輸入和輸出轉換為適合的資料型別：

with torch.autocast(device_type=device, dtype=torch.float16):
    # forward
    inputs = inputs.to(device)
    labels = labels.to(device)
    outputs = model(inputs)
    loss = loss_fn(outputs, labels)

在這個上下文管理器中，模型的輸入和輸出會被自動轉換為 torch.float16 資料型別，這可以加速訓練過程。

反向傳播

在反向傳播過程中，需要使用 scaler 物件來縮放梯度：

# backward with scaler
scaler.scale(loss).backward()

這個步驟會將梯度縮放到適合的範圍，以避免梯度爆炸。

更新模型引數

最後，需要更新模型引數：

optimizer.step()

這個步驟會使用更新的梯度來更新模型引數。

完整程式碼

以下是完整的 train_model 函式程式碼：

def train_model(model, loss_fn, optimizer, data_loader):
    scaler = torch.cuda.amp.GradScaler()
    for i, (inputs, labels) in enumerate(data_loader):
        optimizer.zero_grad()
        with torch.autocast(device_type=device, dtype=torch.float16):
            inputs = inputs.to(device)
            labels = labels.to(device)
            outputs = model(inputs)
            loss = loss_fn(outputs, labels)
        scaler.scale(loss).backward()
        optimizer.step()

這個程式碼會啟用混合精確度訓練，並使用 GradScaler 物件來管理梯度的縮放。

圖表翻譯：

  flowchart TD
    A[啟用混合精確度訓練] --> B[自動混合精確度訓練]
    B --> C[反向傳播]
    C --> D[更新模型引數]
    D --> E[完成訓練]

這個圖表展示了混合精確度訓練的過程，包括啟用混合精確度訓練、自動混合精確度訓練、反向傳播和更新模型引數。

混合精確度訓練與模型佈署

在深度學習中，混合精確度訓練是一種可以提高訓練速度和減少記憶體使用的技術。它結合了兩種不同的資料型別：float16和float32。在PyTorch中，我們可以使用torch.autocast和torch.cuda.amp.GradScaler來實作混合精確度訓練。

混合精確度訓練

torch.autocast是一種上下文管理器，可以讓我們指定一段程式碼執行在混合精確度模式下。它可以自動將資料型別轉換為float16或float32，以便在CUDA裝置上執行。

with torch.autocast(device_type='cuda', dtype=torch.float16):
    # 在這裡執行混合精確度程式碼
    loss = model(input)
    loss.backward()

torch.cuda.amp.GradScaler是一種梯度縮放器，可以用來防止梯度值在反向傳播中被截斷為零。它可以自動將梯度值乘以一個縮放因子，以便在反向傳播中保持精確度。

scaler = torch.cuda.amp.GradScaler()
with torch.autocast(device_type='cuda', dtype=torch.float16):
    # 在這裡執行混合精確度程式碼
    loss = model(input)
    loss.backward()
scaler.step(optimizer)
scaler.update()

模型佈署

模型佈署是指將訓練好的模型佈署到生產環境中，以便可以被使用者存取和使用。在這裡，我們將介紹兩種基本的模型佈署方法：使用Flask佈署模型和使用ngrok佈署模型。

使用Flask佈署模型

Flask是一種輕量級的Web框架，可以用來建立簡單的Web應用程式。下面是一個使用Flask佈署模型的例子：

from flask import Flask, request, send_file
app = Flask(__name__)

# 載入模型
model = ...

@app.route('/text-to-image', methods=['POST', 'GET'])
def predict():
    if request.method in ('POST', 'GET'):
        # 處理請求和生成圖片
        image = ...
        return send_file(image, mimetype='image/jpeg')

if __name__ == '__main__':
    app.run()

使用ngrok佈署模型

ngrok是一種可以用來將本地服務暴露到外網的工具。下面是一個使用ngrok佈署模型的例子：

from flask import Flask, request, send_file
from flask_ngrok import run_with_ngrok
app = Flask(__name__)
run_with_ngrok(app)

# 載入模型
model = ...

@app.route('/text-to-image', methods=['POST', 'GET'])
def predict():
    if request.method in ('POST', 'GET'):
        # 處理請求和生成圖片
        image = ...
        return send_file(image, mimetype='image/jpeg')

if __name__ == '__main__':
    app.run()

這裡，我們使用flask-ngrok函式庫來將Flask應用程式佈署到ngrok上。這樣，外網使用者就可以存取我們的模型了。

使用 Flask 和 Stable Diffusion 建立文字到影像的 API

以下是使用 Flask 和 Stable Diffusion 建立文字到影像的 API 的步驟：

安裝必要的套件

首先，需要安裝 Flask 和 Stable Diffusion 的套件。可以使用 pip 安裝：

pip install flask torch torchvision

建立 Flask API

建立一個新的 Python 檔案，例如 app.py，並加入以下程式碼：

from flask import Flask, request, send_file
from PIL import Image
import io
import torch
from diffusers import StableDiffusionPipeline

app = Flask(__name__)

# 初始化 Stable Diffusion pipeline
sd_pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")

@app.route("/text-to-image", methods=["POST", "GET"])
def text_to_image():
    prompt = request.get_json().get("prompt")
    
    if prompt and prompt.strip():
        # 生成影像
        image = sd_pipe(prompt, num_inference_steps=100).images[0]
        
        # 將影像儲存到 BytesIO
        image_io = io.BytesIO()
        image.save(image_io, format="PNG")
        image_io.seek(0)
        
        # 回傳影像
        return send_file(image_io, as_attachment=False, mimetype="image/png")
    else:
        # 回傳錯誤訊息
        return "Invalid prompt", 500

if __name__ == "__main__":
    app.run()

測試 API

可以使用 requests 套件測試 API。建立一個新的 Python 檔案，例如 test.py，並加入以下程式碼：

import requests

response = requests.post(
    "http://localhost:5000/text-to-image",
    json={"prompt": "High quality photo of a racing car on a track"}
)

# 顯示影像
from PIL import Image
image = Image.open(io.BytesIO(response.content))
image.show()

使用 ngrok 進行測試

可以使用 ngrok 進行測試。首先，需要安裝 ngrok：

pip install pyngrok

然後，建立一個新的 Python 檔案，例如 ngrok_test.py，並加入以下程式碼：

import requests
from pyngrok import ngrok

# 啟動 ngrok
http_tunnel = ngrok.connect(5000)

# 測試 API
response = requests.post(
    http_tunnel.public_url + "/text-to-image",
    json={"prompt": "High quality photo of a racing car on a track"}
)

# 顯示影像
from PIL import Image
image = Image.open(io.BytesIO(response.content))
image.show()

這樣就可以使用 ngrok 進行測試了。

使用 Gradio 建立機器學習網頁應用

Gradio 是一個強大的工具，允許我們建立機器學習網頁應用，並將其佈署在 Hugging Face Spaces 上。以下是如何使用 Gradio 建立一個簡單的機器學習網頁應用。

從使用者經驗視角來看，本文深入探討了從模型的序列化、轉換、載入、驗證到佈署和監控的完整流程，並涵蓋了混合精確度訓練、TensorBoard 視覺化、以及使用 Flask 和 Gradio 建立網頁應用等實務技巧。分析顯示，ONNX 的跨框架相容性有效降低了模型佈署的門檻，而混合精確度訓練則在效能和資源消耗之間取得了平衡。然而，模型佈署到邊緣裝置仍需考量硬體限制和效能最佳化。展望未來，隨著 MLOps 工具鏈的日益成熟，模型開發、佈署和監控的效率將持續提升，同時更精細化的效能調校和模型壓縮技術也將成為重要的發展方向。玄貓認為，掌握這些關鍵技術，將賦予開發者構建和佈署高效能機器學習應用的能力，並在快速變化的技術浪潮中保持競爭優勢。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。