深度學習

 1: # SGD（隨機梯度下降）：最基本的優化器，像是用最笨的方法下山
 2: model.compile(optimizer='sgd', loss='categorical_crossentropy')
 3: 
 4: # SGD + Momentum（加上動量）：像是滾球下山，會「記住」之前的方向，不容易卡住
 5: model.compile(optimizer=keras.optimizers.SGD(learning_rate=0.01, momentum=0.9),
 6:               loss='categorical_crossentropy')
 7: 
 8: # RMSprop：會根據梯度大小自動調整學習速度，比 SGD 聰明
 9: model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
10: 
11: # Adam（最常用）：結合了 Momentum 和 RMSprop 的優點，新手首選
12: model.compile(optimizer='adam', loss='categorical_crossentropy')
13: 
14: # Adam 搭配自訂學習率（learning_rate 越小學越慢但越穩定）
15: model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001),
16:               loss='categorical_crossentropy')

 1: import numpy as np  # 載入 NumPy，等等要用來做矩陣運算
 2: 
 3: # 這個函式負責把評論資料做 one-hot encoding（獨熱編碼）
 4: # 簡單說就是：把「出現過哪些單字」標記成 1，沒出現的標記成 0
 5: def vectorize_sequences(sequences, dimension=10000):
 6:     # 先建一個全部是 0 的大矩陣，大小是（資料筆數 × 10000 個單字）
 7:     results = np.zeros((len(sequences), dimension))
 8:     for i, sequence in enumerate(sequences):  # 逐筆處理每則評論
 9:         results[i, sequence] = 1.  # 把這則評論中出現過的單字位置標記為 1
10:     return results
11: 
12: print("====train_data[0]======")
13: print(train_data[0])  # 原始資料：一串單字編號（長度不固定）
14: 
15: # 將訓練資料向量化（變成固定長度 10000 的 0/1 向量）
16: x_train = vectorize_sequences(train_data)
17: # 將測試資料也做一樣的向量化處理
18: x_test = vectorize_sequences(test_data)
19: print("====x_data[0]======")
20: print(x_train[0])  # 向量化後：長度固定為 10000 的 0/1 陣列
21: 
22: # 最後再將標籤資料轉換為 float32 格式（神經網路比較喜歡浮點數）
23: y_train = np.asarray(train_labels).astype('float32')
24: y_test = np.asarray(test_labels).astype('float32')
25: print("====y_data[0]======")
26: print(y_train[0])  # 標籤：1.0 代表正面，0.0 代表負面

# 加入一個 Dense（全連接）隱藏層，該層有 16 個神經元
# activation='relu' 表示用 ReLU 啟動函數：負數變 0，正數保留原值
model.add(layers.Dense(16, activation='relu'))

 1: from keras import models  # 載入模型模組
 2: from keras import layers  # 載入層模組
 3: 
 4: # 建立一個 Sequential（順序型）模型——就像疊積木一樣，一層一層往上疊
 5: model = models.Sequential()
 6: # 輸入層：告訴模型每筆資料是一個長度 10000 的向量（one-hot 編碼後的結果）
 7: model.add(layers.Input(shape=(10000,)))
 8: # 第一層隱藏層：16 個神經元，用 ReLU 啟動函數（負數變 0，正數保留）
 9: model.add(layers.Dense(16, activation='relu'))
10: # 第二層隱藏層：再來 16 個神經元，一樣用 ReLU
11: model.add(layers.Dense(16, activation='relu'))
12: # 輸出層：只有 1 個神經元，用 sigmoid 把結果壓在 0~1 之間（代表正面評論的機率）
13: model.add(layers.Dense(1, activation='sigmoid'))

1: # 編譯模型：設定訓練時要用的優化器、損失函數和評估指標
2: model.compile(optimizer='rmsprop',             # 優化器：RMSprop（一種聰明的梯度下降法）
3:              loss='binary_crossentropy',       # 損失函數：二元交叉熵（專門用於二分類問題）
4:              metrics=['accuracy'])             # 評估指標：準確率（答對幾題 / 總題數）

 1: # 方法一：自訂學習率（learning_rate 越小學越慢但越穩，越大學越快但可能亂跳）
 2: from keras import optimizers
 3: 
 4: model.compile(optimizer=optimizers.RMSprop(learning_rate=0.001),  # 自訂學習率為 0.001
 5:               loss='binary_crossentropy',
 6:               metrics=['accuracy'])
 7: 
 8: # 方法二：用物件形式指定損失函數和評估指標（效果跟字串一樣，但可以做更多客製化）
 9: from keras import losses    # 載入損失函數模組
