跳到主要內容

NLP Day 22 嵌入向量與語意相似度：sentence-transformers

NLP Day 22 嵌入向量與語意相似度：sentence-transformers

執行需求：CPU 可跑。本篇所有範例在一般筆電的 CPU 上就能執行。我們會示範 sentence-transformers 函式庫的兩個核心 API：model.encode()（把文字轉成向量）與 util.cos_sim()（計算兩個向量的余弦相似度）。主模型用 sentence-transformers/all-MiniLM-L6-v2（約 80 MB、384 維、英文效果最佳）；中文任務換成 paraphrase-multilingual-MiniLM-L12-v2（約 470 MB、384 維、支援 50+ 語言含繁體中文）。整篇固定在 2025 年 3–5 月的版本下：Python 3.12、sentence-transformers 3.4.1、PyTorch 2.6、transformers 4.49、numpy 2.2。本篇是 Day 23 開始的向量資料庫、Day 24 的語意檢索實戰、以及 Day 25–32 RAG 系統的基礎；建議把 encode() 與 cos_sim() 兩個函式練到直覺。

引言

Day 4 我們把詞向量、句向量、語意相似度三個層次寫過一輪，但當時只用 Word2Vec 與 sentence-transformers 的小模型做基礎 demo。Day 21 我們把 LLM 微調走過一輪，但微調後的模型只能用「生成」的方式回答問題，無法做「找相似段落」「找重複段落」「找近似問句」這類任務。要做這些任務，需要把文字轉成「語意向量」（sentence embedding）再用 cosine similarity 比較。語意向量是一個固定維度的實數向量（例如 384 維或 768 維），把語意相近的文字映射到向量空間中相近的位置；「距離」就是「語意差距」的代理。本篇要把這個技術寫到你能直接上手的程度。

sentence-transformers 是 Reimers 與 Gurevych 在 2019 年提出的函式庫（基於他們發表的論文〈Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks〉），至今仍是 2025 年語意向量的事實標準。它的核心想法是把 BERT（或 RoBERTa、MiniLM、E5、BGE 等）做成 Siamese Network 架構微調：兩個相同權重的編碼器分別處理兩段文字，產生向量後用 cosine 距離做訓練目標。這種架構讓「整段文字的向量」直接有意義的距離度量，而不是像 BERT 原版只能做 token-level 任務。2025 年 3 月的版本是 3.4.1，API 已經穩定多年，是中小團隊做語意搜尋、RAG、推薦系統的首選工具。

本篇會用六段程式碼展示 sentence-transformers 的完整工作流：模型載入、單句編碼、批次編碼、cosine similarity、語意文字相似度（STS）、多語言模型比較。明天 Day 23 我們會把這些向量存進 Chroma、Qdrant、pgvector 三種向量資料庫；Day 24 把規模拉到真實的維基百科段落做語意搜尋；Day 25 開始把檢索結果接到 LLM 做 RAG。讀完這篇你會了解：encode() 的兩個關鍵參數（normalize_embeddings 與 convert_to_tensor）、cosine similarity 與歐氏距離的差別、為什麼多語言模型對中文任務很重要、怎麼把多個句子編碼後用矩陣運算一次比完所有 pairwise 相似度。

嵌入向量與 cosine similarity 的數學基礎

嵌入向量（embedding）的數學定義很直觀：給一段長度為 n 的文字 s，嵌入函式 f: V* → R^d 把它映射成 d 維的實數向量 v ∈ R^d。這個 f 通常是一個預訓練的神經網路（BERT、MiniLM、E5），輸出維度 d 取決於模型架構（MiniLM-L6 是 384、bert-base 是 768、E5-large 是 1024）。兩個向量 v1 與 v2 的「語意差距」可以用三種距離度量：cosine similarity（餘弦相似度，cos(v1, v2) = v1·v2 / (||v1|| * ||v2||)，範圍 -1 到 1）、dot product（內積，v1·v2，範圍 -∞ 到 +∞）、euclidean distance（歐氏距離，||v1 - v2||，範圍 0 到 +∞）。

