感知器

 1: import numpy as np  # 匯入 numpy，它是 Python 的數學神器，處理陣列運算超方便
 2: 
 3: # 階梯函數（step function）：輸入 >= 0 就回傳 1，否則回傳 0
 4: # 就像一個超嚴格的門衛：夠格就放行(1)，不夠格就滾(0)
 5: def step_function(x):
 6:     return np.array(x >= 0, dtype=int)
 7: 
 8: # OR 感知器：模擬 OR 邏輯閘
 9: # 只要有一個輸入是 1，就輸出 1（像「有沒有帶錢或帶卡？有一個就能買飲料」）
10: def OR(x1, x2):
11:     x = np.array([x1, x2])    # 把兩個輸入包成一個陣列
12:     w = np.array([1, 1])       # 權重：兩個輸入同等重要，各給 1
13:     b = -0.5                   # 偏移值（門檻）：加權總和要超過 0.5 才算「過關」
14:     y = np.sum(w*x) + b        # 計算加權總和：w1*x1 + w2*x2 + b
15:     return step_function(y)    # 丟給階梯函數，決定最終輸出 0 或 1
16: 
17: # 測試所有可能的輸入組合，驗證是否符合 OR 真值表
18: print("0 OR 0 -> ", OR(0,0))  # 0+0-0.5 = -0.5 < 0 → 輸出 0 ✓
19: print("0 OR 1 -> ", OR(0,1))  # 0+1-0.5 =  0.5 > 0 → 輸出 1 ✓
20: print("1 OR 0 -> ", OR(1,0))  # 1+0-0.5 =  0.5 > 0 → 輸出 1 ✓
21: print("1 OR 1 -> ", OR(1,1))  # 1+1-0.5 =  1.5 > 0 → 輸出 1 ✓

 1: import numpy as np  # 匯入 numpy
 2: 
 3: # 階梯函數：老朋友了，>= 0 就輸出 1，否則 0
 4: def step_function(x):
 5:     return np.array(x >= 0, dtype=int)
 6: 
 7: # AND 感知器：兩個輸入都是 1 才輸出 1（像「要帶錢而且帶卡才能刷」）
 8: def AND(x1, x2):
 9:     x = np.array([x1, x2])        # 把兩個輸入包成陣列
10:     w = np.array([___, ___])       # 請填入權重（提示：跟 OR 一樣各 0.5 就行）
11:     b = ___                        # 請填入偏移值（提示：門檻要比 OR 高，想想為什麼）
12:     y = np.sum(w*x) + b            # 加權總和 = w1*x1 + w2*x2 + b
13:     return step_function(y)        # 過門檻就輸出 1，沒過就 0
14: 
15: # 測試四種輸入組合，對照 AND 真值表檢查
16: print("0 AND 0 -> ", AND(0,0))  # 預期 0
17: print("0 AND 1 -> ", AND(0,1))  # 預期 0
18: print("1 AND 0 -> ", AND(1,0))  # 預期 0
19: print("1 AND 1 -> ", AND(1,1))  # 預期 1（唯一輸出 1 的情況）

 1: import numpy as np  # 匯入 numpy
 2: 
 3: # 階梯函數：又是你，>= 0 → 1，< 0 → 0
 4: def step_function(x):
 5:     return np.array(x >= 0, dtype=int)
 6: 
 7: # NAND 感知器：AND 的相反！兩個都是 1 才輸出 0，其餘都是 1
 8: # （像「兩個人都遲到才扣分，只要有一個準時就沒事」）
 9: def NAND(x1, x2):