10: from keras import metrics   # 載入評估指標模組
11: 
12: model.compile(optimizer=optimizers.RMSprop(learning_rate=0.001),
13:               loss=losses.binary_crossentropy,        # 用物件形式指定損失函數
14:               metrics=[metrics.binary_accuracy])       # 用物件形式指定評估指標

1: # 從 25000 筆訓練資料中，切出前 10000 筆當作「驗證集」（用來監控訓練過程中有沒有過度配適）
2: x_val = x_train[:10000]           # 驗證集的特徵（前 10000 筆）
3: partial_x_train = x_train[10000:] # 真正拿來訓練的特徵（剩下的 15000 筆）
4: 
5: y_val = y_train[:10000]           # 驗證集的標籤
6: partial_y_train = y_train[10000:] # 訓練集的標籤

1: # 開始訓練模型！fit() 就是讓模型「學習」的指令
2: history = model.fit(partial_x_train,              # 訓練用的特徵資料
3:                     partial_y_train,              # 訓練用的標籤（正確答案）
4:                     epochs=20,                    # 把全部資料跑 20 輪（像複習考卷 20 遍）
5:                     batch_size=512,               # 每次餵 512 筆資料給模型（不是一次全丟，會消化不良）
6:                     validation_data=(x_val, y_val))  # 每跑完一輪就用驗證集測試一下，看有沒有「背答案」的跡象

1: # history.history 是一個字典，記錄了每個 epoch 的訓練指標
2: print(history.history)                                          # 印出完整的訓練歷史紀錄
3: print("binary_accuracy:",history.history['binary_accuracy'])    # 每個 epoch 的訓練準確率
4: print("loss:",history.history['loss'])                          # 每個 epoch 的訓練損失值
5: print("val_binary_accuracy:",history.history['val_binary_accuracy'])  # 每個 epoch 的驗證準確率
6: print("val_loss:",history.history['val_loss'])                  # 每個 epoch 的驗證損失值

 1: # 把訓練歷史紀錄存到 history_dict，方便等等畫圖用
 2: history_dict = history.history
 3: print(history_dict.keys())  # 看看字典裡有哪些 key（loss, accuracy 之類的）
 4: 
 5: # 繪圖輔助函數：把訓練過程畫成折線圖，一眼看出模型學得好不好
 6: import matplotlib.pyplot as plt
 7: def plot_train_history(hdict, train_key, val_key, ylabel, filename, axis_range=None):
 8:     plt.cla()                                          # 清除前一張圖（不然會疊在一起）
 9:     epochs = range(1, len(hdict[train_key]) + 1)       # X 軸：第 1, 2, 3... 個 epoch
10:     plt.plot(epochs, hdict[train_key], 'bo', label='Training ' + ylabel.lower())   # 訓練曲線（藍色圓點）
11:     plt.plot(epochs, hdict[val_key], 'b', label='Validation ' + ylabel.lower())    # 驗證曲線（藍色線）
12:     plt.title(f'Training and validation {ylabel.lower()}')  # 圖表標題
13:     plt.xlabel('Epochs')   # X 軸標籤
14:     plt.ylabel(ylabel)     # Y 軸標籤
15:     if axis_range:         # 如果有指定座標軸範圍就套用
16:         plt.axis(axis_range)
17:     plt.legend()           # 顯示圖例（哪條線是訓練、哪條是驗證）
18:     plt.savefig(f"images/{filename}")  # 把圖存成檔案
19: 
20: # 畫出 Loss 曲線（損失值越低越好）
21: plot_train_history(history_dict, 'loss', 'val_loss', 'Loss', 'imdb-Keras-1.png')
22: # 畫出 Accuracy 曲線（準確率越高越好）
23: plot_train_history(history_dict, 'binary_accuracy', 'val_binary_accuracy', 'Accuracy', 'imdb-Keras-2.png')

 1: # ===== 第二版：優化模型 =====
 2: 
 3: # 向量化函式（跟前面一樣，把單字編號轉成 one-hot 向量）
 4: def vectorize_sequences(sequences, dimension=10000):
 5:     results = np.zeros((len(sequences), dimension))  # 建立全 0 矩陣
 6:     for i, sequence in enumerate(sequences):
 7:         results[i, sequence] = 1.  # 出現過的單字位置設為 1
 8:     return results
 9: 
