前面 Day 1～Day 24，我們已經建立很多傳統 System Design 的基礎：
Load Balancer
Database
Index
Cache
Replication
Sharding
CDN
Message Queue
Rate Limiter
Consistency
CAP
Reliability
Observability
Security
API Design
Capacity Estimation
Real-Time System
從 Day 25 開始，我們進入：
AI System Design
但在開始設計 RAG、AI Agent、AI SaaS 之前，必須先把 AI System
最常出現的基本名詞弄懂。
今天不會一開始就畫很複雜的 Architecture。
我們會先回答：
AI 是什麼？
ML 是什麼？
Deep Learning 是什麼？
Neural Network 是什麼？
LLM 是什麼？
GPT 是什麼？
Token 是什麼？
Context Window 是什麼？
Training 和 Inference 差在哪？
Parameter 是什麼？
Embedding 是什麼？
Vector 是什麼？
Semantic Similarity 是什麼？
Vector Database 又是什麼？
GPU 為什麼常出現在 AI System？
Streaming Response 是什麼？
Hallucination 是什麼？
Temperature 是什麼？
RAG 又是在解決什麼問題？
AI = Artificial Intelligence
逐字：
Artificial
→ 人工的 / 人造的
Intelligence
→ 智慧 / 智能
中文：
人工智慧
AI 是一個非常大的領域。
簡單理解：
讓 Computer 執行一些原本通常需要人類智慧才能完成的工作。
例如：
辨識圖片
理解文字
翻譯
語音辨識
推薦商品
回答問題
下棋
生成圖片
寫程式
所以：
ChatGPT
Image Recognition
Recommendation System
Self-driving Technology
都可能屬於 AI 的應用。
現在很多人聽到 AI 就想到：
ChatGPT
LLM
但 AI 的範圍其實更大。
可以先用非常簡化的關係理解：
Artificial Intelligence
│
↓
Machine Learning
│
↓
Deep Learning
│
↓
Large Language Model
注意：
這是一個方便初學者理解的簡化關係，不代表所有 AI 都一定是 Machine
Learning，也不是所有 Deep Learning 都是 LLM。
ML = Machine Learning
逐字：
Machine
→ 機器
Learning
→ 學習
中文：
機器學習
傳統 Programming 常像：
Rules + Data
↓
Program
↓
Answer
例如：
if score >= 60:
return "PASS"
Programmer 明確寫出 Rule。
Machine Learning 的想法比較像：
Data + Correct Examples
↓
Learning Algorithm
↓
Model
Computer 從大量 Data 中學出 Pattern。
Pattern（模式 / 規律）：
Data 中重複出現、可以被學習或利用的關係。
例如：
大量 Spam Email
可能常出現：
FREE MONEY
CLICK NOW
WINNER
Machine Learning Model 可以從大量 Examples 學習哪些特徵比較常和 Spam
有關。
Model（模型）：
在 Machine Learning 中，可以先理解成：
經過 Training 後，學到某些 Pattern，並可以拿來做 Prediction 或產生
Output 的數學系統。
例如：
Input:
"This movie is amazing!"
↓ Model
Output:
Positive
Model 不是單純：
if amazing → positive
而是從大量 Training Data 中學到更複雜的關係。
Training（訓練）：
讓 Model 從大量 Data 中調整自己內部數值，逐漸學會 Pattern 的過程。
例如：
Training Data
↓
Model makes prediction
↓
Compare with expected result
↓
Calculate error
↓
Adjust model
↓
Repeat many times
可以先把 Training 想成：
Model 的學習階段。
Training Data（訓練資料）：
Training 時提供給 Model 學習的 Data。
例如：
Images
Text
Audio
Code
Labels
Training Data 的品質非常重要。
如果 Data 有很多錯誤：
Bad Data
↓
Model learns bad patterns
常聽到一句：
Garbage In
↓
Garbage Out
意思：
輸入的 Data 品質很差，最後產生的結果通常也會受到影響。
Deep Learning
逐字：
Deep
→ 深的
Learning
→ 學習
中文：
深度學習
Deep Learning 是 Machine Learning 的一個重要分支。
它大量使用：
Neural Network
來學習複雜 Pattern。
Neural Network
逐字：
Neural
→ 神經的
Network
→ 網路
中文：
神經網路
它是一種 Machine Learning Model 結構。
名字受到生物神經系統概念啟發，但：
Artificial Neural Network 並不是人類大腦的完整複製。
可以先把它想成：
Input
↓
Many mathematical transformations
↓
Output
例如：
Image Pixels
↓
Neural Network
↓
"Cat"
Layer（層）：
Neural Network 通常由很多 Layers 組成。
簡化：
Input Layer
↓
Hidden Layer
↓
Hidden Layer
↓
Output Layer
每一層會對 Data 做一些數學 Transformation，再傳給下一層。
為什麼叫：
Deep Learning
這裡的 Deep 可以先理解成：
Neural Network 中存在很多 Layers，可以逐層學習更複雜的
Representation。
例如 Image Recognition：
Pixels
↓
Edges
↓
Shapes
↓
Objects
這只是直覺化例子，實際 Model 內部學到的 Representation
不一定能如此清楚地用人類概念命名。
NLP = Natural Language Processing
逐字：
Natural
→ 自然的
Language
→ 語言
Processing
→ 處理
中文：
自然語言處理
意思：
讓 Computer 處理人類使用的語言。
例如：
English
Chinese
Japanese
NLP Tasks 包含：
Translation
Sentiment Analysis
Text Classification
Question Answering
Summarization
Text Generation
Language Model（語言模型）：
用來處理、理解或產生 Language Sequence 的 Model。
其中一個核心能力可以簡化理解成：
根據前面的文字，預測接下來可能出現什麼。
例如：
I love eating ...
可能接：
pizza
LLM = Large Language Model
逐字：
Large
→ 大型的
Language
→ 語言
Model
→ 模型
中文：
大型語言模型
為什麼叫 Large？
通常是因為它可能具有：
大量 Parameters
大量 Training Data
大量 Computation
LLM 可以執行：
Question Answering
Summarization
Translation
Coding
Reasoning-related tasks
Text Generation
Parameter（參數）：
這裡不是 Java Method：
void hello(String name)
裡面的 name 那種 Parameter。
在 Machine Learning 中：
Parameter 是 Model 在 Training 過程中學到的內部數值。
可以非常簡化想像：
Model
├── parameter 1
├── parameter 2
├── parameter 3
├── ...
└── parameter billions
Training 的重要工作之一，就是調整這些 Parameters。
Weight（權重）：
Neural Network 中一種非常重要的 Parameter，用來控制某個 Input / Signal
對後續計算的影響程度。
非常簡化：
Output
=
Input × Weight
實際 Neural Network 的數學遠比這複雜，但初學時先理解：
Training 會不斷調整很多 Weights，讓 Model 的 Output 越來越符合
Training Objective。
GPT = Generative Pre-trained Transformer
逐字：
Generative
→ 生成式的
Pre-trained
→ 預先訓練的
Transformer
→ 一種 Neural Network Architecture
中文可以理解為：
生成式預訓練 Transformer
Generative（生成式的）：
Model 可以產生新的 Content。
例如：
Generate Text
Generate Code
Generate Image
Generate Audio
因此：
Generative AI（生成式人工智慧）
就是：
可以產生新 Content 的 AI System。
Pre-trained（預先訓練的）：
Pre
→ 事先 / 預先
Trained
→ 已經訓練
意思：
Model 在真正被 User 使用之前，就已經先經過大量 Training。
所以你輸入：
Explain TCP
不是從零開始教 Model TCP。
Model 已經在之前 Training 過程中學到大量 Language Patterns。
Transformer：
一種非常重要的 Neural Network Architecture，現代很多 LLM 都建立在
Transformer 類型的架構上。
Architecture（架構）：
一個 System / Model 內部 Components 如何組成、互動與傳遞 Data
的設計方式。
Transformer 很重要的一個概念是：
Attention
今天不深入完整數學，只先建立基本概念。
Attention（注意力機制）：
Model 在處理一段 Sequence
時，可以學習哪些部分彼此比較相關，並讓相關資訊對計算產生較大的影響。
例如：
The animal didn't cross the street because it was too tired.
理解：
it
指的是什麼，需要考慮前面文字之間的關係。
Attention 幫助 Model 在處理 Sequence 時建立這些關聯。
Sequence（序列）：
有順序的一組 Data。
例如文字：
I
love
system
design
就是一個有順序的 Sequence。
順序改成：
design I system love
意思就不同。
Prompt（提示 / 提示詞）：
User 提供給 AI Model 的 Input Instruction 或 Context。
例如：
Explain Load Balancer in Traditional Chinese.
這整段就是 Prompt。
Prompt 可以包含：
Question
Instruction
Examples
Background Information
Output Format
這是 LLM 最重要的基本概念之一。
Token（詞元 / 文字處理單位）：
Model 實際處理文字時使用的基本單位之一。
LLM 不一定直接把：
System Design
理解成兩個完整 English Words。
Tokenizer 可能把文字切成不同 Tokens。
例如概念上：
"unbelievable"
可能被切成：
"un"
"believ"
"able"
這只是示意。
實際 Token 切法：
取決於 Model 使用的 Tokenizer。
非常重要：
Token ≠ Word
一個 Word：
unbelievable
可能是：
1 token
也可能是：
multiple tokens
中文、英文、程式碼、特殊符號的 Tokenization 方式也可能不同。
因此不要直接假設：
100 words = 100 tokens
Tokenizer
Token
→ 詞元 / 文字處理單位
-izer
→ 可以理解成「負責做這件事的工具 / 處理器」
中文：
分詞器 / Token 切分工具
它負責把原始文字轉換成 Model 可以處理的 Tokens。
Raw Text
↓
Tokenizer
↓
Tokens
Computer 最後不是直接處理文字本身。
Tokenizer 會把 Token 對應成：
Token ID（Token 編號）
概念：
"hello" → 15339
"world" → 1917
數字只是示意。
流程：
Text
↓
Tokens
↓
Token IDs
↓
Model
Vocabulary（詞彙表）：
Tokenizer 所知道的一組 Tokens 與它們對應的 IDs。
概念：
Token ID
----------------
hello 100
world 101
system 102
design 103
實際 Vocabulary 通常很大。
Context（上下文）：
Model 在產生 Output 時，可以參考的相關 Input Information。
例如：
My name is Alvin.
I am learning System Design.
What am I learning?
Model 要利用前面的 Context 才知道答案是：
System Design
Context Window
Context
→ 上下文
Window
→ 視窗 / 可看到的範圍
中文：
上下文視窗
意思：
Model 在一次處理過程中可以納入考量的 Token 範圍。
非常簡化：
Context Window = Model working context capacity
可能包含：
System Instructions
User Prompt
Conversation History
Retrieved Documents
Tool Results
Generated Tokens
具體計算方式依 Model / API 而異。
假設你把：
500-page document
全部丟進 Model。
如果超過 Model 能處理的 Context：
Too many tokens
就需要：
Truncate
Chunk
Retrieve relevant parts
Summarize
這也是之後 RAG 很重要的原因之一。
Truncation（截斷）：
Data 太長時，把其中一部分移除，使長度符合限制。
例如：
100K tokens
但只能送：
smaller allowed context
可能需要移除部分內容。
問題是：
重要資訊可能剛好被截掉
Chunk（資料塊 / 分塊）：
把大型 Content 切成較小的 Pieces。
例如：
100-page PDF
↓
Chunk 1
Chunk 2
Chunk 3
...
之後可以只找與 Question 最相關的 Chunks。
Chunking（分塊）：
把大型 Document 切成多個 Chunks 的 Process。
例如：
Document
↓
Chunking
↓
500 smaller chunks
Chunk 太大：
可能帶入很多無關內容
Chunk 太小：
可能失去上下文
因此 Chunk Size 是 Trade-off。
Inference（推論）：
已經 Training 完成的 Model，真正接收 Input 並產生 Output 的過程。
例如：
User Prompt
↓
Trained LLM
↓
Answer
這就是 Inference。
非常重要：
Training
→ 學習
Inference
→ 使用已學好的 Model 產生結果
類比：
Training
→ 學生準備考試
Inference
→ 學生實際回答題目
AI Application 大部分 User Request 發生的是：
Inference
不是重新 Training 整個 Model。
Input Token（輸入 Token）：
傳入 Model、讓 Model 讀取的 Token。
例如：
Prompt
Conversation History
Retrieved Documents
都可能形成 Input Tokens。
Output Token（輸出 Token）：
Model 產生 Response 時輸出的 Token。
例如：
User:
Explain Redis.
Model:
Redis is...
Model 產生的回答會形成 Output Tokens。
使用某些 AI APIs 時，Cost 可能和：
Input Tokens
+
Output Tokens
有關。
因此 AI System Design 除了：
Latency
Availability
Scalability
還常多一個重要問題：
Inference Cost
Inference Cost（推論成本）：
Model 處理 User Request 並產生 Output 所需要的計算 / 金錢成本。
可能受到：
Model Size
Input Tokens
Output Tokens
Hardware
Batching
Request Volume
影響。
之前已經詳細解釋過 Latency，所以這裡不重新定義。
在 AI System 中，可以再細分：
User sends prompt
↓
Model starts processing
↓
First token appears
↓
Remaining tokens continue
↓
Response completes
因此只看：
Total Response Time
有時不夠。
TTFT = Time To First Token
逐字：
Time
→ 時間
To
→ 到
First
→ 第一個
Token
→ Token
中文：
產生第一個 Token 所需要的時間
例如：
User clicks Send
↓
800 ms
↓
first word appears
TTFT 約 800 ms。
如果 AI 回答總共需要 10 秒：
9 秒完全沒反應
↓
第 10 秒突然整段出現
0.8 秒開始出字
↓
接下來持續產生
即使 Total Time 接近，Case B 的 User Experience 通常比較好。
Token Generation（Token 生成）：
Model 一步一步產生 Output Tokens 的 Process。
非常簡化：
Prompt
↓
Generate token 1
↓
Generate token 2
↓
Generate token 3
↓
...
Autoregressive
拆開理解：
Auto
→ 自己 / 自身
Regressive
→ 這裡可以先理解為依賴先前結果繼續預測
在很多 LLM 中，可以簡化理解成：
Model 會根據已經存在的 Tokens，一步一步預測下一個 Token。
例如：
I
↓
I love
↓
I love system
↓
I love system design
這也是為什麼 Output 常是逐步產生。
Probability（機率）：
某件事情發生的可能程度。
Model 預測 Next Token 時，可以概念化成：
"pizza" → 40%
"food" → 25%
"coding" → 5%
...
Model 再根據 Decoding Strategy 選擇下一個 Token。
Decoding（解碼 / 生成選擇過程）：
在 LLM Generation Context：
根據 Model 對 Next Token 的 Probability Distribution，決定實際要選哪個
Token。
它不是單純：
永遠選最高機率
也可以透過不同設定控制 Output 的多樣性。
Temperature（溫度）：
在 LLM 中：
用來調整 Token Selection Randomness 的一個 Generation Parameter。
非常簡化：
Lower Temperature
→ 通常更集中 / 穩定
Higher Temperature
→ 通常更多樣 / 隨機
例如：
Question:
Capital of Japan?
Answer:
Tokyo
在 Creative Writing 中可能產生更多不同表達。
注意：
Temperature 不是「Model 聰明程度」，也不是「正確率按鈕」。
Deterministic（確定性的）：
相同 Input 在相同條件下，結果傾向固定可預期。
相反：
Non-deterministic（非完全確定性的）
同一個 Input 可能產生不同 Output。
LLM Generation 常可能具有一定程度的非確定性。
Streaming Response
Streaming
→ 串流式、持續傳送
Response
→ 回應
中文：
串流回應
不是等整個 Answer 完成：
Model generates entire answer
↓
Send everything
而是：
Token generated
↓
send
more tokens
↓
send
more tokens
↓
send
User 就會看到文字逐漸出現。
主要改善：
Perceived Latency（感知延遲）
Perceived（感受到的）
即：
User 主觀感受到系統有多快。
Streaming 不一定讓 Model 真正算得更快，但可以讓 User 更早看到結果。
接下來是 RAG 最重要的概念之一。
Embedding（嵌入表示 / 向量表示）：
把 Text、Image 或其他 Data 轉換成一組 Numbers，讓 Computer
可以用數學方式比較它們的語意或特徵。
例如：
"I love dogs"
↓
Embedding Model
↓
[0.12, -0.81, 0.33, ...]
這組 Numbers 就是一個：
Vector
Vector（向量）：
初學者可以先理解成：
一串有順序的 Numbers。
例如：
[0.2, 0.8, -0.1]
這是一個 3-dimensional Vector。
Dimension（維度）：
Vector 中有多少個數值方向 / 位置。
例如：
[0.2, 0.8, -0.1]
有 3 個 Numbers：
3 dimensions
Embedding Vector 實際可能有非常多 Dimensions。
Embedding Model（嵌入模型）：
專門把 Input Data 轉換成 Embedding Vector 的 Model。
Text
↓
Embedding Model
↓
Vector
例如：
"How does Redis cache data?"
↓
Embedding
↓
[...numbers...]
Semantic（語意的）：
和「意思」有關，而不只是字面文字是否完全一樣。
例如：
"How do I reset my password?"
"How can I change my login password?"
Words 不完全相同，但 Meaning 很接近。
這叫：
Semantic Similarity
Semantic Similarity
Semantic
→ 語意的
Similarity
→ 相似度
中文：
語意相似度
意思：
比較兩段 Content 在「意思」上有多接近。
Embedding 的重要用途之一，就是讓 Computer 能用 Vector Math 做這種比較。
Similarity Search（相似度搜尋）：
給定一個 Query，找出 Vector Space 中最相似的 Items。
例如：
Query:
"How do I change my password?"
System 可能找到：
Document A:
"Steps to reset your account password"
即使沒有完全相同 Keywords，也可能因 Semantic Meaning 接近而被找到。
Vector Space（向量空間）：
初學者可以先想像：
每一個 Embedding 都是空間中的一個 Point。
例如二維簡化：
● dog
● puppy
● database
● SQL
意思相近的內容，希望在 Embedding Space 中比較接近。
實際 Embedding 通常不是 2D，而是很多 Dimensions。
Similarity Score（相似度分數）：
用一個數值表示兩個 Vectors 有多相似。
例如概念：
Query ↔ Document A = 0.92
Query ↔ Document B = 0.81
Query ↔ Document C = 0.20
就可以優先 Retrieve A、B。
不同 System 使用的 Similarity Metric 可能不同。
Metric（衡量方式 / 指標）：
用來量化某件事情的方法。
在 Vector Search 中，Metric 可以用來衡量：
兩個 Vectors 有多近 / 多相似
常見方法之一：
Cosine Similarity
Cosine Similarity
Cosine
→ 餘弦
Similarity
→ 相似度
中文：
餘弦相似度
它會利用兩個 Vectors 之間方向的關係衡量相似程度。
今天不深入公式。
先記：
Embedding
↓
Vector
Vector A + Vector B
↓
Similarity Metric
↓
Similarity Score
即可。
Vector Database
Vector
→ 向量
Database
→ 資料庫
中文：
向量資料庫
它是一類特別適合：
Store Vectors
+
Search Similar Vectors
的 Database / Data System。
例如：
Document Chunks
↓
Embeddings
↓
Vector Database
User Query：
Query
↓
Embedding
↓
Similarity Search
↓
Relevant Chunks
這非常重要：
Vector Database
≠
LLM
Vector Database 主要負責：
Store / Index / Search Vectors
LLM 主要負責：
Language Understanding / Generation
兩者在 RAG 中可以一起使用。
Retrieval（檢索）：
從大量 Data 中找出與目前 Query 最相關的資訊。
例如：
10,000 documents
↓
User asks one question
↓
Retrieve 5 relevant chunks
不是把全部 10,000 Documents 都塞進 Prompt。
Retriever（檢索器）：
負責執行 Retrieval 的 Component。
例如：
User Query
↓
Retriever
↓
Vector Database
↓
Relevant Chunks
Retriever 可能使用 Vector Search，也可能使用其他 Search Strategy。
Top-K
Top
→ 最前面的 / 分數最高的
K
→ 一個數量變數
意思：
取排名最高的 K 個 Results。
例如：
Top-3
→ 最相關的 3 個 Chunks
Top-5
→ 最相關的 5 個 Chunks
K 太小：
可能漏掉重要資訊
K 太大：
可能塞進太多 Noise
增加 Token Cost
Noise（雜訊 / 無關資訊）：
對目前 Task 沒幫助，甚至可能干擾 Model 的資訊。
例如 User 問：
How does database replication work?
卻 Retrieve：
CSS tutorial
JavaScript animation
Gym plan
這些就是 Noise。
Relevance（相關性）：
某份 Information 和目前 Query 有多相關。
Retrieval System 的核心目標之一：
High Relevance
也就是：
找到真正能幫助回答問題的 Content。
Hallucination（幻覺）：
在 Generative AI 中：
Model 產生看起來合理，但其實不正確、沒有依據或虛構的內容。
例如：
User:
What does this company policy say?
Model:
The policy gives employees 50 vacation days.
但 Document 根本沒寫。
這就是嚴重問題。
LLM 的核心工作不是：
Search a perfect truth database
而是根據：
Input Context
+
Learned Patterns
產生可能的下一段文字。
所以：
Fluent（流暢）不代表 Factual（事實正確）。
Factual（符合事實的）：
Information 是否和真實事實 / Source 一致。
因此 AI System 常要考慮：
How do we improve factual grounding?
Grounding（依據 / 有資料支撐）：
在 AI Application 中，可以理解成：
讓 Model 的 Answer 依據指定的可信 Information，而不是只靠 Model
自己內部學到的 Patterns。
例如：
Company Documents
Medical Records
Product Database
Current Web Information
把 Relevant Information 提供給 Model。
Knowledge Cutoff（知識截止時間）：
Model 的內部 Training Knowledge 不一定包含某個時間點之後發生的事情。
因此如果 User 問：
What happened today?
只靠 Model 內部 Knowledge 可能不夠。
System 可能需要：
Web Search
Database
API
RAG
Tools
取得最新資訊。
RAG = Retrieval-Augmented Generation
逐字：
Retrieval
→ 檢索
Augmented
→ 增強的 / 加強的
Generation
→ 生成
中文：
檢索增強生成
核心：
先從外部 Data Source 找相關資料，再把資料提供給 LLM 產生 Answer。
假設公司有：
Employee Handbook
Internal Documentation
Product Manual
Private Knowledge Base
這些資訊：
可能不在 Model Training Data
可能一直更新
可能是 Private
所以：
User Question
↓
Retrieve relevant company data
↓
Add data to Prompt
↓
LLM generates answer
Augment（增強 / 補充）：
RAG 裡的：
Augmented
意思就是：
在原本 LLM Generation 之外，額外提供 Retrieved Information。
不是：
重新 Training LLM
而是：
Give LLM more relevant context at inference time
Documents
↓
Chunking
↓
Embedding Model
↓
Embeddings
↓
Vector Database
User Query：
User Question
↓
Embedding Model
↓
Query Vector
↓
Vector Search
↓
Top-K Relevant Chunks
↓
Prompt
↓
LLM
↓
Answer
Day 26 會再深入完整 RAG System。
Prompt Augmentation（Prompt 增強）：
把 Retrieved Information 加入原本 Prompt，讓 LLM 在回答時可以參考。
例如：
System:
Answer using the following company policy.
Context:
[Retrieved policy chunk]
User:
How many vacation days do I have?
GPU = Graphics Processing Unit
逐字：
Graphics
→ 圖形
Processing
→ 處理
Unit
→ 單元
中文：
圖形處理器
GPU 最早主要為大量 Graphics Calculation 設計，但它非常擅長：
大量平行數學運算
而 Deep Learning 需要非常多 Matrix / Tensor Calculations，所以 GPU
被大量用在 AI Training 和 Inference。
之前可能已經看過 CPU，這裡只簡短對照。
CPU = Central Processing Unit
Central → 中央的
Processing → 處理
Unit → 單元
中文：
中央處理器
非常簡化：
CPU
→ General-purpose computation
GPU
→ Very large parallel numerical computation
不是：
GPU 永遠比 CPU 快
而是不同 Workload 適合不同 Hardware。
Parallel Processing（平行處理）：
同一時間執行很多計算工作。
類比：
1 worker
↓
Task 1
↓
Task 2
↓
Task 3
Worker 1 → Task 1
Worker 2 → Task 2
Worker 3 → Task 3
AI 的大量 Matrix Operations 很適合這類 Hardware。
Matrix（矩陣）：
按照 Rows 和 Columns 排列的一組 Numbers。
例如：
[
[1, 2],
[3, 4]
]
Deep Learning 內部會執行大量 Matrix Operations。
今天不用學 Linear Algebra 公式，只要知道：
LLM 背後其實是大量數學計算，不是 Database
裡放著一堆完整句子直接搜尋答案。
Tensor（張量）：
初學時可以先理解成：
可以表示多維 Numerical Data 的資料結構 / 數學物件。
非常簡化：
Scalar → 一個數
Vector → 一排數
Matrix → 二維數字表
Tensor → 可以延伸到更多維度
Deep Learning Framework 常大量使用 Tensors。
Model Size（模型大小）：
可能和：
Number of Parameters
Memory Requirement
Storage Requirement
Compute Requirement
有關。
通常更大的 Model 可能需要更多：
GPU Memory
Inference Time
Cost
但：
Model 越大不代表對所有 Task 都一定越好。
VRAM = Video Random Access Memory
逐字：
Video
→ 影像 / 顯示相關
Random Access Memory
→ 隨機存取記憶體
中文：
顯示記憶體 / GPU 記憶體
GPU 在執行 Model 時，需要把：
Model Weights
Intermediate Data
KV Cache 等資料
放進可用 Memory。
今天先記：
Model 越大、Context 越大、Concurrent Work 越多，通常會增加 Memory
Pressure。
之前已經學過 Concurrency，所以這裡不重新完整定義。
AI Service 也可能同時收到：
User A
User B
User C
...
大量 Requests。
問題變成：
How many requests
can the inference system serve simultaneously?
Throughput 之前已經詳細解釋過。
在 LLM Inference 中，可以觀察：
Requests / second
Tokens / second
例如：
100 requests/sec
或：
50,000 output tokens/sec
Tokens Per Second
Tokens
→ Token 數量
Per Second
→ 每秒
中文：
每秒產生 / 處理多少 Tokens
這是 AI Inference 常見 Performance Metric。
例如：
50 tokens/sec
表示平均每秒產生約 50 個 Output Tokens。
Batching（批次處理）：
把多個 Requests / Inputs 組成一批，一起進行計算。
例如：
Request A
Request B
Request C
Request D
不是完全分開處理，而是：
Batch
[A, B, C, D]
↓
GPU
GPU 的 Parallel Processing 能力可能因此被更有效利用。
Batching 可能提升：
Throughput
Hardware Utilization
但如果為了等 Batch 湊滿：
Request A arrives
↓
wait
↓
wait
↓
Request B arrives
就可能增加：
Latency
所以又是：
Latency
vs
Throughput
Trade-off。
Utilization（使用率）：
Resource 有多少比例正在被使用。
例如：
GPU Utilization = 20%
可能代表 Hardware 沒被充分利用。
但：
100%
也不一定永遠最好，因為還需要考慮 Queue、Latency、Headroom 等。
Queue 之前已詳細解釋過，這裡直接套用。
如果 AI Service：
Incoming Requests
>
GPU Processing Capacity
Requests 可能開始：
Queue
↓
Wait
↓
Inference
Queue 太長：
Latency increases
Timeouts
Bad User Experience
Model Server（模型伺服器）：
專門載入 Model 並處理 Inference Requests 的 Service / Server。
例如：
API Service
↓
Model Server
↓
GPU
↓
Model
Model Server 可能負責：
Request Scheduling
Batching
Model Loading
Token Generation
Streaming
Model Loading（模型載入）：
把 Model Weights 等必要資料載入 Memory，使 Model 可以執行 Inference。
大型 Model 可能很大，因此：
Start Server
↓
Load Model
↓
Ready
可能不是瞬間完成。
Cold Start（冷啟動）：
Service / Model 尚未準備好，需要初始化、載入或建立
Resource，因此第一次 Request 特別慢。
例如：
New AI Worker starts
↓
Load model into GPU memory
↓
Initialize runtime
↓
Serve request
這段額外時間就是 Cold Start Problem 的一部分。
Warm（已暖機 / 已準備好）：
Resource 已初始化，可以直接處理 Request。
Cold Worker
→ model not loaded
Warm Worker
→ model loaded and ready
AI Serving System 常希望保留足夠 Warm Capacity。
Autoscaling（自動擴縮容）：
根據 Traffic / Resource Usage 自動增加或減少 Server Instances。
例如：
Traffic rises
↓
Add model servers
Traffic falls
↓
Remove unnecessary servers
但 AI Autoscaling 比一般 Stateless API 更難，因為：
GPU expensive
Model loading slow
Cold start
Large memory requirement
最基本的 AI Application：
User
↓
Frontend
↓
API Service
↓
Model Server
↓
LLM
↓
Response
如果使用 Streaming：
User
↓
API Service
↓
Model Server
↓
Generate tokens
↓
Stream tokens
↓
User
這是今天最重要的 System Design 觀念之一。
很多人以為：
AI App = LLM
其實 Production AI Application 可能還需要：
Authentication
Rate Limiting
Prompt Management
Model Routing
Retrieval
Vector Database
Caching
Message Queue
Observability
Safety Controls
Database
Cost Monitoring
也就是：
LLM 只是整個 AI System 的其中一個 Component。
Provider（提供者 / 服務供應商）
Model Provider（模型服務提供者）：
提供 Model 或 Model API 的 Company / Platform。
Application 不一定自己：
Train
Host
Serve
Model。
也可以：
Application
↓
External Model API
↓
Model Provider
Self-Hosted
Self
→ 自己
Hosted
→ 託管 / 部署
Self-Hosted Model（自行部署模型）：
Organization 自己管理 Model Serving Infrastructure。
可能需要自己處理：
GPU
Deployment
Scaling
Model Loading
Monitoring
Failure Handling
Hosted API（託管 API）：
Model Provider 幫你管理 Model Infrastructure，你透過 API 呼叫。
優點可能包括：
Simpler operations
No direct GPU management
Fast integration
Trade-off 可能包括：
External dependency
Cost
Latency
Rate limits
Data governance considerations
Model Routing（模型路由）：
根據 Request 特性決定要使用哪個 Model。
例如：
Simple classification
→ smaller model
Complex reasoning task
→ stronger model
目的可能是平衡：
Quality
Latency
Cost
Quality（品質） 在 AI System 中：
Model Output 是否符合 Task Requirement。
可能包含：
Correctness
Relevance
Completeness
Safety
Style
因此 AI System Design 常不是只有：
Fast or Slow
而是：
Quality
Latency
Cost
三者一起考慮。
例如：
可能：
Higher quality on difficult tasks
Higher cost
Higher latency
可能：
Lower cost
Lower latency
Enough quality for simple tasks
所以：
不要永遠把所有 Requests 都送到最強、最大的 Model。
Cache 之前已詳細解釋過。
AI Inference 可能昂貴，所以有些情況可以 Cache：
Same deterministic request
↓
Previously generated result
↓
Return cached result
但要小心：
Personalized Prompt
Fresh Data
Non-deterministic Output
Sensitive Data
所以不是所有 AI Response 都適合 Cache。
Semantic Cache（語意快取）：
不只比對 Request 字串完全相同，而是嘗試判斷兩個 Questions 在 Meaning
上是否足夠接近，再考慮重用 Response。
例如：
"How do I reset my password?"
"How can I change my password?"
字串不同，但 Semantic Meaning 很接近。
Trade-off：
如果判斷錯誤，可能回傳不適合的 Cached Answer。
Rate Limiter 之前已詳細解釋過。
AI API 特別需要 Rate Limiting，因為每個 Request 可能消耗昂貴：
Tokens
GPU Compute
External API Cost
除了：
Requests per minute
也可能限制：
Tokens per minute
TPM = Tokens Per Minute
逐字：
Tokens
→ Tokens
Per Minute
→ 每分鐘
中文：
每分鐘 Token 數量
例如：
100,000 TPM
表示一分鐘允許處理的 Token 數量受到某個 Limit 約束。
具體計算規則要看 Provider。
RPM = Requests Per Minute
逐字：
Requests
→ 請求
Per Minute
→ 每分鐘
中文：
每分鐘請求數
因此 AI API 可能同時限制：
RPM
+
TPM
因為：
1 request with 100 tokens
和：
1 request with 100,000 tokens
Compute Cost 完全不同。
Guardrail（護欄 / 防護規則）：
在 AI System 中：
用來限制或檢查 Input / Output，使 System 更符合 Safety、Policy 或
Product Requirements 的機制。
例如：
Input validation
Sensitive-data handling
Output checks
Allowed actions
Business rules
Guardrail 不代表 Model 永遠不會出錯，而是：
增加額外的控制層。
Prompt Injection
Prompt
→ 提示 / 指令
Injection
→ 注入
中文：
提示詞注入攻擊
意思：
惡意或不可信 Input 試圖讓 AI System 忽略原本
Instructions，執行不應執行的行為。
例如外部 Document 中故意寫：
Ignore all previous instructions...
如果 AI Application 無條件把它當成可信 Instruction，就可能出問題。
Untrusted Input（不可信輸入）：
不能假設內容安全、正確或善意的 Input。
例如：
User Input
Web Content
Uploaded Documents
External Tool Results
AI System 要區分：
Instructions
vs
Untrusted Data
Observability 之前已經詳細解釋過。
AI System 除了傳統 Metrics：
Latency
Error Rate
Traffic
CPU/GPU Utilization
還可能需要：
Input Tokens
Output Tokens
TTFT
Tokens/sec
Model Error Rate
Retrieval Latency
Retrieval Quality
Cost per Request
Cost per Request（每個請求成本）：
平均處理一個 User Request 需要多少 Money / Compute Resource。
例如：
1 request
→ retrieval
→ 5K input tokens
→ 1K output tokens
→ model inference
每一步都可能有 Cost。
Evaluation（評估）：
用一套方法衡量 AI System 的 Output 是否符合 Requirement。
傳統 API 很容易測：
2 + 2
expected = 4
actual = 4
但 LLM：
Explain Redis.
可能有很多不同但都合理的 Answers。
所以 AI Evaluation 通常更複雜。
Eval 是：
Evaluation
的常見簡稱。
中文：
評估
AI Team 可能建立：
Eval Dataset
Eval Cases
Eval Metrics
來比較：
Prompt A vs Prompt B
Model A vs Model B
RAG A vs RAG B
Eval Dataset（評估資料集）：
一組專門拿來測試 AI System Quality 的 Examples。
例如：
Question
Expected facts
Expected behavior
當你更換 Model 或 Prompt，可以重新跑 Eval，看看 Quality 有沒有變差。
Regression（退化 / 回歸問題） 在 Software Quality Context：
修改 System 後，原本正常的功能或 Quality 反而變差。
例如：
New Prompt
↓
Coding answers improve
↓
But Chinese answers become worse
這可能就是一種 Regression。
Eval 可以幫助發現它。
┌──────────────────┐
│ User │
└────────┬─────────┘
↓
┌──────────────────┐
│ Frontend │
└────────┬─────────┘
↓
┌──────────────────┐
│ API Service │
└────────┬─────────┘
↓
┌──────────────────┐
│ Prompt / Context │
└────────┬─────────┘
↓
┌──────────────────┐
│ Model Server │
└────────┬─────────┘
↓
┌──────────────────┐
│ LLM │
└────────┬─────────┘
↓
Streaming Response
↓
User
Documents
↓
Chunking
↓
Embedding Model
↓
Vectors
↓
Vector Database
Query Path：
User Question
↓
Embedding Model
↓
Query Vector
↓
Retriever
↓
Vector Database
↓
Top-K Relevant Chunks
↓
Prompt Augmentation
↓
LLM
↓
Answer
傳統 Web System 常問：
Database bottleneck?
CPU bottleneck?
Network bottleneck?
AI System 還可能多：
GPU Capacity
Model Loading
Context Length
Token Generation Speed
External Model API Limit
RPM
TPM
Inference Cost
Retrieval Quality
Hallucination
所以 AI System Design 不是把：
Backend
換成：
LLM
就結束。
可以回答：
Training is the process where a model learns patterns by adjusting its
internal parameters using training data. Inference happens after
training, when the trained model receives an input and produces an
output. In a typical AI application, user requests trigger inference
rather than retraining the model from scratch.
中文核心：
Training
→ Model 學習
Inference
→ Model 使用學到的能力回答
不要回答：
Token = Word
比較好的回答：
A token is a basic unit of text processed by a language model. A token
can be a whole word, part of a word, punctuation, or another text unit
depending on the tokenizer. The model processes token IDs rather than
raw text directly.
可以回答：
The context window is the amount of tokenized information a model can
consider during one processing context. It may include the user
prompt, conversation history, retrieved documents, system
instructions, and generated content, depending on the model and
application.
可以回答：
An embedding converts data such as text into a numerical vector.
Content with similar meaning can often be represented by vectors that
are close according to a similarity metric. This makes embeddings
useful for semantic search and retrieval systems.
可以回答：
A vector database stores and indexes vectors so the system can
efficiently search for items with similar vector representations. In a
RAG system, document chunks can be converted into embeddings and
stored in a vector database, then relevant chunks are retrieved for a
user query.
完整縮寫：
R
= Retrieval
= 檢索
A
= Augmented
= 增強的
G
= Generation
= 生成
可以回答：
RAG stands for Retrieval-Augmented Generation. The system first
retrieves relevant information from an external knowledge source and
then provides that information to the language model as context before
generation. It is useful when the application needs private,
domain-specific, or frequently updated knowledge.
可以回答：
Deep learning models require a large amount of numerical computation,
especially matrix and tensor operations. GPUs are designed to perform
many numerical operations in parallel, so they are widely used for
model training and inference. However, whether a GPU is necessary
depends on the workload and model.
不一定。
Streaming 主要是：
Generate some tokens
↓
Send immediately
↓
Continue generating
它可以改善：
Perceived Latency
但不代表：
Total computation automatically becomes smaller
不能這樣簡化。
Temperature 主要控制：
Token Selection Randomness
Lower Temperature 通常讓 Output 更集中。
但：
Low Temperature
≠
Guaranteed Correct
如果 Model 不知道答案，Temperature 設很低仍可能產生錯誤內容。
不能。
RAG 可以：
Provide relevant external evidence
Improve grounding
但仍可能：
Retrieve wrong documents
Miss important documents
Misinterpret context
Generate unsupported claims
所以 Production System 還需要：
Evaluation
Source Attribution
Guardrails
Monitoring
Source Attribution
Source
→ 來源
Attribution
→ 歸屬 / 標示來源
中文：
來源標示
意思：
Answer 告訴 User 某個 Claim 主要依據哪份 Source。
例如：
According to Employee Handbook Section 5...
它可以幫助：
Verification
Trust
Debugging
但 Citation 本身也必須真的對應到支持 Claim 的 Source。
傳統 System Design：
Requirement
↓
Traffic
↓
Storage
↓
Bottleneck
↓
Architecture
↓
Trade-off
AI System Design 仍然需要這些。
只是還要多問：
Which AI capability?
↓
Which model?
↓
How much context?
↓
Need RAG?
↓
Need private/current data?
↓
Latency requirement?
↓
Streaming?
↓
Expected tokens?
↓
Quality requirement?
↓
Cost budget?
↓
Safety requirement?
↓
Evaluation strategy?
AI Basics
□ AI
□ Artificial Intelligence
□ ML
□ Machine Learning
□ Pattern
□ Model
□ Training
□ Training Data
□ Deep Learning
□ Neural Network
□ Layer
Language
□ NLP
□ Natural Language Processing
□ Language Model
□ LLM
□ Large Language Model
□ Parameter
□ Weight
□ GPT
□ Generative
□ Pre-trained
□ Transformer
□ Architecture
□ Attention
□ Sequence
Prompt / Token
□ Prompt
□ Token
□ Tokenizer
□ Token ID
□ Vocabulary
□ Context
□ Context Window
□ Truncation
□ Chunk
□ Chunking
□ Input Token
□ Output Token
Inference
□ Inference
□ Training vs Inference
□ Inference Cost
□ TTFT
□ Time To First Token
□ Token Generation
□ Autoregressive
□ Probability
□ Decoding
□ Temperature
□ Deterministic
□ Streaming Response
□ Perceived Latency
Embedding / Retrieval
□ Embedding
□ Vector
□ Dimension
□ Embedding Model
□ Semantic
□ Semantic Similarity
□ Similarity Search
□ Vector Space
□ Similarity Score
□ Metric
□ Cosine Similarity
□ Vector Database
□ Retrieval
□ Retriever
□ Top-K
□ Noise
□ Relevance
RAG
□ Hallucination
□ Factual
□ Grounding
□ Knowledge Cutoff
□ RAG
□ Retrieval-Augmented Generation
□ Augment
□ Prompt Augmentation
□ Source Attribution
Hardware
□ GPU
□ Graphics Processing Unit
□ CPU
□ Parallel Processing
□ Matrix
□ Tensor
□ Model Size
□ VRAM
□ Video Random Access Memory
Serving
□ Tokens Per Second
□ Batching
□ Utilization
□ Model Server
□ Model Loading
□ Cold Start
□ Warm
□ Autoscaling
□ Model Provider
□ Self-Hosted Model
□ Hosted API
□ Model Routing
Production
□ Quality
□ Quality-Latency-Cost Trade-off
□ Semantic Cache
□ TPM
□ Tokens Per Minute
□ RPM
□ Requests Per Minute
□ Guardrail
□ Prompt Injection
□ Untrusted Input
□ Cost per Request
□ Evaluation
□ Eval
□ Eval Dataset
□ Regression
AI
= Artificial Intelligence
= 人工智慧
ML
= Machine Learning
= 機器學習
NLP
= Natural Language Processing
= 自然語言處理
LLM
= Large Language Model
= 大型語言模型
GPT
= Generative Pre-trained Transformer
= 生成式預訓練 Transformer
TTFT
= Time To First Token
= 產生第一個 Token 所需要的時間
RAG
= Retrieval-Augmented Generation
= 檢索增強生成
GPU
= Graphics Processing Unit
= 圖形處理器
CPU
= Central Processing Unit
= 中央處理器
VRAM
= Video Random Access Memory
= 顯示記憶體 / GPU 記憶體
TPM
= Tokens Per Minute
= 每分鐘 Token 數
RPM
= Requests Per Minute
= 每分鐘請求數
之前已經詳細學過的：
API
RPS
QPS
Latency
Throughput
Cache
Queue
Rate Limiter
Observability
Authentication
Authorization
ACID
CAP
SLI
SLO
SLA
今天就不再重複完整拆解。
Artificial Intelligence
│
↓
Machine Learning
│
↓
Deep Learning
│
↓
Neural Network
│
↓
Large Language Model
LLM Request：
Prompt
↓
Tokenizer
↓
Tokens / Token IDs
↓
LLM Inference
↓
Token Generation
iThome鐵人賽
看影片追技術