10:     x = np.array([x1, x2])        # 把兩個輸入包成陣列
11:     w = np.array([___, ___])       # 請填入權重（提示：把 AND 的權重「反過來」）
12:     b = ___                        # 偏移值也反過來
13:     y = np.sum(w*x) + b            # 加權總和
14:     return step_function(y)        # 階梯函數判定輸出
15: 
16: # 測試四種輸入組合，對照 NAND 真值表
17: print("0 NAND 0 -> ", NAND(0,0))  # 預期 1
18: print("0 NAND 1 -> ", NAND(0,1))  # 預期 1
19: print("1 NAND 0 -> ", NAND(1,0))  # 預期 1
20: print("1 NAND 1 -> ", NAND(1,1))  # 預期 0（唯一輸出 0 的情況）

 1: import numpy as np  # 匯入 numpy
 2: 
 3: # 階梯函數：>= 0 輸出 1（清醒），< 0 輸出 0（睡著）
 4: def step_function(x):
 5:     return np.array(x >= 0, dtype=int)
 6: 
 7: # 同學資料：每列 = [昨晚睡幾小時, 今天咖啡幾杯]
 8: # 8 位同學的生活作息，老師偷偷記下來的（隱私什麼的先不管了）
 9: X = np.array([[8,2], [4,0], [7,1], [3,1],
10:               [6,2], [5,0], [4,2], [3,0]])
11: # 標籤（正確答案）: 清醒=1, 睡著=0
12: y = np.array([1, 0, 1, 0, 1, 0, 1, 0])
13: names = ['阿明','小美','大雄','胖虎','靜香','小夫','阿福','魯夫']
14: 
15: # 設定感知器的權重和偏移值
16: # w=[1, 0] 表示：只看睡眠時數（權重=1），完全忽略咖啡（權重=0）
17: w = np.array([1, 0])
18: b = -5.5  # 門檻 5.5 小時（睡超過 5.5hr 才判定為清醒）
19: 
20: # 逐一預測每位同學的上課狀態
21: print("預測結果（只看睡眠時數）:")
22: for i in range(len(X)):
23:     # np.dot(w, X[i]) + b = 1*睡眠 + 0*咖啡 - 5.5 = 睡眠 - 5.5
24:     pred = step_function(np.dot(w, X[i]) + b)  # 過階梯函數得到 0 或 1
25:     label = '清醒' if pred == 1 else '睡著'     # 把 0/1 翻譯成人話
26:     correct = '○' if pred == y[i] else '×'      # 跟正確答案比對
27:     print(f"  {names[i]}（睡{X[i][0]}hr, 咖啡{X[i][1]}杯）→ {label} {correct}")

 1: import numpy as np          # 數學運算
 2: import matplotlib.pyplot as plt  # 畫圖用（matplotlib 是 Python 的畫圖神器）
 3: 
 4: # 階梯函數
 5: def step_function(x):
 6:     return np.array(x >= 0, dtype=int)
 7: 
 8: # 同學資料 [昨晚睡幾小時, 今天咖啡幾杯]
 9: X = np.array([[8,2], [4,0], [7,1], [3,1],
10:               [6,2], [5,0], [4,2], [3,0]])
11: # 標籤（正確答案）: 清醒=1, 睡著=0
12: y = np.array([1, 0, 1, 0, 1, 0, 1, 0])
13: names = ['阿明','小美','大雄','胖虎','靜香','小夫','阿福','魯夫']
14: 
15: # TODO: 修改 w 和 b，讓感知器同時考慮睡眠和咖啡
16: # 提示：咖啡的提神效果大約是睡眠的 2 倍，所以咖啡權重應該更大
17: w = np.array([___, ___])  # [睡眠權重, 咖啡權重]，請填入數字
18: b = ___                    # 偏移值（門檻），請填入數字
19: 
20: # 逐一測試每位同學
21: print("預測結果:")
22: for i in range(len(X)):
23:     # np.dot(w, X[i]) 計算內積 = w1*睡眠 + w2*咖啡
24:     pred = step_function(np.dot(w, X[i]) + b)  # 加上偏移值後過階梯函數
25:     label = '清醒' if pred == 1 else '睡著'
26:     correct = '○' if pred == y[i] else '×'
27:     print(f"  {names[i]}（睡{X[i][0]}hr, 咖啡{X[i][1]}杯）→ {label} {correct}")
28: 
29: # ===== 以下是畫圖部分 =====
30: plt.figure(figsize=(6, 5))            # 建立 6x5 吋的圖
31: awake = y == 1                         # 布林陣列：哪些人是清醒的
32: asleep = y == 0                        # 布林陣列：哪些人是睡著的
33: # 清醒的同學畫綠色圓點，睡著的畫紅色叉叉
34: plt.scatter(X[awake, 0], X[awake, 1], c='green', marker='o', s=100, label='清醒')
35: plt.scatter(X[asleep, 0], X[asleep, 1], c='red', marker='x', s=100, label='睡著')
36: # 在每個點旁邊標上名字
37: for i, name in enumerate(names):
38:     plt.annotate(name, (X[i,0]+0.1, X[i,1]+0.1))
39: 
40: # 畫決策邊界（就是那條把清醒和睡著分開的線）
41: # 數學：w1*x1 + w2*x2 + b = 0，移項得 x2 = -(w1*x1 + b)/w2
42: x1_line = np.linspace(2, 9, 100)              # x 軸上取 100 個均勻的點
43: x2_line = -(w[0] * x1_line + b) / w[1]        # 對應的 y 值
44: plt.plot(x1_line, x2_line, 'b--', linewidth=2, label='決策邊界')
45: 
46: plt.xlabel('昨晚睡幾小時')
47: plt.ylabel('今天咖啡幾杯')
48: plt.title('感知器預測：你會不會睡著？')
49: plt.legend()        # 顯示圖例
50: plt.grid(True)      # 顯示格線
51: plt.savefig("images/perceptron-sleep.png", dpi=300)  # 儲存圖片

 1: import numpy as np  # 匯入 numpy
 2: 
 3: # 階梯函數：感知器的「判官」
 4: def step_function(x):
 5:     return np.array(x >= 0, dtype=int)
 6: 
 7: # 訓練資料：每列 = [每週滑手機hr, 每週讀書hr]
 8: # 導師暗中觀察的 6 位同學（這種老師真的存在嗎？）
 9: X = np.array([[30,2], [5,25], [25,5], [10,20], [20,10], [15,15]])