10: x_train = vectorize_sequences(train_data)   # 向量化訓練資料
11: x_test = vectorize_sequences(test_data)     # 向量化測試資料
12: # 標籤轉為浮點數格式
13: y_train = np.asarray(train_labels).astype('float32')
14: y_test = np.asarray(test_labels).astype('float32')
15: 
16: # 建立優化版 model（比第一版多了 Dropout 層來防止過度配適）
17: model = models.Sequential()
18: model.add(layers.Input(shape=(10000,)))          # 輸入層：10000 維向量
19: model.add(layers.Dense(16, activation='relu'))   # 隱藏層 1：16 個神經元
20: model.add(layers.Dense(64, activation='relu'))   # 隱藏層 2：64 個神經元（加寬，讓模型學更多特徵）
21: model.add(layers.Dropout(0.25))                  # Dropout：隨機關掉 25% 的神經元（防止模型「背答案」）
22: model.add(layers.Dense(64, activation='relu'))   # 隱藏層 3：再來 64 個神經元
23: model.add(layers.Dropout(0.25))                  # 再加一層 Dropout，雙重保險
24: model.add(layers.Dense(1, activation='sigmoid')) # 輸出層：sigmoid 輸出 0~1 的機率
25: 
26: # 設定優化器，學習率調低到 0.0001（學慢一點但更穩定）
27: import platform
28: opt = optimizers.RMSprop(learning_rate=0.0001)
29: 
30: # 編譯模型
31: model.compile(optimizer=opt, loss='binary_crossentropy',
32:               metrics=[metrics.binary_accuracy])
33: 
34: # 切出驗證集（跟前面一樣的做法）
35: x_val = x_train[:10000]           # 前 10000 筆做驗證
36: partial_x_train = x_train[10000:] # 剩下的拿來訓練
37: y_val = y_train[:10000]
38: partial_y_train = y_train[10000:]
39: 
40: # 開始訓練（verbose=0 表示不要一直印進度條，安靜訓練）
41: history = model.fit(partial_x_train, partial_y_train,
42:                     epochs=20, batch_size=512,
43:                     validation_data=(x_val, y_val), verbose=0)
44: 
45: # 看看訓練歷史紀錄有哪些指標
46: history_dict = history.history
47: print(history_dict.keys())
48: 
49: # 用訓練好的模型對測試集進行預測（每筆資料會得到一個 0~1 的機率值）
50: x = model.predict(x_test)
51: print(x)
52: 
53: # 畫出優化版的 Loss 和 Accuracy 曲線，跟第一版比較看看有沒有進步
54: plot_train_history(history_dict, 'loss', 'val_loss', 'Loss', 'imdb-Keras-3.png')
55: plot_train_history(history_dict, 'binary_accuracy', 'val_binary_accuracy', 'Accuracy', 'imdb-Keras-4.png')

 1: from keras.datasets import reuters               # 載入 Reuters 新聞分類資料集
 2: from tensorflow.keras.utils import to_categorical # 載入 one-hot 編碼工具
 3: import numpy as np
 4: 
 5: # 載入資料，num_words=10000 表示只保留最常見的 10000 個字（跟 IMDB 一樣的套路）
 6: (train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)
 7: print(f"訓練資料筆數: {len(train_data)}")       # 看看有多少筆訓練資料
 8: print(f"測試資料筆數: {len(test_data)}")         # 看看有多少筆測試資料
 9: print(f"類別數: {max(train_labels) + 1}")        # 最大標籤值 +1 = 總類別數（因為從 0 開始編號）
10: 
11: # 向量化函式（跟 IMDB 一模一樣：把單字編號轉成 one-hot 向量）
12: def vectorize_sequences(sequences, dimension=10000):
13:     results = np.zeros((len(sequences), dimension))  # 建立全 0 矩陣
14:     for i, sequence in enumerate(sequences):
15:         results[i, sequence] = 1.                    # 出現過的單字標記為 1
16:     return results
17: 
18: x_train = vectorize_sequences(train_data)  # 向量化訓練資料
19: x_test = vectorize_sequences(test_data)    # 向量化測試資料
20: 
21: # 標籤用 one-hot 編碼：因為有 46 個類別，每個標籤會變成長度 46 的向量
22: # 例如類別 3 會變成 [0, 0, 0, 1, 0, 0, ..., 0]（只有第 3 個位置是 1）
23: one_hot_train_labels = to_categorical(train_labels)
24: one_hot_test_labels = to_categorical(test_labels)
25: print(f"標籤 one-hot 維度: {one_hot_train_labels.shape}")  # 應該是 (筆數, 46)

 1: from keras import models  # 載入模型模組
 2: from keras import layers  # 載入層模組
 3: 
 4: model = models.Sequential()                          # 建立順序型模型
 5: model.add(layers.Input(shape=(10000,)))              # 輸入層：10000 維向量（跟 IMDB 一樣）
 6: model.add(layers.Dense(64, activation='relu'))       # 隱藏層 1：64 個神經元（比 IMDB 多，因為分類更複雜）
 7: model.add(layers.Dense(64, activation='relu'))       # 隱藏層 2：64 個神經元
 8: model.add(layers.Dense(______, activation='______'))  # <-- 輸出層：幾個神經元？什麼啟動函數？
 9: 