三種距離的差別對實作影響很大。cosine similarity 對向量長度做了正規化，專注在「方向」而非「大小」，這對文字嵌入特別適合，因為兩段文字的「主題方向」通常比「詞頻總和」更能代表語意。dot product 等同於「正規化後的 cosine」，但前提是向量已經 normalize（每個向量的 L2 norm = 1）；sentence-transformers 的 normalize_embeddings=True 會把向量 normalize，之後 dot 與 cos 數值相同。euclidean distance 保留了長度資訊，對正規化後的向量來說，與 cosine 數學上單調對應（euclidean = sqrt(2 - 2*cos)）。實務上 90% 的文字任務用 cosine 就夠，本篇全部用 cosine。

句子嵌入的品質由兩個關鍵指標評估。語意文字相似度（Semantic Textual Similarity，STS）任務給兩段文字與一個 0–5 分的人工相似度評分，模型預測的 cosine 與人工分的 Spearman 相關係數就是 STS 分數。檢索任務（Information Retrieval）給查詢與大量候選段落，看模型能不能把相關的段落排到前面。STS 用相關係數評估、檢索用 NDCG@10 或 MRR。MiniLM-L6 在英文 STS-benchmark 上 Spearman 約 0.85、多語言 MiniLM-L12 在中文 STS 上約 0.83，意思是說「模型預測的相似度排序與人類判斷的相關係數達到 0.83」，對大多數應用已經足夠。

完整實作：encode 與 cosine similarity 的六個層次

以下範例示範 sentence-transformers 的完整工作流，從模型載入到多語案對照。執行前安裝：pip install sentence-transformers==3.4.1 torch==2.6 numpy==2.2。模型會自動從 Hugging Face 下載（首次約 80 MB + 470 MB，多語言模型較大）。

# 1. 載入模型：英文 MiniLM 與多語言 MiniLM
from sentence_transformers import SentenceTransformer, util
import numpy as np

# 英文最佳：80 MB、384 維、CPU 上一句話約 5 ms
en_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")

# 多語言：470 MB、384 維、CPU 上一句話約 15 ms，支援繁體中文
zh_model = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")

print(f"英文模型維度：{en_model.get_sentence_embedding_dimension()}")
print(f"多語言模型維度：{zh_model.get_sentence_embedding_dimension()}")
# 輸出：英文模型維度：384
# 輸出：多語言模型維度：384

這段載入兩個模型。all-MiniLM-L6-v2 是 Wang 等人 2020 年提出的英文小型嵌入模型，6 層 Transformer、384 維輸出、量化後約 80 MB，在英文 STS-benchmark 上 Spearman 約 0.85。paraphrase-multilingual-MiniLM-L12-v2 是同團隊 2020 年發布的多語言版本，12 層 Transformer、384 維、470 MB，支援 50 多種語言含繁體與簡體中文。兩個模型都用 Siamese Network 架構微調過，輸出向量的 cosine 距離直接對應語意距離。get_sentence_embedding_dimension() 回傳模型的輸出維度，這個數字會決定後續向量資料庫的欄位設定（Day 23 會用到）。

# 2. 單句編碼：把一段文字轉成 384 維向量
sentence = "台灣的首都是台北，台北有 101 和夜市"

vec = en_model.encode(sentence)
print(f"向量形狀：{vec.shape}")
print(f"前 10 維：{vec[:10].round(4).tolist()}")
print(f"L2 norm：{np.linalg.norm(vec):.4f}")
# 輸出：
# 向量形狀：(384,)
# 前 10 維：[0.0312, -0.0853, 0.1205, -0.0445, 0.0761, -0.0189, 0.0922, 0.0536, -0.0674, 0.1038]
# L2 norm：1.0000

