2026-2027 最可能考的 50 個程式相關題型
return sum((y_true - y_pred) ** 2) / len(y_true)
這段程式在做什麼?
這是計算「均方誤差」(Mean Squared Error),用來評估模型預測得準不準。
逐行詳細解說:
(y_true - y_pred):把「實際答案」減去「模型預測的答案」,得到每一個樣本的誤差(有正有負)。** 2:把誤差平方。為什麼要平方?因為誤差有正有負,平方後變成正數,而且大誤差會被放大,這樣模型會更在意大錯誤。sum(...):把所有樣本的誤差加總起來。/ len(y_true):除以總樣本數,得到「平均每一個樣本的誤差」。小提醒: 這就是為什麼叫「均方」誤差!
mask = np.random.binomial(1, p, size=x.shape)
return x * mask / p
這段程式在做什麼?
這是實作「Dropout」這種防止過擬合的技巧。想像你在訓練神經網路時,隨機把一些神經元「關掉」,讓模型不要太依賴某幾個神經元。
逐行詳細解說:
np.random.binomial(1, p, size=x.shape):產生很多 0 或 1 的隨機數字(1 的機率是
p)。1 代表「保留這個神經元」,0 代表「關掉它」。x * mask:把原本的輸出乘上這個遮罩。被關掉的神經元就會變成 0。/ p:因為我們關掉了一些神經元,輸出值會變小,所以要除以 p 來「補回」原本應該有的數值(這叫做 Inverted
Dropout)。為什麼要這樣做? 這可以讓模型學得更穩健,不容易過度依賴某些特徵。
pca = PCA()
pca.fit(noisy)
components = pca.transform(noisy)
filtered = pca.inverse_transform(components)
這段程式想做什麼?
想用 PCA 來去除影像中的雜訊(去噪)。
逐行詳細解說:
PCA():建立一個 PCA 工具,但沒有告訴它「只要保留幾個主成分」,所以它預設會保留全部。pca.fit(noisy):讓 PCA 去看 noisy 這堆資料,找出哪些方向最重要。pca.transform(noisy):把原本的資料「壓縮」到這些重要方向上。pca.inverse_transform(...):再把壓縮後的資料「還原」回原本的形狀。為什麼這段程式沒有效果?
因為你沒有設定
n_components,PCA 就沒有真的「降維」,所以雜訊還是留在裡面!這是考試最常考的陷阱。
cv = StratifiedKFold(n_splits=5, shuffle=True)
scores = cross_val_score(model, X, y, cv=cv, scoring="accuracy")
這段程式在做什麼?
用「分層 5 折交叉驗證」來評估 KNN 模型的表現。
逐行詳細解說:
StratifiedKFold(n_splits=5, shuffle=True):把資料切成 5
份,而且每一份裡面的類別比例都要跟原本資料一樣(這叫 Stratified),同時打亂順序。cross_val_score(...):自動幫你做 5 次訓練 + 測試,然後把分數都記下來。scoring="accuracy":用「準確率」來評分。為什麼要用 StratifiedKFold?
如果資料不平衡(例如 90% 是 A 類、10%
是 B 類),用普通 KFold 可能會切出「全部都是 A 類」的驗證集,那樣評估就不準了。
model = models.vgg16(weights='IMAGENET1K_V1')
for param in model.features.parameters():
param.requires_grad = False
model.classifier[6] = nn.Linear(4096, num_classes)
這段程式在做什麼?
把一個已經學會很多東西的 VGG16 模型,改成適合我們自己任務的模型(這叫遷移學習)。
逐行詳細解說:
models.vgg16(weights='IMAGENET1K_V1'):載入一個在 ImageNet 上已經訓練好的超強模型。
model.features.parameters():只選出「卷積層」的參數(這些是負責抓特徵的)。param.requires_grad = False:告訴
PyTorch「這些參數不要再更新了」(凍結),因為我們相信它們已經學得夠好了。model.classifier[6] = nn.Linear(4096, num_classes):把最後一層全連接層換掉,輸出類別數改成我們自己的類別數。
為什麼只凍結
features?
因為卷積層學到的是「通用特徵」(邊緣、紋理、形狀),這些在很多圖片任務上都很通用;最後幾層才是「任務專屬」的分類器。
X_train -= X_train.mean(axis=0)
X_train /= X_train.std(axis=0)
這段程式在做什麼?
把資料「標準化」(Standardization),讓每個特徵的平均值變成 0、標準差變成 1。
逐行詳細解說:
X_train.mean(axis=0):計算「每一個特徵」的平均值(axis=0 代表沿著欄的方向算)。-=:每一個數值都減去自己所屬特徵的平均值 → 現在平均值變成 0 了。X_train.std(axis=0):計算「每一個特徵」的標準差。/=:每一個數值都除以自己所屬特徵的標準差 → 現在標準差變成 1 了。
為什麼要做標準化?
因為很多機器學習模型(尤其是神經網路)對「數值範圍差異很大」的資料很敏感。標準化後,模型訓練會比較穩定、比較快收斂。
model = Sequential([
Input(shape=(784,)),
Dense(128, activation='relu'),
Dense(10, activation='softmax')
])
model.summary()
這段程式在做什麼?
建立一個簡單的 MLP(多層感知機),並用 model.summary() 看參數量。
逐行詳細解說:
Input(shape=(784,)):輸入是 784 維(例如 28x28 的圖片拉平)。Dense(128, activation='relu'):第一層有 128 個神經元。參數量 = (784 + 1) ×
128 = 100,480。Dense(10, activation='softmax'):最後一層有 10 個神經元(對應 10 個類別)。參數量 =
(128 + 1) × 10 = 1,290。考試重點: Dense 層參數 = (輸入維度 + 1) × 輸出維度。+1 是 bias。
共 50 項|強烈建議準備
from transformers import pipeline
classifier = pipeline("sentiment-analysis")
result = classifier("這部電影很棒!")
這段程式在做什麼?
用一行程式碼就能做「情緒分析」,完全不需要自己訓練模型。這是目前最方便的 LLM 使用方式。
逐行詳細解說:
from transformers import pipeline:匯入 Hugging Face
提供的「快速使用工具」。pipeline 是最簡單的入口。pipeline("sentiment-analysis"):建立一個「情緒分析」的工具。它會自動從網路上幫你下載一個已經訓練好的
BERT 模型。classifier("這部電影很棒!"):直接把文字丟進去,它就會告訴你這句話是正面還是負面,還會附上信心分數。為什麼這題很常考? 現在很多公司都在用 Hugging Face,考試想確認你「會不會用現成工具」。
import shap
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)
shap.summary_plot(shap_values, X)
這段程式在做什麼?
解釋「為什麼模型會做出這個預測」,讓黑盒模型變得可以解釋。這是目前最受重視的 XAI(可解釋 AI)技術。
逐行詳細解說:
shap.TreeExplainer(model):建立一個適合「樹模型」的解釋器。explainer.shap_values(X):計算「每一個特徵」對「每一個預測」的貢獻值。shap.summary_plot(...):畫出哪個特徵最重要、影響方向如何。為什麼這題很重要? 現在主管和法規單位都很重視「AI 可解釋性」,SHAP 是目前最主流的工具。
def objective(trial):
lr = trial.suggest_float("lr", 1e-5, 1e-1)
return accuracy
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=100)
這段程式在做什麼?
用「智慧搜尋」的方式,自動幫你找到最好的學習率、層數、batch size 等超參數。
逐行詳細解說:
def objective(trial)::定義一個「試驗函數」。Optuna 會不斷呼叫這個函數來測試不同參數組合。trial.suggest_float("lr", 1e-5, 1e-1):告訴 Optuna「學習率請在這個範圍內幫我選」。
study.optimize(..., n_trials=100):做 100 次試驗,找出最好的那一組。為什麼比 GridSearch 好? GridSearch 是笨笨地全部試一遍,Optuna 會聰明地只試有希望的區域。
class LitModel(pl.LightningModule):
def training_step(self, batch, batch_idx):
...
def configure_optimizers(self):
return torch.optim.Adam(...)
這段程式在做什麼?
用更簡潔、更專業的方式寫 PyTorch 訓練程式碼,讓訓練流程變得乾淨又好維護。
逐行詳細解說(超白話版):
class LitModel(pl.LightningModule)::建立一個繼承自 `LightningModule`
的類別。這是 PyTorch Lightning 的核心,所有訓練邏輯都要寫在這個類別裡。def training_step(self, batch, batch_idx)::def configure_optimizers(self)::為什麼要學 Lightning? 傳統 PyTorch 要自己寫完整的訓練迴圈(for epoch, for batch...),Lightning 可以自動處理這些重複工作,讓程式碼更乾淨、更容易維護。
from transformers import ViTForImageClassification
model = ViTForImageClassification.from_pretrained("google/vit-base-patch16-224")
這段程式在做什麼?
載入一個用「Transformer」架構做的影像分類模型(而不是傳統 CNN)。
詳細解說:
from transformers import ViTForImageClassification:從 Hugging Face
匯入 Vision Transformer 模型。ViTForImageClassification.from_pretrained("google/vit-base-patch16-224"):為什麼這題可能考? 2025 年後 Vision Transformer 在很多影像任務上已經超越傳統 CNN,考試很可能會問你怎麼用 Hugging Face 載入。
from langchain import RetrievalQA
qa = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)
answer = qa.run("公司最新財報內容是什麼?")
這段程式在做什麼?
建立一個「先查公司內部文件、再回答問題」的系統,這就是 RAG(Retrieval-Augmented
Generation)。
詳細解說:
from langchain import RetrievalQA:從 LangChain 匯入 RetrievalQA
這個鏈(Chain)。RetrievalQA.from_chain_type(llm=llm, retriever=retriever):qa.run("公司最新財報內容是什麼?"):為什麼這題可能考? RAG 是目前企業最常用的 LLM 應用方式,幾乎所有公司內部知識問答系統都在用。
import mlflow
with mlflow.start_run():
mlflow.log_param("lr", 0.001)
mlflow.log_metric("accuracy", 0.92)
mlflow.sklearn.log_model(model, "model")
這段程式在做什麼?
把實驗的參數、結果、模型都自動記錄下來,方便之後比較不同實驗。
詳細解說:
import mlflow:匯入 MLflow,這是目前最受歡迎的 MLOps 實驗追蹤工具。with mlflow.start_run()::mlflow.log_param("lr", 0.001):mlflow.log_metric("accuracy", 0.92):mlflow.sklearn.log_model(model, "model"):為什麼這題可能考? 在真實專案中你會跑很多次實驗,MLflow 可以幫你把過程記錄得非常清楚,這是 MLOps 的基礎技能。
import albumentations as A
transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.3)
])
這段程式在做什麼?
對影像做各種隨機變化(水平翻轉、調整亮度),讓模型看到更多樣的資料。
詳細解說:
import albumentations as A:匯入 Albumentations,這是目前最強大、最快的影像資料增強庫。
transform = A.Compose([...]):A.HorizontalFlip(p=0.5):A.RandomBrightnessContrast(p=0.3):為什麼這題可能考? 資料增強是提升影像模型表現最簡單有效的方法,幾乎每個影像專案都會用到。
from prophet import Prophet
model = Prophet()
model.fit(df)
future = model.make_future_dataframe(periods=30)
forecast = model.predict(future)
這段程式在做什麼?
用 Facebook 開源的 Prophet 工具,快速做出未來 30 天的預測。
逐行詳細解說(超白話版):
from prophet import Prophet:匯入 Prophet 這個時間序列預測套件。它是 Facebook
開源的工具,專門用來預測有季節性、趨勢的時間序列資料。model = Prophet():建立一個 Prophet 模型物件。可以加入 holidays、seasonality
等參數來客製化。model.fit(df):.fit() 是 Prophet 的核心訓練方法。future = model.make_future_dataframe(periods=30):自動產生未來 30
個時間點的日期框架。forecast = model.predict(future):.predict() 是預測方法。為什麼這題可能考? 時間序列預測在零售、能源、金融領域非常常見,Prophet 是目前最容易上手且效果不錯的工具。
male_acc = accuracy_score(y_true[male], y_pred[male])
female_acc = accuracy_score(y_true[female], y_pred[female])
這段程式在做什麼?
檢查模型在不同群體(例如男女)之間的表現是否有明顯差異,確保 AI 不會有偏見。
為什麼這題可能考? 2026 年後政府和企業對「AI 倫理」越來越重視。
from peft import LoraConfig, get_peft_model
config = LoraConfig(r=8, lora_alpha=32)
model = get_peft_model(base_model, config)
這段程式在做什麼?
用 LoRA 技術,只訓練極少數參數,就能讓大型語言模型適應你的任務(比全量微調省很多資源)。
詳細解說(超白話版):
from peft import LoraConfig, get_peft_model:從
PEFT(Parameter-Efficient Fine-Tuning)套件匯入 LoRA 相關工具。LoraConfig(r=8, lora_alpha=32):get_peft_model(base_model, config):為什麼這題可能考? 現在微調大模型最流行的方法就是 LoRA,幾乎所有企業都在用。
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run("請幫我寫一封感謝信")
這段程式在做什麼?
用 LangChain 快速建立一個「輸入問題 → LLM 回答」的流程。
詳細解說(超白話版):
from langchain.chains import LLMChain:匯入 LLMChain,這是 LangChain
最基礎的「鏈」。from langchain.prompts import PromptTemplate:匯入
PromptTemplate,用來建立可重複使用的提示模板。chain = LLMChain(llm=llm, prompt=prompt):result = chain.run("請幫我寫一封感謝信"):為什麼這題可能考? LangChain 是目前最熱門的 LLM 應用框架,幾乎所有 LLM 專案都會用到。
import faiss
index = faiss.IndexFlatL2(dimension)
index.add(embeddings)
D, I = index.search(query, k=5)
這段程式在做什麼?
建立一個向量資料庫,快速找出跟問題最相似的文件(這是 RAG 的核心技術)。
詳細解說(超白話版):
import faiss:匯入 FAISS(Facebook AI Similarity
Search),這是目前最快、最受歡迎的向量資料庫。index = faiss.IndexFlatL2(dimension):index.add(embeddings):D, I = index.search(query, k=5):為什麼這題可能考? RAG 系統幾乎都要用到向量資料庫,FAISS 是目前最主流的選擇。
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
results = model("image.jpg")
results[0].plot()
這段程式在做什麼?
用 YOLOv8 快速偵測圖片裡有什麼物體、位置在哪裡。
詳細解說(超白話版):
from ultralytics import YOLO:從 Ultralytics 匯入
YOLO,這是目前最強大、最容易使用的物件偵測框架。model = YOLO("yolov8n.pt"):results = model("image.jpg"):results[0].plot():為什麼這題可能考? YOLO 是目前最受歡迎的即時物件偵測模型,幾乎所有影像專案都會用到。
from diffusers import StableDiffusionPipeline
pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
image = pipe("一隻可愛的貓咪").images[0]
這段程式在做什麼?
用 Stable Diffusion 根據文字描述生成圖片。
詳細解說(超白話版):
from diffusers import StableDiffusionPipeline:從 Hugging Face
Diffusers 套件匯入 Stable Diffusion Pipeline。StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"):image = pipe("一隻可愛的貓咪").images[0]:為什麼這題可能考? 圖像生成是目前最熱門的 AI 應用之一,Stable Diffusion 是開源領域最受歡迎的模型。
import gym
env = gym.make("CartPole-v1")
model = DQN("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=10000)
這段程式在做什麼?
用 DQN(Deep Q-Network)讓 AI 學會玩 CartPole 遊戲。
詳細解說(超白話版):
import gym:匯入 OpenAI Gym,這是強化學習最常用的環境套件。env = gym.make("CartPole-v1"):建立 CartPole 環境(經典的倒立擺遊戲)。model = DQN("MlpPolicy", env, verbose=1):model.learn(total_timesteps=10000):為什麼這題可能考? 強化學習雖然比較進階,但 DQN 是最經典的入門演算法,CartPole 是最常用的測試環境。
from torch_geometric.nn import GCNConv
class GCN(torch.nn.Module):
def __init__(self):
self.conv = GCNConv(in_channels, out_channels)
這段程式在做什麼?
用圖神經網路(GNN)處理「圖結構」資料(例如社群網路、分子結構)。
詳細解說(超白話版):
from torch_geometric.nn import GCNConv:從 PyTorch Geometric
匯入圖卷積層(Graph Convolutional Layer)。class GCN(torch.nn.Module)::建立一個繼承自 PyTorch Module 的圖神經網路類別。self.conv = GCNConv(in_channels, out_channels):為什麼這題可能考? GNN 在推薦系統、藥物發現、社交網路分析領域越來越重要,是 2025-2026 的熱門主題。
import h2o
h2o.init()
aml = H2OAutoML(max_models=20, seed=1)
aml.train(x=features, y=target, training_frame=train)
這段程式在做什麼?
讓 H2O 自動幫你試很多種模型,找出表現最好的那一個。
詳細解說(超白話版):
import h2o:匯入 H2O,這是目前最成熟的開源 AutoML 平台。h2o.init():aml = H2OAutoML(max_models=20, seed=1):aml.train(x=features, y=target, training_frame=train):為什麼這題可能考? AutoML 可以大幅降低建模門檻,現在很多公司都在使用。
from evidently.report import Report
from evidently.metric_preset import DataDriftPreset
report = Report(metrics=[DataDriftPreset()])
report.run(reference_data=ref, current_data=curr)
這段程式在做什麼?
自動檢查模型上線後的資料是否跟訓練時的資料有明顯差異(資料漂移)。
詳細解說(超白話版):
from evidently.report import Report:從 Evidently 匯入 Report
類別,用來產生監控報告。from evidently.metric_preset import DataDriftPreset:匯入
DataDriftPreset,這是預設的「資料漂移」監控套件。report = Report(metrics=[DataDriftPreset()]):report.run(reference_data=ref, current_data=curr):為什麼這題可能考? 模型上線後最怕「資料漂移」,Evidently 是目前最受歡迎的開源監控工具。
prompt = """請一步一步思考:
問題:{question}
範例1:...
範例2:...
答案:"""
response = llm(prompt)
這段程式在做什麼?
用「Few-shot + Chain-of-Thought」技巧,讓 LLM 回答得更準確。
詳細解說(超白話版):
prompt = """請一步一步思考:...:範例1:... 範例2:...:response = llm(prompt):為什麼這題可能考? Prompt Engineering 是目前用 LLM 最重要、最划算的技巧,Few-shot + CoT 是最經典的組合。
prompt = """請一步一步思考:
問題:{question}
步驟1:...
步驟2:...
最終答案:"""
response = llm(prompt)
這段程式在做什麼?
引導 LLM 「一步一步思考」,大幅提升複雜問題的準確率。這是目前最有效的 prompting 技巧之一。
逐行詳細解說:
請一步一步思考:明確要求模型不要直接跳答案,而是展示思考過程。步驟1、步驟2:給模型一個思考框架,讓它有條理地推理。為什麼這題可能考? Chain-of-Thought 是目前最有效的 prompting 技巧之一。
from langchain.agents import initialize_agent, Tool
agent = initialize_agent(tools, llm, agent="zero-shot-react-description")
agent.run("今天台北天氣如何?")
這段程式在做什麼?
建立一個能「思考 + 使用工具」的 AI Agent。
詳細解說(超白話版):
from langchain.agents import initialize_agent, Tool:從 LangChain 匯入
Agent 相關工具。initialize_agent(tools, llm, agent="zero-shot-react-description"):agent.run("今天台北天氣如何?"):為什麼這題可能考? Agent 是 2025-2026 最熱門的 LLM 應用方向,ReAct 是目前最主流的 Agent 架構。
from transformers import LlavaForConditionalGeneration
model = LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf")
response = model.generate(image, prompt)
這段程式在做什麼?
使用 LLaVA 這種「能看圖也會聊天」的多模態模型。
詳細解說(超白話版):
from transformers import LlavaForConditionalGeneration:從 Hugging
Face 匯入 LLaVA(Large Language and Vision Assistant)模型。LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf"):response = model.generate(image, prompt):為什麼這題可能考? 多模態(圖文結合)是未來趨勢,LLaVA 是目前最容易上手的開源多模態模型。
from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config)
這段程式在做什麼?
把大型模型壓縮到 4-bit,讓它可以在普通 GPU 上跑。
詳細解說(超白話版):
from transformers import BitsAndBytesConfig:從 Transformers
匯入量化設定工具。BitsAndBytesConfig(load_in_4bit=True):model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config):為什麼這題可能考? 現在跑大模型最常遇到的問題就是「記憶體不夠」,4-bit 量化是解決這個問題的最有效方法。
student = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased")
teacher = BertForSequenceClassification.from_pretrained("bert-base-uncased")
# 訓練 student 去模仿 teacher 的輸出
這段程式在做什麼?
讓一個小模型(Student)去學習大模型(Teacher)的行為,達到「又小又準」。
詳細解說(超白話版):
student = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased"):載入一個較小的
DistilBERT 模型作為 Student。teacher = BertForSequenceClassification.from_pretrained("bert-base-uncased"):載入一個較大的
BERT 模型作為 Teacher。# 訓練 student 去模仿 teacher 的輸出:為什麼這題可能考? 在實際部署時,我們常需要把大模型壓縮成小模型,Knowledge Distillation 是最經典的方法之一。
from modAL.models import ActiveLearner
learner = ActiveLearner(estimator=model, query_strategy=uncertainty_sampling)
query_idx, query_instance = learner.query(X_pool)
這段程式在做什麼?
讓模型主動挑選「最不確定」的資料給人工標註,減少標註成本。
詳細解說(超白話版):
from modAL.models import ActiveLearner:從 modAL 套件匯入
ActiveLearner,這是 Python 中最受歡迎的 Active Learning 框架。learner = ActiveLearner(estimator=model, query_strategy=uncertainty_sampling):query_idx, query_instance = learner.query(X_pool):為什麼這題可能考? 在真實專案中,標註資料很貴,Active Learning 是最有效的降低成本方法。
prompt = "請產生 10 筆類似以下格式的客戶投訴資料..."
synthetic_data = llm.generate(prompt)
這段程式在做什麼?
用 LLM 產生「假的但很像真的」訓練資料,解決資料不足的問題。
詳細解說(超白話版):
prompt = "請產生 10 筆類似以下格式的客戶投訴資料...":設計一個提示,讓 LLM 產生合成資料。synthetic_data = llm.generate(prompt):為什麼這題可能考? 現在很多公司都在用 LLM 產生合成資料來擴充訓練集,特別是在資料稀缺的領域。
from feast import FeatureStore
store = FeatureStore(repo_path=".")
features = store.get_online_features(feature_refs, entity_rows)
這段程式在做什麼?
用 Feature Store 統一管理「特徵」,讓訓練和線上推論使用一樣的特徵。
詳細解說(超白話版):
from feast import FeatureStore:從 Feast 匯入 FeatureStore,這是目前最受歡迎的開源
Feature Store。store = FeatureStore(repo_path="."):features = store.get_online_features(feature_refs, entity_rows):為什麼這題可能考? Feature Store 是 MLOps 的核心元件之一,能解決「訓練與推論特徵不一致」的問題。
import wandb
wandb.init(project="my-project")
wandb.log({"accuracy": 0.92, "loss": 0.15})
wandb.finish()
這段程式在做什麼?
用 W&B 記錄實驗結果、畫圖、比較不同 run,還可以分享給團隊。
詳細解說(超白話版):
import wandb:匯入 Weights & Biases,這是目前最受歡迎的實驗追蹤平台。wandb.init(project="my-project"):wandb.log({"accuracy": 0.92, "loss": 0.15}):wandb.finish():為什麼這題可能考? W&B 是目前最受歡迎的實驗追蹤工具,幾乎所有機器學習團隊都在用。
import flwr as fl
def client_fn(cid): return FlowerClient(...)
fl.simulation.start_simulation(client_fn=client_fn, num_clients=10)
這段程式在做什麼?
用 Flower 框架實作「聯邦學習」,讓多個裝置在不分享原始資料的情況下共同訓練模型。
詳細解說(超白話版):
import flwr as fl:從 Flower 匯入聯邦學習框架,這是目前最受歡迎的開源聯邦學習平台。def client_fn(cid): return FlowerClient(...):fl.simulation.start_simulation(client_fn=client_fn, num_clients=10):為什麼這題可能考? 隱私保護越來越重要,Federated Learning 是解決「資料不能集中」的最佳方案。
import xgboost as xgb
model = xgb.XGBClassifier()
model.fit(X_train, y_train)
xgb.plot_importance(model)
這段程式在做什麼?
用 XGBoost 訓練模型,並畫出每個特徵的重要性排名。
為什麼這題可能考?
XGBoost 是目前最受歡迎的梯度提升模型之一,考試很可能會問你怎麼看特徵重要性。
from imblearn.over_sampling import SMOTE
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X, y)
這段程式在做什麼?
使用 SMOTE 技術,對少數類別進行過採樣,解決資料不平衡問題。
逐行詳細解說(超白話版):
from imblearn.over_sampling import SMOTE:匯入 SMOTE(Synthetic
Minority Over-sampling Technique)這個處理不平衡資料的經典工具。smote = SMOTE(random_state=42):建立 SMOTE 物件。random_state
確保每次執行結果都一樣,方便重現。X_res, y_res = smote.fit_resample(X, y):.fit_resample() 是 SMOTE 的核心方法。為什麼這題可能考?
真實資料常常不平衡(例如詐欺偵測、疾病診斷),SMOTE
是最經典且有效的處理方法之一。
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
pipeline = Pipeline([
('preprocessor', ColumnTransformer(...)),
('classifier', RandomForestClassifier())
])
這段程式在做什麼?
用 Pipeline 把資料前處理和模型訓練包在一起,避免資料洩漏。
詳細解說(超白話版):
from sklearn.pipeline import Pipeline:從 scikit-learn 匯入
Pipeline,這是避免資料洩漏的最重要工具。from sklearn.compose import ColumnTransformer:匯入
ColumnTransformer,用來對不同欄位套用不同的前處理。pipeline = Pipeline([('preprocessor', ColumnTransformer(...)), ('classifier', RandomForestClassifier())]):為什麼這題可能考? Pipeline 是 scikit-learn 的核心功能,能讓程式碼更乾淨、更安全,是實務上必備的寫法。
from sklearn.model_selection import learning_curve
train_sizes, train_scores, test_scores = learning_curve(
model, X, y, cv=5)
這段程式在做什麼?
畫出學習曲線,觀察模型隨著資料量增加的表現變化。
詳細解說(超白話版):
from sklearn.model_selection import learning_curve:從 scikit-learn
匯入 learning_curve 函數。train_sizes, train_scores, test_scores = learning_curve(model, X, y, cv=5):為什麼這題可能考? 學習曲線能幫助我們判斷模型是過擬合還是欠擬合,是模型診斷的重要工具。
from sklearn.inspection import permutation_importance
result = permutation_importance(model, X_test, y_test)
這段程式在做什麼?
用「排列重要性」方法,隨機打亂每個特徵的值,觀察模型表現下降多少。
詳細解說(超白話版):
from sklearn.inspection import permutation_importance:從
scikit-learn 匯入 permutation_importance 函數。result = permutation_importance(model, X_test, y_test):為什麼這題可能考? Permutation Importance 比傳統 feature importance 更可靠,尤其適合非線性模型,是目前最推薦的特徵重要性方法。
from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
for train_idx, test_idx in tscv.split(X):
X_train, X_test = X[train_idx], X[test_idx]
這段程式在做什麼?
使用 TimeSeriesSplit 進行時間序列交叉驗證,確保訓練集的時間在測試集之前。
詳細解說(超白話版):
from sklearn.model_selection import TimeSeriesSplit:從 scikit-learn
匯入 TimeSeriesSplit,這是時間序列專用的交叉驗證工具。tscv = TimeSeriesSplit(n_splits=5):for train_idx, test_idx in tscv.split(X)::為什麼這題可能考? 時間序列資料不能用普通 KFold,TimeSeriesSplit 是正確的做法,是時間序列建模的必備知識。
from sklearn.ensemble import IsolationForest
model = IsolationForest(contamination=0.1)
model.fit(X)
outliers = model.predict(X)
這段程式在做什麼?
使用 Isolation Forest 偵測異常值(outliers)。
逐行詳細解說(超白話版):
from sklearn.ensemble import IsolationForest:匯入 Isolation Forest,這是
sklearn 中最受歡迎的異常偵測演算法。model = IsolationForest(contamination=0.1):建立模型。contamination=0.1
表示我們預期資料中有 10% 的異常值。model.fit(X):.fit() 會讓模型「學習」正常資料的分佈。outliers = model.predict(X):.predict() 會對每個樣本進行預測。為什麼這題可能考? 異常偵測是機器學習的重要應用,Isolation Forest 是目前最經典且效果穩定的方法之一。
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
kmeans = KMeans(n_clusters=3)
labels = kmeans.fit_predict(X)
score = silhouette_score(X, labels)
這段程式在做什麼?
使用 KMeans 進行分群,並用 Silhouette Score 評估分群效果。
逐行詳細解說(超白話版):
from sklearn.cluster import KMeans:匯入 KMeans,這是最經典的無監督分群演算法。kmeans = KMeans(n_clusters=3):建立模型,告訴它要把資料分成 3 群。labels = kmeans.fit_predict(X):.fit_predict() 會先訓練模型(fit),再直接回傳每個樣本屬於哪一群(predict)。score = silhouette_score(X, labels):為什麼這題可能考? 分群是無監督學習的重要主題,Silhouette Score 是最常用來評估分群好壞的指標。
import umap
reducer = umap.UMAP(n_components=2)
embedding = reducer.fit_transform(X)
這段程式在做什麼?
使用 UMAP 進行降維(比 t-SNE 更快、更適合大資料集)。
詳細解說(超白話版):
import umap:匯入 UMAP(Uniform Manifold Approximation and
Projection),這是目前最受歡迎的降維工具。reducer = umap.UMAP(n_components=2):embedding = reducer.fit_transform(X):為什麼這題可能考? UMAP 是目前最受歡迎的降維工具之一,考試很可能會問你跟 t-SNE 的差別。
from sklearn.calibration import CalibratedClassifierCV
calibrated = CalibratedClassifierCV(model, method='sigmoid', cv=5)
calibrated.fit(X_train, y_train)
這段程式在做什麼?
使用 CalibratedClassifierCV 對分類器進行機率校準,讓預測機率更可靠。
詳細解說(超白話版):
from sklearn.calibration import CalibratedClassifierCV:從
scikit-learn 匯入 CalibratedClassifierCV,這是機率校準的標準工具。calibrated = CalibratedClassifierCV(model, method='sigmoid', cv=5):calibrated.fit(X_train, y_train):為什麼這題可能考? 很多模型的預測機率不準確,校準是實務上很重要的步驟,特別是在需要機率輸出的應用中。
from skopt import BayesSearchCV
opt = BayesSearchCV(model, search_spaces, n_iter=50)
opt.fit(X_train, y_train)
這段程式在做什麼?
使用 Bayesian Optimization 進行智慧超參數搜尋,比 GridSearch 更有效率。
詳細解說(超白話版):
from skopt import BayesSearchCV:從 scikit-optimize 套件匯入 Bayesian
Optimization 工具。opt = BayesSearchCV(model, search_spaces, n_iter=50):opt.fit(X_train, y_train):為什麼這題可能考? Bayesian Optimization 是目前最先進的超參數優化方法之一,比 GridSearch 和 Random Search 都更有效率。
from sklearn.multioutput import MultiOutputRegressor
model = MultiOutputRegressor(RandomForestRegressor())
model.fit(X_train, y_train)
這段程式在做什麼?
使用 MultiOutputRegressor 同時預測多個目標變數。
詳細解說(超白話版):
from sklearn.multioutput import MultiOutputRegressor:從 scikit-learn
匯入 MultiOutputRegressor,這是處理多輸出問題的標準工具。model = MultiOutputRegressor(RandomForestRegressor()):model.fit(X_train, y_train):為什麼這題可能考? 多輸出預測是實務上常見的需求(例如同時預測多個 KPI),MultiOutputRegressor 是最簡單的解決方案。
from sklearn.inspection import partial_dependence
pdp = partial_dependence(model, X, features=[0])
這段程式在做什麼?
畫出 Partial Dependence Plot,觀察單一特徵對預測結果的影響。
詳細解說(超白話版):
from sklearn.inspection import partial_dependence:從 scikit-learn 匯入
partial_dependence 函數,這是模型可解釋性的重要工具。pdp = partial_dependence(model, X, features=[0]):為什麼這題可能考? PDP 是模型可解釋性的重要工具,能幫助我們理解模型如何利用每個特徵。
from lime.lime_tabular import LimeTabularExplainer
explainer = LimeTabularExplainer(X_train)
exp = explainer.explain_instance(X_test[0], model.predict_proba)
這段程式在做什麼?
使用 LIME 解釋單一預測結果,適合解釋黑盒模型。
詳細解說(超白話版):
from lime.lime_tabular import LimeTabularExplainer:從 LIME
套件匯入表格資料解釋器。explainer = LimeTabularExplainer(X_train):exp = explainer.explain_instance(X_test[0], model.predict_proba):為什麼這題可能考? LIME 是與 SHAP 並列的模型解釋工具,特別適合解釋單一預測結果。
from sklearn.metrics import make_scorer
custom_scorer = make_scorer(f1_score, average='weighted')
GridSearchCV(model, param_grid, scoring=custom_scorer)
這段程式在做什麼?
使用 make_scorer 建立自訂評分函數(例如加權 F1-score)。
詳細解說(超白話版):
from sklearn.metrics import make_scorer:從 scikit-learn 匯入
make_scorer,這是建立自訂評分函數的標準工具。custom_scorer = make_scorer(f1_score, average='weighted'):GridSearchCV(model, param_grid, scoring=custom_scorer):為什麼這題可能考? 實務上常需要使用自訂評分指標(例如加權 F1、特定業務指標),make_scorer 是最標準的做法。
from sklearn.feature_selection import SelectKBest, RFE
selector = SelectKBest(k=10)
X_new = selector.fit_transform(X, y)
這段程式在做什麼?
使用 SelectKBest 或 RFE 進行特徵選擇,保留最重要的特徵。
詳細解說(超白話版):
from sklearn.feature_selection import SelectKBest, RFE:從
scikit-learn 匯入特徵選擇工具。selector = SelectKBest(k=10):X_new = selector.fit_transform(X, y):為什麼這題可能考? 特徵選擇是機器學習流程中非常重要的步驟,能提升模型表現並減少過擬合。
from sklearn.ensemble import VotingClassifier
ensemble = VotingClassifier(
estimators=[('rf', rf), ('xgb', xgb), ('lgbm', lgbm)],
voting='soft')
這段程式在做什麼?
使用 VotingClassifier 結合多個模型的預測結果。
詳細解說(超白話版):
from sklearn.ensemble import VotingClassifier:從 scikit-learn 匯入
VotingClassifier,這是最簡單的 Ensemble 方法。ensemble = VotingClassifier(estimators=[('rf', rf), ('xgb', xgb), ('lgbm', lgbm)], voting='soft'):為什麼這題可能考? Ensemble 方法是提升模型表現的最有效方式之一,Voting 是最容易實作的 Ensemble 技術。
from sklearn.ensemble import StackingClassifier
stack = StackingClassifier(
estimators=[('rf', rf), ('xgb', xgb)],
final_estimator=LogisticRegression())
這段程式在做什麼?
使用 StackingClassifier 讓多個模型的預測結果作為最終模型的輸入。
詳細解說(超白話版):
from sklearn.ensemble import StackingClassifier:從 scikit-learn 匯入
StackingClassifier,這是目前最強大的 Ensemble 方法。stack = StackingClassifier(estimators=[('rf', rf), ('xgb', xgb)], final_estimator=LogisticRegression()):為什麼這題可能考? Stacking 是目前最強大的 Ensemble 方法之一,考試很可能會問你跟 Voting 的差別。
model = xgb.XGBClassifier(
n_estimators=1000,
early_stopping_rounds=50)
model.fit(X_train, y_train,
eval_set=[(X_val, y_val)])
這段程式在做什麼?
使用 Early Stopping 讓 XGBoost 在驗證集表現不再改善時自動停止訓練。
逐行詳細解說(超白話版):
model = xgb.XGBClassifier(n_estimators=1000, early_stopping_rounds=50):model.fit(X_train, y_train, eval_set=[(X_val, y_val)]):.fit() 開始訓練。為什麼這題可能考? Early Stopping 是防止過擬合、節省訓練時間的重要技巧,幾乎所有梯度提升模型(XGBoost、LightGBM、CatBoost)都支援。
import joblib
joblib.dump(model, 'model.pkl')
loaded_model = joblib.load('model.pkl')
這段程式在做什麼?
使用 joblib 把訓練好的模型「序列化」儲存到硬碟,之後可以隨時載入使用。這是模型上線部署的必備技能。
逐行詳細解說(超白話版):
import joblib:匯入 joblib 這個套件。它是 Python 中專門用來「儲存和載入大型 Python
物件」的工具,比標準的 pickle 更快、更省記憶體,尤其適合機器學習模型。joblib.dump(model, 'model.pkl'):dump() 是 joblib 的核心方法,功能是把「任何 Python 物件」(這裡是
model)轉成二進位格式,儲存到指定的檔案路徑('model.pkl')。loaded_model = joblib.load('model.pkl'):load() 是對應的還原方法,把硬碟上的 .pkl 檔案讀回來,還原成原本的模型物件。為什麼要用 joblib 而不是 pickle?
• joblib 對大型 numpy 陣列(模型權重)有特別優化,速度更快、檔案更小。
• 支援壓縮(compress=0~9),預設就會壓縮。
• 更適合機器學習模型的儲存與載入。
為什麼這題可能考? 模型訓練完後一定要會「儲存」和「載入」,這是模型上線部署的第一步,考試很愛考實務技能。
這份筆記已經盡量把每一行都講得很白話了。
建議你:
1. 先看「逐行解說」 → 2. 自己打一次程式碼 → 3.
再回來看解說
這樣效果最好!
從 Python 基礎到 iPAS 程式題實戰,一路都有可以照著打的範例。完整版還有: