T:0000
深度學習是一種基於人工神經網路的機器學習方法，使用多層的神經網路來自動學習數據的特徵。以下是幾種常見的深度學習演算法：
前饋神經網路是最基本的深度學習架構，其中數據沿著一個方向通過網路，不會形成循環。FNN 對於分類和迴歸問題非常有效。
CNN 是專門用於處理圖像數據的深度學習網路，它使用卷積層來自動提取圖像中的空間特徵。常用於圖像分類、物體檢測等任務。
RNN 可以處理序列數據，如時間序列、語言模型等。它利用循環結構使網路能夠記憶之前的輸入，廣泛應用於語音識別、自然語言處理等。
LSTM 是 RNN 的一種改進版本，解決了傳統 RNN 中的長期依賴問題，使其能夠在較長的序列中保持關鍵信息。
自編碼器是一種無監督學習方法，用於降維和數據去噪。它將輸入數據壓縮到一個低維的隱藏層，然後嘗試還原原始數據。
GAN 包含一個生成器和一個鑑別器，生成器試圖生成逼真的數據，而鑑別器則試圖區分真實數據和生成數據。GAN 被廣泛應用於圖像生成、風格遷移等任務。
Transformer 是一種基於注意力機制的模型，尤其在自然語言處理中表現突出。它能夠處理長序列數據，並且與 RNN 相比，訓練速度更快。
TensorFlow 是由 Google Brain 團隊開發的開源機器學習框架。它採用資料流圖（Data Flow Graphs）的概念，讓開發者能夠構建複雜的類神經網路。其名稱源自於「Tensor」（張量，即多維陣列）在運算圖中的「Flow」（流動）。
TensorFlow 的設計分為多個層次，以平衡靈活性與開發效率：
在 TensorFlow 中開發模型的典型流程如下：
| 階段 | 說明 |
|---|---|
| 資料準備 | 使用 tf.data API 進行資料讀取、清洗與預處理。 |
| 建立模型 | 透過 tf.keras.Sequential 或 Functional API 定義網路層。 |
| 編譯與訓練 | 設定優化器 (Optimizer) 與損失函數 (Loss Function)，並執行 model.fit()。 |
| 評估與部署 | 驗證模型準確度，並匯出為 SavedModel 格式進行部署。 |
以下是使用 Keras 建立簡單線性回歸模型的範例：
import tensorflow as tf
import numpy as np
# 建立模型
model = tf.keras.Sequential([
tf.keras.layers.Dense(units=1, input_shape=[1])
])
# 編譯模型
model.compile(optimizer='sgd', loss='mean_squared_error')
# 準備測試資料
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)
# 訓練模型
model.fit(xs, ys, epochs=500, verbose=0)
# 進行預測
print("預測結果：", model.predict([10.0]))
Keras 是一個用 Python 編寫的高階神經網路 API，旨在實現快速實驗。它最初由 François Chollet 開發，現在作為 TensorFlow 的官方高階介面（tf.keras）。Keras 的核心設計原則是使用者友好、模組化以及易於擴充，讓開發者能以最少的程式碼構建深度學習模型。
| 方式 | 特點 | 適用場景 |
|---|---|---|
| Sequential API | 簡單的層堆疊，一層接著一層。 | 單輸入、單輸出的線性堆疊模型。 |
| Functional API | 可定義複雜圖形，支援多輸入/輸出。 | 殘差網路（ResNet）、多分支模型。 |
| Subclassing | 透過繼承 Model 類別自定義行為。 |
需要完全控制前向傳播邏輯的研發場景。 |
在 Keras 中完成一個機器學習任務通常包含以下五個步驟：
fit() 函數餵入資料進行學習。evaluate() 檢查在測試集上的表現。predict() 產出新資料的預測結果。以下是使用 Keras 構建簡單影像分類網路（如 MNIST）的標準寫法：
from tensorflow.keras import layers, models
# 1. 定義 Sequential 模型
model = models.Sequential([
layers.Flatten(input_shape=(28, 28)), # 輸入層
layers.Dense(128, activation='relu'), # 隱藏層
layers.Dropout(0.2), # 防止過擬合
layers.Dense(10, activation='softmax') # 輸出層
])
# 2. 編譯
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 3. 訓練 (假設已有 x_train, y_train)
# model.fit(x_train, y_train, epochs=5)
自 TensorFlow 2.0 起，Keras 已成為其預設的高階 API。這意味著您可以使用 Keras 的簡單語法，同時享有 TensorFlow 底層的分散式訓練、TPU 加速以及強大的部署能力（如 TensorFlow Serving）。
在 Keras 中，Layer 是建構神經網路的基本單位。每個圖層封裝了特定的計算邏輯（如矩陣乘法）與狀態（權重權重 weights）。模型本質上就是將多個圖層連接起來，形成資料流向的結構。
| 類別 | 常用圖層 (tf.keras.layers) | 主要功能 |
|---|---|---|
| 基礎層 (Core) | Dense |
全連接層，執行 \(y = f(Wx + b)\)。 |
| 卷積層 (Convolutional) | Conv2D, Conv1D |
用於特徵提取，常用於影像或時間序列。 |
| 池化層 (Pooling) | MaxPooling2D, AveragePooling2D |
降維並減少計算量，保留關鍵特徵。 |
| 循環層 (Recurrent) | LSTM, GRU, SimpleRNN |
處理序列資料（如文字、股價），具備記憶性。 |
| 正規化層 (Regularization) | Dropout, BatchNormalization |
防止過擬合（Overfitting）並加速收斂。 |
'relu', 'sigmoid', 'softmax'），決定輸出的非線性轉換。除了計算特徵的圖層外，還有一些用於轉換資料結構的特殊層：
以下展示了在一個影像處理模型中，各類圖層如何協作：
from tensorflow.keras import layers, models
model = models.Sequential([
# 卷積層提取空間特徵
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
# 池化層壓縮特徵
layers.MaxPooling2D((2, 2)),
# 拉平層準備進入全連接
layers.Flatten(),
# 全連接層進行學習
layers.Dense(64, activation='relu'),
# Dropout 防止過擬合
layers.Dropout(0.5),
# 輸出層 (假設 10 個類別)
layers.Dense(10, activation='softmax')
])
每個圖層都有可訓練參數（Trainable Params）。例如 Dense(units=10) 若輸入維度為 50，則參數數量為 \(50 \times 10\)（權重）+ \(10\)（偏置）= \(510\)。您可以使用 model.summary() 來查看各圖層的參數分布情形。
前饋神經網路（Feedforward Neural Network, FNN）是最基本的類神經網路架構。資料從輸入層進入，經過一層或多層隱藏層的計算，最後由輸出層產出結果。資料流始終朝向前方，不存在循環或回饋路徑。
以下使用 tf.keras.Sequential 建立一個標準的多層感知器（MLP），適用於結構化資料分類（如 Iris 鳶尾花資料集或房價預測）：
from tensorflow.keras import layers, models
def build_fnn_model(input_dim, num_classes):
model = models.Sequential([
# 輸入層與第一個隱藏層
layers.Dense(64, activation='relu', input_shape=(input_dim,)),
# 第二個隱藏層
layers.Dense(32, activation='relu'),
# 正規化層（選配），減少過擬合
layers.Dropout(0.2),
# 輸出層 (多分類使用 softmax，回歸則通常不加或加 linear)
layers.Dense(num_classes, activation='softmax')
])
return model
# 假設輸入特徵有 20 個，分類目標有 3 類
model = build_fnn_model(input_dim=20, num_classes=3)
model.summary()
編譯時需根據任務類型選擇合適的損失函數（Loss Function）：
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 執行訓練
# model.fit(x_train, y_train, epochs=50, batch_size=32, validation_split=0.2)
| 組件名稱 | 常用設定 | 功能說明 |
|---|---|---|
| Dense (全連接層) | units=64 |
將前一層的所有神經元與本層連接，學習特徵間的非線性組合。 |
| ReLU (激活函數) | activation='relu' |
解決梯度消失問題，是目前隱藏層最常用的激活函數。 |
| Softmax (輸出函數) | activation='softmax' |
將輸出轉化為機率分佈，所有類別機率總和為 1。 |
| Adam (優化器) | optimizer='adam' |
自動調整學習率的演算法，通常能獲得較快且穩定的收斂。 |
ValueError: Input 0 of layer dense is incompatible with the layer，請使用 traceback.format_exc() 檢查輸入資料的 Shape 是否符合 input_shape 定義。卷積神經網路（Convolutional Neural Network, CNN）主要由卷積層（Convolutional Layer）、池化層（Pooling Layer）以及全連接層（Dense Layer）組成。卷積層負責提取影像空間特徵，池化層負責縮減資料維度，最後由全連接層進行分類決策。
以下使用 tf.keras.Sequential 建立一個經典的 CNN 模型，適用於處理如 MNIST 或 CIFAR-10 的影像分類任務：
from tensorflow.keras import layers, models
def build_cnn_model(input_shape, num_classes):
model = models.Sequential([
# 第一組卷積與池化：提取基礎特徵
layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),
layers.MaxPooling2D((2, 2)),
# 第二組卷積與池化：提取高階特徵
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
# 第三組卷積：進一步強化特徵
layers.Conv2D(64, (3, 3), activation='relu'),
# 平坦化與全連接層：將特徵圖轉換為分類結果
layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(num_classes, activation='softmax')
])
return model
# 建立模型 (假設輸入影像為 28x28 灰階，分類數為 10)
model = build_cnn_model(input_shape=(28, 28, 1), num_classes=10)
model.summary()
建立模型後，需要指定優化器、損失函數與評估指標。對於多分類問題，通常使用 Adam 優化器與 SparseCategoricalCrossentropy。
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 假設已有準備好的訓練資料 x_train, y_train
# model.fit(x_train, y_train, epochs=10, batch_size=64)
| 圖層名稱 | 關鍵參數範例 | 主要作用 |
|---|---|---|
| Conv2D | filters=32, kernel_size=(3,3) |
透過卷積核與影像運算，提取邊緣、紋理等局部特徵。 |
| MaxPooling2D | pool_size=(2,2) |
選取區域最大值，降低解析度以減少計算量並避免過擬合。 |
| Flatten | 無 | 將多維的張量拉平為一維向量，以便進入最後的分類器。 |
| Dense | units=10, activation='softmax' |
將提取出的特徵映射到具體的類別機率上。 |
layers.Dropout(0.5)，隨機捨棄神經元以增強泛化能力。tf.keras.layers.RandomFlip 等圖層在訓練時自動旋轉或翻轉影像，增加樣本多樣性。traceback.format_exc() 檢查是否為張量維度（Shapes）不匹配或記憶體不足（OOM）。循環神經網路（Recurrent Neural Network, RNN）專門用於處理序列資料，如時間序列、語音或自然語言。與 FNN 不同，RNN 具備「記憶」能力，隱藏層的神經元會將目前的資訊傳遞給下一個時間步（Time Step），從而捕捉資料中的前後文關聯。
在實際應用中，為了避免長序列產生的「梯度消失」問題，通常使用 LSTM 或 GRU 圖層。以下建立一個簡單的 LSTM 模型來預測時間序列（例如股價或氣溫）：
from tensorflow.keras import layers, models
def build_rnn_model(timesteps, features):
model = models.Sequential([
# LSTM 層：需要 3D 輸入 (samples, timesteps, features)
layers.LSTM(50, activation='relu', input_shape=(timesteps, features), return_sequences=True),
# 第二層 LSTM：如果不回傳序列，則 return_sequences=False (預設)
layers.LSTM(50, activation='relu'),
# 全連接層進行最終輸出
layers.Dense(25),
layers.Dense(1) # 假設是回歸問題，預測下一個數值
])
return model
# 假設觀測過去 10 天的資料，每天有 5 個特徵
model = build_rnn_model(timesteps=10, features=5)
model.summary()
RNN 圖層對於輸入資料的 Shape 要求非常嚴格，這是初學者最常報錯的地方：
| 維度名稱 | 說明 | 範例 |
|---|---|---|
| Samples | 訓練樣本的總數。 | 1000 筆資料 |
| Timesteps | 序列的長度（時間窗口）。 | 觀察過去 30 天 |
| Features | 每個時間點擁有的特徵數量。 | 開盤價、收盤價、成交量 |
| 圖層名稱 | 特點 | 建議場景 |
|---|---|---|
| SimpleRNN | 最基礎結構，運算快但記憶力極短。 | 極短序列或簡單模式。 |
| LSTM | 具備閘門機制（Gate），能保留長期記憶。 | 長文本處理、複雜時間序列預測。 |
| GRU | LSTM 的簡化版，參數較少，訓練較快。 | 運算資源有限時的 LSTM 替代方案。 |
clipnorm=1.0 可增加穩定性。return_sequences=True。Input 0 of layer lstm is incompatible with the layer，請透過 traceback.format_exc() 檢查 X_train.shape 是否確實為三維張量。# 編譯範例
model.compile(optimizer='adam', loss='mean_squared_error')
長短期記憶網路（Long Short-Term Memory, LSTM）是一種特殊的 RNN，設計初衷是為了解決傳統 RNN 在處理長序列時發生的梯度消失問題。它透過「閘門機制」（遺忘閘、輸入閘、輸出閘）來控制資訊的保留與丟棄，使其能捕捉資料中的長期依賴關係。
以下建立一個兩層堆疊的 LSTM 模型，常用於股價預測、電力負載預測或氣象感測資料分析：
from tensorflow.keras import layers, models
def build_lstm_model(timesteps, features):
model = models.Sequential([
# 第一層 LSTM：必須設定 return_sequences=True 才能將序列傳遞給下一層
layers.LSTM(units=50, return_sequences=True, input_shape=(timesteps, features)),
layers.Dropout(0.2), # 防止過擬合
# 第二層 LSTM：最後一層通常不回傳序列
layers.LSTM(units=50, return_sequences=False),
layers.Dropout(0.2),
# 全連接層輸出
layers.Dense(units=1) # 預測單一數值
])
model.compile(optimizer='adam', loss='mean_squared_error')
return model
# 範例：觀測過去 60 個時間點，每個點有 1 個特徵（如價格）
model = build_lstm_model(timesteps=60, features=1)
model.summary()
LSTM 的輸入必須是三維張量 (Samples, Timesteps, Features)。在將資料餵入模型前，通常需要使用 NumPy 進行轉換：
import numpy as np
# 假設原始資料是一維序列
data = np.random.rand(1000, 1)
# 轉換為 (樣本數, 時間步, 特徵數)
# 例如：每 60 筆預測 1 筆
X_train = []
for i in range(60, 1000):
X_train.append(data[i-60:i, 0])
X_train = np.array(X_train)
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
| 參數名稱 | 說明 |
|---|---|
| units | 隱藏層中的神經元數量，代表模型的記憶容量。 |
| return_sequences | 若為 True，輸出整個序列；若為 False，僅輸出最後一個時間步。 |
| input_shape | 格式為 (時間長度, 特徵數量)，不包含樣本數。 |
| Dropout | 在訓練期間隨機將部分單元設為 0，能有效降低模型的過擬合風險。 |
expected ndim=3, found ndim=2，請檢查輸入資料是否已透過 reshape 轉為三維。MinMaxScaler 將資料縮放到 0 與 1 之間。batch_size 或使用 traceback.format_exc() 檢查具體錯誤原因。自動編碼器(Autoencoder) 是一種非監督式學習的神經網路，旨在將輸入資料壓縮成低維度的表徵（編碼），再從中重建出原始資料（解碼）。它主要由兩部分組成：
以下使用 Keras Functional API 建立一個用於影像去噪或降維的基礎自動編碼器：
from tensorflow.keras import layers, models
# 設定輸入維度 (假設為 28x28 影像拉平後)
input_dim = 784
encoding_dim = 32 # 壓縮後的特徵維度
# 1. 定義編碼器 (Encoder)
input_img = layers.Input(shape=(input_dim,))
encoded = layers.Dense(encoding_dim, activation='relu')(input_img)
# 2. 定義解碼器 (Decoder)
decoded = layers.Dense(input_dim, activation='sigmoid')(encoded)
# 3. 建立自動編碼器模型 (包含輸入到重建輸出)
autoencoder = models.Model(input_img, decoded)
# 4. 建立單獨的編碼器模型 (用於提取特徵)
encoder = models.Model(input_img, encoded)
# 5. 編譯模型 (通常使用 MSE 作為損失函數)
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
| 應用類型 | 主要用途 | 特點 |
|---|---|---|
| 資料降維 | 取代 PCA | 能捕捉非線性的特徵關係。 |
| 影像去噪 (Denoising) | 移除圖片雜訊 | 輸入含雜訊圖片，目標為原始乾淨圖片。 |
| 異常檢測 | 偵測信用卡盜刷、設備故障 | 重建誤差 (Reconstruction Error) 過大者即為異常。 |
| 生成模型 | VAE (變分自動編碼器) | 可從編碼空間隨機取樣生成新資料。 |
處理影像時，使用卷積層效果更佳。編碼器使用 Conv2D 與 MaxPooling2D，解碼器則使用 UpSampling2D 或 Conv2DTranspose：
# 編碼器部分
x = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(input_img_2d)
x = layers.MaxPooling2D((2, 2), padding='same')(x)
# 解碼器部分
x = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(x)
x = layers.UpSampling2D((2, 2))(x)
decoded = layers.Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)
y_train 就是 x_train 本身，即 model.fit(x_train, x_train, ...)。encoding_dim 太小，無法完整捕捉資料特徵。traceback.format_exc() 檢查激活函數（如輸出層應根據資料範圍選擇 sigmoid 或 linear）。生成對抗網路（Generative Adversarial Network, GAN）由兩個相互競爭的神經網路組成：
兩者在訓練過程中不斷進化：生成器學習產生更真實的資料，而辨別器學習成為更敏銳的檢查員。這種動態平衡最終使生成器能夠產生高品質的擬真資料。
以下展示一個基礎的 GAN 結構，用於產生類似 MNIST 的手寫數字：
from tensorflow.keras import layers, models, optimizers
# 1. 定義生成器
def build_generator(latent_dim):
model = models.Sequential([
layers.Dense(128, input_dim=latent_dim),
layers.LeakyReLU(alpha=0.2),
layers.Dense(256),
layers.LeakyReLU(alpha=0.2),
layers.Dense(784, activation='tanh') # 輸出範圍介於 -1 到 1
])
return model
# 2. 定義辨別器
def build_discriminator():
model = models.Sequential([
layers.Dense(256, input_dim=784),
layers.LeakyReLU(alpha=0.2),
layers.Dropout(0.3),
layers.Dense(1, activation='sigmoid') # 二元分類：真或假
])
model.compile(loss='binary_crossentropy', optimizer=optimizers.Adam(0.0002, 0.5))
return model
# 3. 定義對抗網路 (組合模型)
def build_gan(generator, discriminator):
discriminator.trainable = False # 在組合模型中固定辨別器
model = models.Sequential([generator, discriminator])
model.compile(loss='binary_crossentropy', optimizer=optimizers.Adam(0.0002, 0.5))
return model
GAN 的訓練與一般模型不同，需要交替訓練辨別器與生成器：
| 訓練階段 | 操作步驟 | 訓練目標 |
|---|---|---|
| 訓練辨別器 | 輸入一半真實圖片、一半偽造圖片，並給予標籤 (1 與 0)。 | 最大化辨識真偽的準確率。 |
| 訓練生成器 | 透過對抗網路輸入隨機雜訊，並將標籤全部設為 1 (假裝是真貨)。 | 最小化辨別器識破偽造品的機率。 |
在處理影像時，改用卷積層能大幅提升生成品質。生成器會使用 Conv2DTranspose（轉置卷積）來放大特徵圖：
# 生成器中的轉置卷積層範例
model.add(layers.Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
model.add(layers.LeakyReLU(alpha=0.2))
traceback.format_exc() 捕捉訓練循環中的異常。建議定期存下生成器產生的圖片，以觀察視覺上的演進過程。Transformer 是一種捨棄了傳統 RNN 循環結構，完全基於注意力機制 (Attention Mechanism) 的架構。它的核心在於「多頭自注意力層」(Multi-Head Self-Attention)，能夠同時處理序列中的所有位置，完美解決了長距離依賴問題，是目前 BERT、GPT 等大模型的基石。
在 Keras 中，我們通常會將 Transformer 的核心單元封裝成一個自定義層或函數。一個標準的 Transformer Block 包含多頭注意力、加法與正規化 (Add & Norm) 以及前饋網路 (Feed Forward)。
from tensorflow import keras
from tensorflow.keras import layers
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
# 1. 多頭自注意力 (Multi-Head Self-Attention)
x = layers.MultiHeadAttention(
key_dim=head_size, num_heads=num_heads, dropout=dropout
)(inputs, inputs)
x = layers.Dropout(dropout)(x)
res = x + inputs # 殘差連接
x = layers.LayerNormalization(epsilon=1e-6)(res)
# 2. 前饋網路 (Feed Forward Network)
x_ff = layers.Dense(ff_dim, activation="relu")(x)
x_ff = layers.Dropout(dropout)(x_ff)
x_ff = layers.Dense(inputs.shape[-1])(x_ff)
x = x_ff + x # 殘差連接
return layers.LayerNormalization(epsilon=1e-6)(x)
以下展示如何將 Transformer 套用於序列分類任務（如情感分析或時間序列分類）：
def build_transformer_model(input_shape, head_size, num_heads, ff_dim, num_transformer_blocks, mlp_units, num_classes, dropout=0):
inputs = keras.Input(shape=input_shape)
x = inputs
# 堆疊多個 Transformer Encoder 層
for _ in range(num_transformer_blocks):
x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)
# 全域平均池化與最後的分類層
x = layers.GlobalAveragePooling1D(data_format="channels_last")(x)
for dim in mlp_units:
x = layers.Dense(dim, activation="relu")(x)
x = layers.Dropout(dropout)(x)
outputs = layers.Dense(num_classes, activation="softmax")(x)
return keras.Model(inputs, outputs)
# 範例參數
model = build_transformer_model(
input_shape=(100, 64), # 100 個時間點，每個點 64 個特徵
head_size=256,
num_heads=4,
ff_dim=4,
num_transformer_blocks=4,
mlp_units=[128],
num_classes=2,
dropout=0.1
)
model.summary()
| 組件名稱 | 功能說明 |
|---|---|
| MultiHeadAttention | 計算序列中不同位置之間的關聯強度，捕捉上下文資訊。 |
| Positional Encoding | 由於 Transformer 並行處理，需額外加入位置資訊（通常加在輸入層）。 |
| LayerNormalization | 穩定神經元的活動，加速訓練收斂，與 CNN 常用的 Batch Norm 不同。 |
| Residual Connection | 透過 x + inputs 讓梯度更容易傳遞，防止深層網路退化。 |
Incompatible shapes，通常發生在殘差連接處。請確保經過注意力層或 Dense 層後，輸出的維度與輸入 inputs 完全一致。PyTorch 是一個基於 Torch 庫的開源機器學習框架，主要由 Meta（原 Facebook）的 AI 研究團隊開發。它以 Python 優先（Python-first）為設計理念，強調靈活性與動態性，目前已成為學術研究界最受歡迎的框架，並在工業界廣泛應用。
| 組件名稱 | 主要用途 |
|---|---|
| torch.nn | 包含各種神經網路層（如 Linear, Conv2d）與損失函數。 |
| torch.optim | 提供優化演算法，如 SGD, Adam, RMSprop。 |
| torch.utils.data | 處理資料載入，包含 Dataset 與 DataLoader。 |
| torchvision | 專為電腦視覺設計的工具包，包含常用資料集、模型架構與影像轉換。 |
在 PyTorch 中開發模型通常遵循以下步驟：
Dataset 類別並使用 DataLoader 進行批次處理。nn.Module，在 __init__ 中定義層，在 forward 中定義前向傳播邏輯。以下是一個簡單的線性回歸模型實作：
import torch
import torch.nn as nn
# 1. 定義模型架構
class LinearModel(nn.Module):
def __init__(self):
super(LinearModel, self).__init__()
self.linear = nn.Linear(1, 1) # 輸入 1, 輸出 1
def forward(self, x):
return self.linear(x)
model = LinearModel()
# 2. 定義損失函數與優化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# 3. 訓練循環 (簡化版)
# for inputs, targets in dataloader:
# outputs = model(inputs)
# loss = criterion(outputs, targets)
# optimizer.zero_grad()
# loss.backward()
# optimizer.step()
透過 PyTorch 架構的分類器模型，對多組時間序列數據進行分類
假設多組時間序列數據為已標記的數據集，包含不同的分類標籤。我們需要將數據預處理成適合 PyTorch 的 Dataset 和 DataLoader 格式，以便用於訓練和測試。
import torch
from torch.utils.data import DataLoader, Dataset
# 假設每組數據有多個時間點的特徵
class TimeSeriesDataset(Dataset):
def __init__(self, data, labels):
self.data = data
self.labels = labels
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
return torch.tensor(self.data[idx], dtype=torch.float32), torch.tensor(self.labels[idx], dtype=torch.long)
此處使用一個簡單的 長短期記憶網絡（LSTM） 模型來處理時間序列數據，並將最終的輸出分類為多個類別。以下是一個簡單的 LSTM 模型範例。
import torch.nn as nn
class LSTMClassifier(nn.Module):
def __init__(self, input_size, hidden_size, num_layers, num_classes):
super(LSTMClassifier, self).__init__()
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, num_classes)
def forward(self, x):
h0 = torch.zeros(num_layers, x.size(0), hidden_size).to(x.device)
c0 = torch.zeros(num_layers, x.size(0), hidden_size).to(x.device)
out, _ = self.lstm(x, (h0, c0))
out = self.fc(out[:, -1, :])
return out
接下來，設定損失函數和優化器，將數據送入模型進行訓練。
import torch.optim as optim
# 模型參數
input_size = 10 # 每個時間點的特徵數
hidden_size = 64
num_layers = 2
num_classes = 3 # 分類類別數量
model = LSTMClassifier(input_size, hidden_size, num_layers, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 訓練迴圈
for epoch in range(num_epochs):
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')
在測試數據上評估模型的表現。
model.eval()
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_loader:
outputs = model(inputs)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f'測試準確率: {100 * correct / total:.2f}%')
一般無法啟用 GPU 的主要原因在於您安裝的 PyTorch 版本是 +cpu 版本。
在安裝支援 GPU 的版本前，必須先移除現有的純 CPU 版本，以避免函式庫衝突：
pip uninstall torch torchvision torchaudio若您的 CUDA 版本是 13.1，您需要安裝對應或相容的 PyTorch 指令。請注意，PyTorch 官方通常會針對特定的 CUDA 版本進行編譯。
請執行以下指令（安裝支援最新 CUDA 版本的 PyTorch）：
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124註：截至目前，PyTorch 官方穩定版可能尚未完全標示 cu131 的標籤，但通常 cu124 或最新的 CUDA 編譯版可以與 13.x 驅動向下相容。
安裝完成後，請再次執行您的檢查腳本。如果成功，您應該會看到以下結果：
torch.cuda.is_available(): Truetorch.version.cuda: 顯示為 12.4 (或您安裝的版本)transformers 是由 Hugging Face 開發的強大套件，專為自然語言處理（NLP）及其他機器學習任務設計。它提供多種預訓練模型的便捷使用方式，使開發者能以最少的設定使用最先進的技術。
可以使用 pip 安裝 transformers 套件：
pip install transformers以下是一個使用預訓練模型進行文本分類的簡單範例：
from transformers import pipeline
# 載入情感分析管道
classifier = pipeline("sentiment-analysis")
# 執行情感分析
results = classifier("Hugging Face 的 Transformers 套件非常棒！")
print(results)transformers 套件是 NLP 領域開發者與研究人員的重要工具。其豐富的模型庫與友善的 API 讓它成為構建與部署最先進機器學習應用的首選。
from transformers import AutoModelForCausalLM, AutoTokenizer
# 選擇預訓練模型，例如 GPT-2
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# 輸入提示
prompt = "很久很久以前，在一個遙遠的國度，"
# 將輸入轉換為模型的編碼格式
input_ids = tokenizer.encode(prompt, return_tensors="pt")
# 使用模型生成文本
output = model.generate(
input_ids,
max_length=50, # 生成的最大字數
num_return_sequences=1, # 返回的文本數量
temperature=0.7, # 控制生成的多樣性
top_k=50, # 限制候選單字的範圍
top_p=0.9, # 使用核取樣
do_sample=True # 啟用抽樣以產生多樣的輸出
)
# 將生成的編碼轉回文本
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print(generated_text)
prompt = "在未來的人工智能時代，"
output = model.generate(
tokenizer.encode(prompt, return_tensors="pt"),
max_length=100,
temperature=1.0,
top_p=0.95,
do_sample=True
)
print(tokenizer.decode(output[0], skip_special_tokens=True))
prompt = "人工智慧的主要功能是"
output = model.generate(
tokenizer.encode(prompt, return_tensors="pt"),
max_length=50,
temperature=0.5,
do_sample=False # 使用確定性生成
)
print(tokenizer.decode(output[0], skip_special_tokens=True))
上述範例展示了如何使用 transformers 模型進行文本生成。根據不同需求，您可以調整參數來生成多樣化或精確的文本，適用於創意生成、補全技術文件等場景。
在使用 Hugging Face 的 transformers 套件時，模型和分詞器的預訓練檔案會下載並儲存在預設的快取目錄中。若需更改快取目錄，可在載入模型或分詞器時指定 cache_dir 參數。
from transformers import AutoModel, AutoTokenizer
# 自訂快取目錄
cache_directory = "./my_custom_cache"
# 載入模型與分詞器，指定快取目錄
model = AutoModel.from_pretrained("bert-base-uncased", cache_dir=cache_directory)
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased", cache_dir=cache_directory)
您也可以透過設定環境變數來更改全域的快取目錄，確保所有模型和分詞器均使用相同的快取位置。
import os
from transformers import AutoModel, AutoTokenizer
# 設定全域快取目錄
os.environ["TRANSFORMERS_CACHE"] = "./my_global_cache"
# 載入模型與分詞器
model = AutoModel.from_pretrained("bert-base-uncased")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
要檢查預設快取目錄的位置，可以使用以下程式碼：
from transformers.utils import default_cache_path
print("預設快取目錄:", default_cache_path)
透過設定 cache_dir 或環境變數，您可以輕鬆管理 Transformers 套件的快取目錄，提升專案的靈活性和資源管理效率。
大部分 AI 框架（如 Hugging Face Transformers）的模型在下載時會存放到預設的目錄中，以便重複使用。以下是一些常見框架的預設目錄：
~/.cache/huggingface/transformers/~/.tensorflow_hub/~/.cache/torch/hub/有些模型檔案很大，需要做一些管理。可以透過環境變數或程式參數更改預設下載目錄，以下是一些具體方法：
透過環境變數 HF_HOME 或 TRANSFORMERS_CACHE 修改。
export HF_HOME=/your/custom/path
export TRANSFORMERS_CACHE=/your/custom/path
或在程式中指定：
from transformers import AutoModel
import os
os.environ["HF_HOME"] = "/your/custom/path"
os.environ["TRANSFORMERS_CACHE"] = "/your/custom/path"
model = AutoModel.from_pretrained("model-name")
設定環境變數 TFHUB_CACHE_DIR：
export TFHUB_CACHE_DIR=/your/custom/path
在程式中設定：
import os
os.environ["TFHUB_CACHE_DIR"] = "/your/custom/path"
設定環境變數 TORCH_HOME：
export TORCH_HOME=/your/custom/path
在程式中設定：
import os
os.environ["TORCH_HOME"] = "/your/custom/path"
確認模型是否下載到指定目錄，可以檢查目錄內容：
ls /your/custom/path
或者在程式中列印當前目錄：
import os
print(os.environ.get("HF_HOME"))
print(os.environ.get("TRANSFORMERS_CACHE"))
檔案類型： 標準 Hugging Face 模型檔案（pytorch_model.bin），轉換為 FP16 格式。
用途： 相較於 FP32，FP16 降低了記憶體使用量並提高計算效能。
使用情境： 常用於 PyTorch 或 TensorFlow 的 GPU 推理。
儲存為 FP16 的方法：
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("model_name")
model.half() # 轉換為 FP16 格式
model.save_pretrained("./fp16_model")
檔案類型： 與 FP16 類似，但設計上具備更好的數值穩定性。
用途： 在支援 BF16 的 GPU（例如 NVIDIA A100、H100）上進行穩定的推理與訓練。
使用方法：
model = AutoModelForCausalLM.from_pretrained("model_name", torch_dtype="torch.bfloat16").cuda()
檔案類型： 經 INT8 量化後的 Hugging Face 模型檔案。
用途： 顯著降低記憶體使用量，效能損失較小。
儲存 INT8 模型的方法：
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("model_name", device_map="auto", load_in_8bit=True)
model.save_pretrained("./int8_model")
檔案類型： .onnx
用途： 跨平台 GPU 推理，支援 ONNX Runtime 和 TensorRT。
轉換為 ONNX 的方法：
pip install optimum[onnxruntime] optimum-cli export onnx --model=model_name ./onnx_model
ONNX 推理範例：
from onnxruntime import InferenceSession
session = InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])
檔案類型： .engine
用途： NVIDIA 專屬格式，用於高效能推理，支援 FP16 和 INT8。
轉換為 TensorRT 的方法：
trtexec --onnx=model.onnx --saveEngine=model.engine --fp16
TensorRT 推理範例：
import tensorrt as trt
TorchScript 模型： 使用 PyTorch 的 .pt 格式。
儲存範例：
scripted_model = torch.jit.script(model)
scripted_model.save("model.pt")
| 格式 | 檔案副檔名 | 最佳化用途 | 框架 |
|---|---|---|---|
| FP16 | .bin | 通用 GPU 推理 | PyTorch, TensorFlow |
| BF16 | .bin | 數值穩定性 | PyTorch, TensorFlow |
| INT8 | .bin | 低記憶體 GPU | Hugging Face + bitsandbytes |
| ONNX | .onnx | 跨平台 GPU | ONNX Runtime, TensorRT |
| TensorRT | .engine | NVIDIA GPU | TensorRT |
GGML（General Graphical Model Layer）是一種針對高效能和低資源場景設計的機器學習模型格式。其核心目的是實現模型的高效存儲和推理，特別適用於內存受限的設備。
將機器學習模型轉換為 GGML 格式的步驟：
pytorch_model.bin）。llama.cpp 提供的轉換腳本。model.ggml.q4_0.bin。Llama（Large Language Model Meta AI）是由 Meta 開發的大型語言模型，專為生成自然語言文本、回答問題以及進行語言理解任務而設計。
這些模型以其高效性著稱，能在相對較少的硬體資源下提供高品質的文本生成結果。
自然語言生成： 用於創作故事、文章或對話。
問答系統： 支援用戶查詢並生成準確答案。
語言翻譯： 支援多種語言間的翻譯任務。
語言理解： 適用於摘要、情感分析等任務。
效率高： 相較於其他大型模型，Llama 訓練所需資源更少。
開放性： Meta 提供了對研究與商業應用的支持，促進了社群的發展。
靈活性： 模型可以在多種硬體平台上運行，包括 CPU 和 GPU。
1. 安裝所需工具：
pip install transformers pip install sentencepiece
2. 加載模型：
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b")
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b").cuda()
input_text = "Llama 是什麼？"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.cuda()
output = model.generate(input_ids, max_length=50)
print(tokenizer.decode(output[0]))
Llama 提供了多個版本，主要區分在於模型的參數量（如 7B、13B、70B）：
CPU： 可以使用 GGUF 格式進行高效推理。
GPU： 支援 FP16 或 BF16 格式以提升性能。
FP16 量化： 降低記憶體使用並提高推理速度。
INT8 量化： 適用於資源受限的設備，減少性能損失。
Mistral 是一款由 Mistral AI 開發的大型語言模型，專注於提供高效、精確的自然語言處理能力。
該模型以其高度優化的架構和精簡的運算資源需求而著稱，適用於各類語言生成與理解任務。
高效性： Mistral 採用最新的 Transformer 架構設計，提供快速且準確的推理能力。
開放性： Mistral 模型是開源的，允許用戶在本地運行並進行自定義。
可擴展性： 模型支持多種量化格式，適用於不同的硬體環境。
隱私保護： 可在本地環境中部署，避免數據洩漏的風險。
內容生成： 包括文章撰寫、對話生成和文案創作。
語言理解： 用於文本分類、情感分析等任務。
教育應用： 提供教學輔助，解答學術問題。
自動化系統： 集成到客服系統或其他自動化流程中。
1. 安裝依賴：
pip install transformers
2. 下載模型： 從 Hugging Face 或其他官方來源下載 Mistral 模型檔案。
3. 加載模型：
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B").cuda()
input_text = "Mistral 是什麼？"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.cuda()
output = model.generate(input_ids, max_length=50)
print(tokenizer.decode(output[0]))
CPU： 支援高效能的 CPU 推理，可使用 GGUF 格式進行優化。
GPU： 支援 FP16 或 BF16 格式，可在 NVIDIA GPU 上提供最佳性能。
Mistral 提供多種版本，主要區別在於參數量和性能：
量化格式： 使用 INT8 或 GGUF 格式降低記憶體需求，提升推理效率。
性能優化： 利用硬體特性（如 AVX 指令集或 CUDA 加速）實現高效運算。
Gemma 是一種專為高效自然語言處理任務設計的開源大型語言模型。
該模型以其多功能性和可擴展性為核心，支援文本生成、語言理解以及多種語言的翻譯任務。
多語言支持： Gemma 能夠處理多種語言，使其適合於全球化應用場景。
輕量化： 模型針對資源受限的硬體進行了高度優化。
可擴展性： 支持在多種硬體環境下運行，包括 CPU 和 GPU。
開源性： 開放源代碼，方便用戶進行二次開發和自定義。
自然語言生成： 適用於內容創作、文章撰寫和對話生成。
語言理解： 包括情感分析、主題分類以及文本摘要等任務。
機器翻譯： 提供高準確度的多語言翻譯服務。
教育與研究： 作為教學輔助工具或研究分析平台。
1. 安裝依賴：
pip install gemma
2. 下載模型： 從官方網站或模型庫中下載適合的 Gemma 模型檔案。
3. 加載模型：
from gemma import GemmaModel, GemmaTokenizer
# 初始化 Tokenizer 和模型
tokenizer = GemmaTokenizer.from_pretrained("gemma-ai/gemma-base")
model = GemmaModel.from_pretrained("gemma-ai/gemma-base").cuda()
# 準備輸入文本
input_text = "Gemma 是什麼？"
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.cuda()
# 生成輸出
outputs = model.generate(input_ids, max_length=50)
print(tokenizer.decode(outputs[0]))
Gemma 提供多個版本，滿足不同需求：
CPU： 支援 CPU 推理，適合低資源環境。
GPU： 在支持 CUDA 的 GPU 上運行以實現高效能。
量化技術： 支援 INT8 和 FP16 格式，減少記憶體占用的同時保持性能穩定。
硬體優化： 利用硬體特性（如 AVX 指令集）進一步提升推理速度。
GPT4All 是一種開源的大型語言模型，旨在在本地設備上進行自然語言處理，無需雲端依賴。
該模型提供了高效的文本生成能力，適用於多種語言應用場景，並專為低資源硬體設計。
開源性： GPT4All 是完全開源的，可以根據需求進行自定義。
本地運行： 支援在個人電腦、筆記型電腦或伺服器上運行，不需網路連線。
輕量化： 可運行於 CPU 和低規格 GPU 上，降低硬體需求。
隱私保護： 由於所有運算在本地完成，用戶數據不會洩漏到外部伺服器。
內容創作： 用於撰寫文章、故事、博客或技術文檔。
問答系統： 創建可離線使用的問答助手。
教育輔助： 作為學習和解題工具，幫助用戶理解複雜概念。
開發輔助： 用於生成代碼或提供程式開發建議。
1. 安裝依賴：
pip install gpt4all
2. 下載模型檔案： 從 GPT4All 官方網站下載所需的模型檔案（如 .bin 或 .gguf 格式）。
3. 加載模型：
from gpt4all import GPT4All
model = GPT4All("gpt4all-lora-quantized.bin")
response = model.generate("你好，GPT4All 是什麼？", max_tokens=100)
print(response)
.bin： 常見的量化模型格式，適用於大多數設備。
.gguf： 為 CPU 優化的格式，適合低資源設備進行高效推理。
CPU： GPT4All 支援高效能的 CPU 推理，適合無 GPU 的環境。
GPU： 若有 NVIDIA GPU，可使用 PyTorch 或其他框架進行加速。
量化模型： 使用 INT8 或其他量化技術以降低記憶體占用。
性能優化： 利用硬體特性（如 AVX 指令集）提升推理速度。
email: [email protected]