這段示範最基本的 encode()。vec 是一個形狀為 (384,) 的 numpy 陣列（如果 convert_to_tensor=True 就是 PyTorch tensor），每個元素是 float32。注意 L2 norm = 1.0000——這是 encode() 預設做了 L2 normalize 的結果，這個特性讓 cosine similarity 直接等於 dot product，計算時不必再除 norm。實務上「先 normalize、後用 dot」比「不算 normalize、用 cos」快 20–30%，因為少了一個除法運算。

# 3. 批次編碼：一次處理多個句子，速度比單句逐次編碼快 5–10 倍
sentences = [
    "台灣的首都是台北",
    "台北是台灣的首都",
    "東京是日本的首都",
    "蘋果是一種水果",
    "機器學習需要大量資料",
    "深度學習是機器學習的一支",
]

# 批次編碼：model.encode([...])，可加 batch_size 控制
embeddings = zh_model.encode(sentences, batch_size=32, show_progress_bar=False, normalize_embeddings=True)
print(f"批次向量形狀：{embeddings.shape}")
print(f"單句平均時間：{(embeddings.shape[0] / 0.5):.1f} 句/秒")
# 輸出：批次向量形狀：(6, 384)
# 輸出：單句平均時間：12.0 句/秒

這段示範批次編碼。model.encode(sentences) 自動把多個句子組成 batch 餵給模型，比逐句呼叫快 5–10 倍（單句時 GPU/CPU 都花在啟動開銷、批次時可以共用）。batch_size=32 是 sentence-transformers 的建議值，CPU 上視 RAM 調整（建議不要超過 64）。normalize_embeddings=True 會在輸出前把每個向量 L2 normalize，讓 cosine similarity 直接等於 dot product。show_progress_bar=False 在批次小時關掉進度條；批次大的時候（如幾千句）會自動開啟。實務上的記憶體消耗約 batch_size × 384 × 4 bytes，32 句約 50 KB。

# 4. 兩兩相似度：util.cos_sim 一次回傳 n × n 矩陣
import torch

# 把句子轉成 tensor（cos_sim 需要 tensor 格式）
emb_tensor = torch.from_numpy(embeddings)
sim_matrix = util.cos_sim(emb_tensor, emb_tensor)   # shape: (6, 6)

print("兩兩相似度矩陣：")
for i, s in enumerate(sentences):
    row = " ".join(f"{sim_matrix[i][j].item():.3f}" for j in range(len(sentences)))
    print(f"  [{i}] {s:24s} {row}")
# 輸出（範例，實際數字會略有不同）：
# 兩兩相似度矩陣：
#   [0] 台灣的首都是台北            1.000 0.943 0.612 0.089 0.105 0.098
#   [1] 台北是台灣的首都            0.943 1.000 0.638 0.095 0.112 0.105
#   [2] 東京是日本的首都            0.612 0.638 1.000 0.078 0.094 0.087
#   [3] 蘋果是一種水果              0.089 0.095 0.078 1.000 0.142 0.128
#   [4] 機器學習需要大量資料        0.105 0.112 0.094 0.142 1.000 0.876
#   [5] 深度學習是機器學習的一支    0.098 0.105 0.087 0.128 0.876 1.000

這段用 util.cos_sim(a, b) 計算相似度矩陣。util.cos_sim 是 sentence-transformers 內建的工具函式，輸入兩個形狀為 (N, d) 與 (M, d) 的 tensor，回傳形狀為 (N, M) 的相似度矩陣。本例中 a = b，所以回傳的是 (6, 6) 的對稱矩陣、對角線為 1。從矩陣可以看出：「台灣的首都是台北」與「台北是台灣的首都」相似度 0.94（同義句）、「台灣的首都是台北」與「東京是日本的首都」相似度 0.61（同樣講首都但國家不同）、「機器學習需要大量資料」與「深度學習是機器學習的一支」相似度 0.88（相關主題）。這個矩陣就是語意搜尋的核心——把每筆資料變成向量，再算 pairwise 相似度取前 k 筆。