10: model.compile(optimizer='rmsprop',
11:               loss='______',            # <-- 什麼損失函數？
12:               metrics=['accuracy'])
13: 
14: model.summary()  # 印出模型架構摘要（可以看到每層的參數數量）

 1: # 切出驗證集（前 1000 筆當驗證，剩下的拿來訓練）
 2: x_val = x_train[:1000]                          # 驗證集特徵
 3: partial_x_train = x_train[1000:]                # 訓練集特徵
 4: y_val = one_hot_train_labels[:1000]             # 驗證集標籤
 5: partial_y_train = one_hot_train_labels[1000:]   # 訓練集標籤
 6: 
 7: # 開始訓練模型
 8: history = model.fit(partial_x_train,
 9:                     partial_y_train,
10:                     epochs=9,                    # 訓練 9 輪
11:                     batch_size=512,              # 每批次 512 筆
12:                     validation_data=(x_val, y_val),  # 每輪結束後用驗證集測試
13:                     verbose=0)                   # 安靜模式，不印進度條
14: 
15: # 用測試集評估模型表現
16: results = model.evaluate(x_test, one_hot_test_labels)
17: print(f"測試集 Loss: {results[0]:.4f}")       # 損失值（越低越好）
18: print(f"測試集 Accuracy: {results[1]:.4f}")   # 準確率（越高越好）
19: 
20: # 拿測試集做預測，看看模型實際猜的結果
21: predictions = model.predict(x_test)
22: # argmax 會找出機率最大的那個位置，就是模型認為的類別
23: print(f"第一筆預測結果: 類別 {np.argmax(predictions[0])}")
24: print(f"第一筆正確答案: 類別 {np.argmax(one_hot_test_labels[0])}")

 1: import matplotlib.pyplot as plt  # 載入繪圖套件
 2: 
 3: # 繪圖輔助函數（跟 IMDB 用的一樣）
 4: def plot_train_history(hdict, train_key, val_key, ylabel, filename, axis_range=None):
 5:     plt.cla()                                          # 清除上一張圖
 6:     epochs = range(1, len(hdict[train_key]) + 1)       # X 軸：epoch 編號
 7:     plt.plot(epochs, hdict[train_key], 'bo', label='Training ' + ylabel.lower())   # 訓練曲線
 8:     plt.plot(epochs, hdict[val_key], 'b', label='Validation ' + ylabel.lower())    # 驗證曲線
 9:     plt.title(f'Training and validation {ylabel.lower()}')
10:     plt.xlabel('Epochs')
11:     plt.ylabel(ylabel)
12:     if axis_range:         # 設定座標軸範圍（讓圖看起來更整齊）
13:         plt.axis(axis_range)
14:     plt.legend()           # 顯示圖例
15:     plt.savefig(f"images/{filename}")  # 存檔
16: 
17: history_dict = history.history  # 取得訓練歷史紀錄
18: # 畫 Loss 曲線（座標軸範圍：x=0~10, y=0~3）
19: plot_train_history(history_dict, 'loss', 'val_loss', 'Loss', 'reuters-1.png', [0, 10, 0, 3])
20: # 畫 Accuracy 曲線（座標軸範圍：x=0~10, y=0~1）
21: plot_train_history(history_dict, 'accuracy', 'val_accuracy', 'Accuracy', 'reuters-2.png', [0, 10, 0, 1])

 1: from sklearn.datasets import fetch_california_housing  # 從 scikit-learn 載入加州房價資料集
 2: from sklearn.model_selection import train_test_split   # 載入資料分割工具
 3: import numpy as np
 4: 
 5: housing = fetch_california_housing()                   # 下載並載入資料集
 6: print(f"資料集大小: {housing.data.shape}")              # 看看有幾筆資料、幾個特徵
 7: print(f"特徵名稱: {housing.feature_names}")            # 8 個特徵：收入、屋齡、房間數等等
 8: print(f"目標: 房價中位數（單位：十萬美元）")
 9: 