10: y = np.array([0, 1, 0, 1, 0, 1])  # 正確答案：0=被當, 1=存活
11: names = ['小明', '學霸', '阿宅', '認真妹', '社畜', '覺醒者']
12: 
13: # ===== 初始化：一切從零開始 =====
14: w = np.zeros(2)  # 權重初始為 [0, 0]（感知器一開始什麼都不知道）
15: b = 0.0          # 偏移值也從 0 開始
16: eta = 0.01       # 學習率：每次犯錯時調整的幅度（太大會暴走，太小會龜速）
17: 
18: # ===== 訓練過程：從錯誤中學習 =====
19: print(f"初始狀態: w=[{w[0]:.3f}, {w[1]:.3f}], b={b:.3f}")
20: for epoch in range(50):  # 最多跑 50 輪（epoch = 把所有資料看一遍）
21:     w_before, b_before = w.copy(), b  # 先記住這輪開始前的權重（等下比較用）
22:     errors = 0  # 這輪犯了幾次錯
23:     for xi, yi in zip(X, y):  # 逐筆看訓練資料
24:         y_pred = step_function(np.dot(w, xi) + b)  # 用目前的權重做預測
25:         error = yi - y_pred  # 算誤差：正確答案 - 預測值（0=猜對，非0=猜錯）
26:         if error != 0:  # 猜錯了！該調整了
27:             w = w + eta * error * xi  # 更新權重：往正確方向微調
28:             b = b + eta * error       # 更新偏移值
29:             errors += 1               # 錯誤數 +1
30:     # 印出前 5 輪或收斂那輪的狀態
31:     if epoch < 5 or errors == 0:
32:         changed = "（權重已更新）" if (not np.array_equal(w, w_before) or b != b_before) else "（無變化）"
33:         print(f"Epoch {epoch+1:2d}: w=[{w[0]:.3f}, {w[1]:.3f}], b={b:.3f}, 錯誤數={errors} {changed}")
34:     if errors == 0:  # 一整輪都沒犯錯 → 訓練完成！
35:         print("訓練完成！導師的 AI 預警系統上線了。")
36:         break
37: 
38: # ===== 用學到的權重預測每位同學 =====
39: print("\n=== 預測結果 ===")
40: for i in range(len(X)):
41:     pred = step_function(np.dot(w, X[i]) + b)  # 內積 + 偏移 → 階梯函數
42:     result = '存活' if pred == 1 else '被當'
43:     correct = '○' if pred == y[i] else '×'
44:     print(f"  {names[i]}: 滑手機{X[i][0]}hr 讀書{X[i][1]}hr → {result} {correct}")

 1: # （接續上方程式碼，請貼在最後面一起執行）
 2: # 注意：這段需要用到上方已經訓練好的 w 和 b，所以要一起跑
 3: 
 4: # 三位新同學的資料：[每週滑手機hr, 每週讀書hr]
 5: new_students = [
 6:     ("邊緣人", [18, 12]),   # 滑手機略多於讀書，命運未卜
 7:     ("佛系仔", [15, 16]),   # 幾乎一半一半，讀書只多 1 小時
 8:     ("手遊王", [35, 1]),    # 不用預測你也知道結果了吧
 9: ]