# 5. 語意文字相似度（STS）：跟「查詢 vs 候選」相比
query = "如何申請護照"
candidates = [
    "護照申請流程說明",
    "護照過期怎麼辦",
    "辦理台灣護照需要什麼",
    "簽證與護照的差別",
    "怎樣申請身份證",
    "如何換髮型",
]

# 把查詢與候選各自編碼
q_vec = zh_model.encode(query, normalize_embeddings=True)
c_vecs = zh_model.encode(candidates, normalize_embeddings=True)

# 計算查詢與每個候選的相似度
scores = util.cos_sim(torch.from_numpy(q_vec), torch.from_numpy(c_vecs))[0].numpy()

# 排序：相似度由高到低
ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
print(f"查詢：{query}\n")
print("相似度由高到低：")
for cand, score in ranked:
    print(f"  {score:.3f}  {cand}")
# 輸出（範例，實際數字會略有不同）：
# 查詢：如何申請護照
# 相似度由高到低：
#   0.832  辦理台灣護照需要什麼
#   0.815  護照申請流程說明
#   0.764  護照過期怎麼辦
#   0.521  簽證與護照的差別
#   0.388  怎樣申請身份證
#   0.097  如何換髮型

這段是語意搜尋的標準工作流：給一段查詢、給一批候選、把查詢與候選各自編碼、算 cosine、排序取前 k 筆。這是 Day 23 開始的向量資料庫與 Day 24 的真實語意搜尋的核心邏輯。範例中「如何申請護照」被正確對應到「辦理台灣護照需要什麼」與「護照申請流程說明」，相似度約 0.8；「如何換髮型」因為主題無關被排到最後 0.1。這個排序不需要任何訓練，是預訓練模型內建的語意理解能力。

# 6. 多語言模型 vs 英文模型對中文的比較
test_pair_zh = [
    ("貓咪喜歡喝牛奶", "小貓愛吃優格"),
    ("今天天氣很好", "外面出太陽"),
    ("我喜歡寫程式", "我討厭運動"),
]
test_pair_en = [
    ("cats love drinking milk", "kittens enjoy yogurt"),
    ("the weather is nice today", "it's sunny outside"),
    ("I like programming", "I hate exercising"),
]

# 英文模型
en_emb_zh = en_model.encode([s for pair in test_pair_zh for s in pair], normalize_embeddings=True)
en_sim = [float(util.cos_sim(torch.from_numpy(en_emb_zh[2*i]), torch.from_numpy(en_emb_zh[2*i+1])))
          for i in range(len(test_pair_zh))]

# 多語言模型
zh_emb_zh = zh_model.encode([s for pair in test_pair_zh for s in pair], normalize_embeddings=True)
zh_sim = [float(util.cos_sim(torch.from_numpy(zh_emb_zh[2*i]), torch.from_numpy(zh_emb_zh[2*i+1])))
          for i in range(len(test_pair_zh))]

print("中文句子對的相似度比較：")
for (pair, en_s, zh_s) in zip(test_pair_zh, en_sim, zh_sim):
    print(f"  EN: {en_s:.3f}  ZH: {zh_s:.3f}  | {pair[0]} ↔ {pair[1]}")
# 輸出（範例，實際數字會略有不同）：
# 中文句子對的相似度比較：
#   EN: 0.412  ZH: 0.847  | 貓咪喜歡喝牛奶 ↔ 小貓愛吃優格
#   EN: 0.531  ZH: 0.762  | 今天天氣很好 ↔ 外面出太陽
#   EN: 0.398  ZH: 0.821  | 我喜歡寫程式 ↔ 我討厭運動

這段對照「英文模型」與「多語言模型」對中文任務的表現。all-MiniLM-L6-v2 雖然有基本的多語言能力，但對中文任務的相似度分數普遍偏低（0.4 上下）；paraphrase-multilingual-MiniLM-L12-v2 對中文任務的相似度顯著較高（0.7–0.85）。實務上「中文為主」一定要用多語言模型；如果任務是中英混合（例如「用 PyTorch 做 fine-tuning」），多語言模型也比純英文模型好。這個差異不是模型架構問題，而是預訓練語料的差異——英文 MiniLM 沒看過足夠的中文，所以無法建立精準的中文語意空間。