10: # 把資料分成訓練集（80%）和測試集（20%），random_state=42 是為了讓每次分割結果一樣
11: train_data, test_data, train_targets, test_targets = train_test_split(
12:     housing.data, housing.target, test_size=0.2, random_state=42)
13: print(f"訓練集: {train_data.shape}, 測試集: {test_data.shape}")

 1: from keras import models  # 載入模型模組
 2: from keras import layers  # 載入層模組
 3: 
 4: # 把模型建構包成函式，方便重複使用
 5: def build_model():
 6:     model = models.Sequential()                                    # 順序型模型
 7:     model.add(layers.Input(shape=(train_data.shape[1],)))          # 輸入層：8 個特徵
 8:     model.add(layers.Dense(64, activation='relu'))                 # 隱藏層 1：64 個神經元
 9:     model.add(layers.Dense(64, activation='relu'))                 # 隱藏層 2：64 個神經元
10:     model.add(layers.Dense(1))
11:     # ↑ 輸出層：1 個神經元，不加啟動函數！因為是迴歸問題，要直接輸出房價數值
12:     model.compile(optimizer='rmsprop',    # 優化器：RMSprop
13:                   loss='mse',             # 損失函數：均方誤差（Mean Squared Error）
14:                   metrics=['mae'])        # 評估指標：平均絕對誤差（Mean Absolute Error）
15:     return model

 1: model = build_model()  # 呼叫函式建立模型
 2: 
 3: # 開始訓練！validation_split=0.2 表示自動從訓練資料中切 20% 當驗證集
 4: history = model.fit(train_data, train_targets,   # 訓練資料和目標值（房價）
 5:                     validation_split=0.2,        # 自動切 20% 做驗證
 6:                     epochs=100,                  # 訓練 100 輪
 7:                     batch_size=32,               # 每批次 32 筆
 8:                     verbose=0)                   # 安靜模式
 9: 
10: # 在測試集上評估模型表現（用模型沒看過的資料來測試）
11: test_mse, test_mae = model.evaluate(test_data, test_targets, verbose=0)
12: print(f"測試集 MSE: {test_mse:.4f}")   # 均方誤差（越低越好）
13: print(f"測試集 MAE: {test_mae:.4f}")   # 平均絕對誤差（越低越好）
14: print(f"→ 平均預測誤差約 {test_mae:.2f} 十萬美元（約 {test_mae*10:.1f} 萬美元）")  # 把 MAE 換算成實際金額

 1: import matplotlib.pyplot as plt  # 載入繪圖套件
 2: 
 3: history_dict = history.history   # 取得訓練歷史紀錄
 4: 
 5: plt.cla()                        # 清除上一張圖
 6: plt.figure(figsize=(12, 4))      # 建立一個寬 12、高 4 的畫布（放兩張子圖剛好）
 7: 
 8: # 左邊的子圖：Loss (MSE) 曲線
 9: plt.subplot(1, 2, 1)                                     # 1 列 2 欄的第 1 格
10: plt.plot(history_dict['loss'], label='Training')          # 訓練集的 MSE
11: plt.plot(history_dict['val_loss'], label='Validation')    # 驗證集的 MSE
12: plt.title('Loss (MSE)')        # 圖標題
13: plt.xlabel('Epochs')           # X 軸
14: plt.ylabel('MSE')              # Y 軸
15: plt.legend()                   # 顯示圖例
16: 
17: # 右邊的子圖：MAE 曲線
18: plt.subplot(1, 2, 2)                                     # 1 列 2 欄的第 2 格
19: plt.plot(history_dict['mae'], label='Training')           # 訓練集的 MAE
20: plt.plot(history_dict['val_mae'], label='Validation')     # 驗證集的 MAE
21: plt.title('Mean Absolute Error')
22: plt.xlabel('Epochs')
23: plt.ylabel('MAE')
24: plt.legend()
25: 
26: plt.tight_layout()             # 自動調整子圖間距（避免標題被切掉）
27: plt.savefig("images/california-housing-train.png", dpi=300)  # 存成高解析度 PNG
28: print("圖已儲存")