10: print("\n=== 導師的黑名單預測 ===")
11: for name, data in new_students:
12:     x = np.array(data)               # 把資料轉成 numpy 陣列
13:     score = np.dot(w, x) + b         # 算分數 = w1*滑手機 + w2*讀書 + b
14:     pred = step_function(score)       # 分數 >= 0 → 存活(1)，< 0 → 被當(0)
15:     status = '存活' if pred == 1 else '被當'
16:     emoji = '安全過關' if pred == 1 else '準備叫家長'
17:     print(f"  {name}: 滑{data[0]}hr 讀{data[1]}hr → 分數={score:.2f} → {status}（{emoji}）")

 1: # （接續任務 A 程式碼，請貼在最後面一起執行）
 2: # 需要用到上方的 w, b, X, y, names
 3: 
 4: import matplotlib.pyplot as plt  # 匯入畫圖工具
 5: 
 6: # 建立一張 7x6 吋的圖
 7: plt.figure(figsize=(7, 6))
 8: survived = y == 1  # 布林遮罩：存活的同學
 9: failed = y == 0    # 布林遮罩：被當的同學
10: 
11: # 畫散佈圖：存活=綠色圓點，被當=紅色叉叉
12: # zorder=5 讓點畫在最上層（不會被線蓋住）
13: plt.scatter(X[survived, 0], X[survived, 1], c='green', marker='o', s=120, label='存活', zorder=5)
14: plt.scatter(X[failed, 0], X[failed, 1], c='red', marker='x', s=120, linewidths=2, label='被當', zorder=5)
15: 
16: # 在每個點旁邊標上同學名字
17: for i, name in enumerate(names):
18:     plt.annotate(name, (X[i,0]+0.5, X[i,1]+0.5), fontsize=10)
19: 
20: # 畫決策邊界（生死線）
21: # 數學推導：w1*x1 + w2*x2 + b = 0 → x2 = -(w1*x1 + b) / w2
22: x1_line = np.linspace(0, 40, 100)  # x 軸（滑手機時數）取 100 個點
23: if w[1] != 0:  # 確認 w2 不是 0（除以 0 會爆炸）
24:     x2_line = -(w[0] * x1_line + b) / w[1]  # 算出對應的 y 值（讀書時數）
25:     plt.plot(x1_line, x2_line, 'b--', linewidth=2, label='決策邊界（生死線）')
26: 
27: plt.xlabel('每週滑手機時數')   # x 軸標籤
28: plt.ylabel('每週讀書時數')     # y 軸標籤
29: plt.title('導師的 AI 預警系統：期末生死分界線')
30: plt.legend()                    # 顯示圖例
31: plt.grid(True, alpha=0.3)      # 淡淡的格線
32: plt.xlim(0, 40)                # x 軸範圍
33: plt.ylim(0, 30)                # y 軸範圍
34: plt.savefig("images/perceptron-flunk.png", dpi=300)  # 存檔（dpi=300 高畫質）
35: print("決策邊界圖已儲存！")
36: print(f"生死線方程式: {w[0]:.3f} × 滑手機 + {w[1]:.3f} × 讀書 + {b:.3f} = 0")