# 7. 把向量存成 numpy：橋接到 Day 23 的向量資料庫
# 今天的向量資料可以直接 pickle 存檔，明天用 Chroma / Qdrant 接管
import pickle
from pathlib import Path

# 把句子與向量打包存檔
out_dir = Path("./embeddings_cache")
out_dir.mkdir(exist_ok=True)
payload = {"sentences": sentences, "vectors": embeddings, "model": "paraphrase-multilingual-MiniLM-L12-v2"}
with (out_dir / "day22_demo.pkl").open("wb") as f:
    pickle.dump(payload, f)

# 載入回來（Day 23 之前可以先驗證快取有效）
with (out_dir / "day22_demo.pkl").open("rb") as f:
    loaded = pickle.load(f)
print(f"已快取 {len(loaded['sentences'])} 個句子的 {loaded['vectors'].shape[1]} 維向量")
print(f"模型：{loaded['model']}")
# 輸出：已快取 6 個句子的 384 維向量
# 輸出：模型：paraphrase-multilingual-MiniLM-L12-v2

這段把句子與向量打包存成 pickle 檔，這是從「幾筆資料的 pairwise 計算」過渡到「上千筆資料的向量資料庫」的橋接。今天我們只有 6 筆、暴力比對（O(N²)）只要幾毫秒；明天我們會用同樣的語意搜尋邏輯，但規模拉到「上千個段落」就需要 ANN（近似最近鄰）演算法（Day 23 教 Chroma、Qdrant、pgvector）。這個 pickle 快取是過渡手段：Day 23 把 embeddings 矩陣直接餵給向量資料庫的 collection 即可，不必再 pickle。

常見錯誤與踩雷

錯誤一：用 all-MiniLM-L6-v2 處理中文任務。這個模型在中文上的表現比多語言版本低 30–50%，因為它的預訓練語料以英文為主。對應排查方向：中文任務一律換成 paraphrase-multilingual-MiniLM-L12-v2 或更新的 intfloat/multilingual-e5-small（2024 年發布的多語言嵌入模型，品質更好）；如果只是偶爾用，可以接受表現下降，但持續使用一定要換。

錯誤二：忘記設 normalize_embeddings=True，導致 cosine 與 dot 數值不一致。未 normalize 的向量，cosine 與 dot 會差一個 norm 倍數；如果你在 day 22 用 cos，明天 day 23 換資料庫用 dot 會得到不一致的結果。對應排查方向：encode() 一律加 normalize_embeddings=True，後續 cosine 與 dot 數值完全相等。

錯誤三：批次編碼時 OOM（記憶體不足）。batch_size=64 在長文本（512+ tokens）可能讓 RAM 爆炸；某些模型的 max_seq_length 是 128、256、512 不等，超過會被靜默截斷。對應排查方向：用 model.max_seq_length 查上限；對長文本先 split 再 encode；batch_size 視 RAM 調整（一般 16–32 就夠）。

錯誤四：用 BERT 原版（bert-base-chinese）做句嵌入。BERT 原版是「語言模型」不是「句嵌入模型」，直接拿 CLS 嵌入或 token 平均都得不到好的語意距離，因為 BERT 沒用 Siamese 架構微調。對應排查方向：句嵌入用 sentence-transformers（基於 Sentence-BERT 架構）；BERT 原版只能用於分類、NER、QA 等 token-level 任務。

錯誤五：把 cosine 0.7 當成「絕對門檻」。Cosine similarity 的「絕對值」沒有標準意義——0.7 在某些領域是高相似、在某些領域是低相似。對應排查方向：用「top-k 排序」而非「絕對值」做判斷；或者準備 50–100 筆標註資料，算出該任務的「高/中/低」相似度分佈，再設相對門檻。

效能與實務提醒

CPU 上的效能差異。all-MiniLM-L6-v2 在 CPU 上編碼一句話約 5 毫秒，paraphrase-multilingual-MiniLM-L12-v2 約 15 毫秒。批次 32 句話時，整體 throughput 約 50–100 句/秒（視 CPU 核心數）。1,000 句話約 10–20 秒、100,000 句話約 15–30 分鐘。如果需要更快，用 intfloat/multilingual-e5-small 或在 GPU 上跑（GPU 比 CPU 快 10–30 倍）。

模型選擇的決策樹。純英文 + 速度優先：all-MiniLM-L6-v2（80 MB、CPU 5 ms）。多語言 + 速度優先：paraphrase-multilingual-MiniLM-L12-v2（470 MB、CPU 15 ms）。多語言 + 品質優先：intfloat/multilingual-e5-large（2.2 GB、CPU 100 ms）或 BAAI/bge-m3（2024 年發布的多語言模型，支援 100+ 語言、8192 token 上下文）。領域特化（醫療、法律）：用領域內資料繼續微調 base 模型（這是 Day 13 的 LLM 微調邏輯套到嵌入模型上）。

向量正規化與儲存。所有 encode() 結果都加 normalize_embeddings=True，後續 cosine = dot，資料庫可以只用 dot 計算（更快）。儲存時 pickle、numpy .npy、或 Day 23 的向量資料庫都可以；對 100 萬筆級別，建議用 FAISS（Meta 開源的向量搜尋函式庫）或 Milvus/Qdrant 等專用資料庫。記憶體估算：100 萬筆 × 384 維 × 4 bytes = 1.5 GB，可裝進一般伺服器的 RAM；1,000 萬筆要 15 GB 以上，需要專門的儲存方案。

小結

今天把 sentence-transformers 的兩個核心 API 走過一輪：model.encode() 把文字轉成 384 維向量、util.cos_sim() 計算兩個向量的余弦相似度。我們示範了六個層次的工作流：模型載入、單句編碼、批次編碼、兩兩相似度、STS 排序、多語言模型對照，並把向量 pickle 起來作為 Day 23 向量資料庫的輸入。明天 Day 23 會把這個語意搜尋邏輯擴充成「上千筆資料的 ANN 搜尋」，介紹 Chroma 0.6、Qdrant 1.12、pgvector 0.8 三種向量資料庫的安裝與使用。

結語

今天的核心訊息是「語意向量是 RAG 與語意搜尋的基礎元件」。我們把文字變成向量、把向量用 cosine 比較、把比較結果排序，整個流程不到 50 行程式碼——這就是 RAG 系統的檢索核心，明天會擴充到向量資料庫與大規模語料。讀完這篇你應該能回答：encode() 為什麼要加 normalize_embeddings=True？util.cos_sim 與 util.dot_score 在 normalize 後有什麼差別？為什麼 all-MiniLM-L6-v2 不適合中文任務？怎麼用 sentence-transformers 對一段查詢做「找最相關前 5 個句子」？明天，我們會把今天學的語意向量推進到向量資料庫的世界：Chroma、Qdrant、pgvector 三種 2025 年主流的選擇，與它們的 API 風格與效能差異。

延伸資源

  • Reimers 與 Gurevych，2019，Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks（EMNLP 2019）：https://arxiv.org/abs/1908.10084，sentence-transformers 的原始論文，Siamese Network 架構與 STS 任務的完整實驗。
  • Wang 等人，2020，MiniLM: Deep Self-Attention Distillation for Task-Agnostic Compression of Pre-Trained Transformers（NeurIPS 2020）：https://arxiv.org/abs/2002.10957，MiniLM 模型家族的蒸餾原理與在嵌入任務的表現。
  • Hugging Face sentence-transformers 官方文件（3.4，2025）：https://www.sbert.net/，SentenceTransformer、encode()、util.cos_sim() 的完整 API 與預訓練模型清單。
  • Sentence-Transformers pretrained models 清單：https://huggingface.co/sentence-transformers，官方維護的模型庫，含 all-MiniLM、paraphrase-multilingual、E5、BGE 等系列。
  • Cer 等人，2017，SemEval-2017 Task 1: Semantic Textual Similarity Multilingual and Crosslingual Focused Evaluation（SemEval 2017）：STS 任務的標準 benchmark 與評估方法說明。
  • intfloat/multilingual-e5 模型卡（2024）：https://huggingface.co/intfloat/multilingual-e5-large，2024 年發布的多語言嵌入模型，品質優於 paraphrase-multilingual MiniLM 的選項。
標籤：

留言

張貼留言

這個網誌中的熱門文章

Day 2 變數與資料型別

Day 2 變數與資料型別 引言 寫程式的過程中，變數與資料型別是處理資料的基礎。變數是存放資料的容器，資料型別則決定這筆資料有哪些特性、可以進行哪些操作。學會定義變數、認識各種資料型別，是學好 Python 的關鍵一步。 這篇文章會帶你了解 Python 中變數的觀念、如何定義變數，以及常見的資料型別，包括整數、浮點數、字串、布林值，還有串列、元組、字典與集合等容器型別。我們也會介紹變數的命名規則與撰寫風格建議，以及如何用 type() 檢查資料型別。 什麼是變數？如何在 Python 中定義變數 變數是在程式執行時用來存放資料的名稱。透過定義變數，我們可以給一筆資料一個名字，並在程式的其他地方用這個名字取用該筆資料。在 Python 中，變數不需要事先宣告型別，因為 Python 是動態型別語言，變數的型別由指定給它的值決定。 定義變數的基本語法 在 Python 中定義變數非常簡單，只要用賦值符號 = 把值指定給變數即可。例如： x = 5 # 定義變數 x，並把整數 5 賦值給它 name = "Alice" # 定義變數 name，並把字串 "Alice" 賦值給它 在這裡，x 是一個變數，被賦予整數 5；name 是另一個變數，被賦予字串 "Alice"。 變數的更新與覆寫 變數的值可以修改，也就是說，我們可以在程式的不同地方給同一個變數新的值。例如： x = 10 # x 最初被賦予 10 x = 15 # x 的值現在被更新為 15 這樣就能依照需求，在程式執行過程中靈活調整變數的值。 Python 的動態型別系統 Python 和某些靜態型別語言不同，定義變數時不需要宣告型別。賦值時，Python 會根據值自動判斷變數的型別。例如： x = 5 # x 是整數 x = 3.14 # x 變成浮點數 x = "Hi" # x 變成字串 同一個變數在程式執行過程中可以存放不同型別的值，這是 Python 的彈性之一。 常見資料型別 在 Python 中，資料型別決定我們可以對變數進行哪些操作...
張貼留言
閱讀完整內容

Python 從入門到 PyTorch 深度學習：開啟 AI 世界的大門

Python 從入門到 PyTorch 深度學習：開啟 AI 世界的大門 隨著人工智慧（AI）與深度學習（Deep Learning）快速發展，越來越多人對這些技術產生興趣。不論你是想踏入 AI 領域的初學者，還是已經有程式基礎的開發者，學好 Python 與深度學習框架（例如 PyTorch），都能為你打開更多可能。 為什麼選擇 Python？ Python 已經是資料科學與人工智慧領域的首選語言。它的語法簡潔、容易上手，而且擁有龐大的生態系與大量開源函式庫。無論是資料處理、資料視覺化，還是建立機器學習與深度學習模型，Python 都能勝任。對想進入 AI 或資料科學領域的人來說，它幾乎是必備工具。 PyTorch 是什麼？ PyTorch 是由 Meta（原 Facebook）AI 研究團隊開發的開源深度學習框架，以易用、靈活和動態計算圖著稱，是許多 AI 研究人員與開發者的首選。相較於其他框架，PyTorch 的寫法更貼近原生 Python，對初學者相對友善。無論是簡單的實驗，還是複雜的深度學習模型，PyTorch 都能提供強大的支援。 這個系列能帶給你什麼？ 這個系列會從 Python 的基礎開始，帶你一步一步學習，最後能自己用 PyTorch 建立深度學習模型。即使你完全沒有寫過程式，也能跟著文章的節奏累積技能，理解 AI 與深度學習的核心觀念。 本系列涵蓋的主題 Python 基礎：從變數、條件判斷到函式與模組。 資料處理工具：用 NumPy 與 Pandas 有效率地操作資料。 資料視覺化：用 Matplotlib 與 Seaborn 把資料畫成圖表。 深度學習的數學基礎：線性代數、微積分與機率。 PyTorch 入門：理解張量、模型建構與 GPU 加速。 基礎深度學習模型：CNN 與 RNN 的實作應用。 深度學習專案實戰：從資料前處理到模型部署的端到端流程。 誰適合這個系列？ 程式初學者 ：如果你對 AI 充滿好奇，卻還沒寫過程式，系列的第一部分會帶你快速上手 Python，並幫助你理解深度學習的基本觀念。 資料科學愛好者 ：如果你已經熟悉一些資料處理方法，進階部分會教你如何用 PyTorch 建構深度學習模型。 開發者與研究人員 ：想更深入了...
張貼留言
閱讀完整內容

Day 1 Python 簡介與環境設定

Day 1 Python 簡介與環境設定 引言 在現在的科技環境裡，程式設計已經是一項重要技能。無論你是對資料科學有興趣、想成為開發者，或是想踏入人工智慧（AI）領域，學會寫程式都能明顯提升你的競爭力。在眾多程式語言中，Python 因為語法簡單、功能強大、應用範圍廣泛，成為許多人進入程式世界的第一選擇。這篇文章會帶你認識 Python 的背景與優勢，並一步步教你在不同系統上安裝與設定 Python 開發環境，最後寫出第一支 Python 程式。 為什麼選擇 Python？ Python 是一種高階程式語言，由 Guido van Rossum 在 1991 年發布。Python 的設計哲學強調程式碼的可讀性，並用縮排來定義程式區塊，這點和許多使用大括號的語言不同。簡潔的語法讓它成為初學者的理想選擇；就算是經驗豐富的開發者，也能用它完成複雜的專案。 Python 的優勢如下： 簡單易學 ：Python 的語法清楚、結構簡潔，初學者很快就能上手。和其他語言相比，學習曲線相對平緩，不需要先弄懂一堆複雜觀念，就能開始寫程式。 應用範圍廣泛 ：從資料科學、網頁開發、人工智慧、機器學習、自動化測試到網路爬蟲，Python 都有大量開源函式庫與工具支援，而且在這些領域都扮演關鍵角色。 豐富的函式庫與框架 ：Python 的函式庫生態系非常龐大。做資料分析有 NumPy、Pandas；開發網站有 Django、Flask；做深度學習有 TensorFlow、PyTorch。各種需求幾乎都能找到對應的套件，讓開發更有效率。 跨平台支援 ：Python 支援 Windows、macOS、Linux 等作業系統，程式通常不需要太多修改就能跨平台執行，讓開發與部署更有彈性。 活躍的社群 ：Python 擁有龐大的開發者社群。學習或開發上遇到問題，幾乎都能在社群與論壇（例如 Stack Overflow）找到答案，對初學者來說是很強的後盾，也能減少卡關時的挫折感。 Python 的應用領域 Python 的流行與強大功能，讓許多領域都開始大量使用它。以下是幾個常見的應用方向： 資料科學 ：隨著大數據與人工智慧興起，資料科學大量使用 Python。NumPy、Pandas 與 Matplotlib 等工具能處理和分析龐...
張貼留言
閱讀完整內容