diff --git a/acs111125-ex1/ex1.ipynb b/acs111125-ex1/ex1.ipynb
new file mode 100644
index 0000000..3fe9407
--- /dev/null
+++ b/acs111125-ex1/ex1.ipynb
@@ -0,0 +1,226 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0a8b1f63",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\yianm\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading from https://www.kaggle.com/api/v1/datasets/download/mlg-ulb/creditcardfraud?dataset_version_number=3...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 66.0M/66.0M [00:25<00:00, 2.76MB/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Extracting files...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ 資料載入完成，總筆數： 284807\n",
+      "\n",
+      "📊 Random Forest 評估結果\n",
+      "========================================\n",
+      "Accuracy : 0.9994499256814484\n",
+      "Precision: 0.9719626168224299\n",
+      "Recall   : 0.7027027027027027\n",
+      "F1 Score : 0.8156862745098039\n",
+      "\n",
+      "Classification Report:\n",
+      "               precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00     85295\n",
+      "           1       0.97      0.70      0.82       148\n",
+      "\n",
+      "    accuracy                           1.00     85443\n",
+      "   macro avg       0.99      0.85      0.91     85443\n",
+      "weighted avg       1.00      1.00      1.00     85443\n",
+      "\n",
+      "🌀 KMeans 最佳群數 k = 2\n",
+      "\n",
+      "📊 KMeans (Unsupervised) 評估結果\n",
+      "========================================\n",
+      "Accuracy : 0.9982678510820079\n",
+      "Precision: 0.0\n",
+      "Recall   : 0.0\n",
+      "F1 Score : 0.0\n",
+      "\n",
+      "Classification Report:\n",
+      "               precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00     85295\n",
+      "           1       0.00      0.00      0.00       148\n",
+      "\n",
+      "    accuracy                           1.00     85443\n",
+      "   macro avg       0.50      0.50      0.50     85443\n",
+      "weighted avg       1.00      1.00      1.00     85443\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\yianm\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+      "c:\\Users\\yianm\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+      "c:\\Users\\yianm\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
+      "c:\\Users\\yianm\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
+      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ex1.ipynb - 挑戰一 練習作業框架\n",
+    "# Author: [請寫上你的名字或學號]\n",
+    "\n",
+    "# ====== 🔹 套件匯入區 ======\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.metrics import classification_report, accuracy_score, precision_score, recall_score, f1_score\n",
+    "from sklearn.cluster import KMeans\n",
+    "from sklearn.metrics import silhouette_score\n",
+    "\n",
+    "# ====== 🔹 資料載入與前處理 ======\n",
+    "# 如果 kagglehub 有裝就用這個；如果你下載 csv，改成讀本地檔\n",
+    "try:\n",
+    "    import kagglehub\n",
+    "    path = kagglehub.dataset_download(\"mlg-ulb/creditcardfraud\")\n",
+    "    data = pd.read_csv(f\"{path}/creditcard.csv\")\n",
+    "except:\n",
+    "    print(\"使用本地資料路徑\")\n",
+    "    data = pd.read_csv(\"creditcard.csv\")  # <-- 下載檔案後請放這裡\n",
+    "\n",
+    "data['Class'] = data['Class'].astype(int)\n",
+    "data = data.drop(['Time'], axis=1)\n",
+    "data['Amount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))\n",
+    "\n",
+    "print(\"✅ 資料載入完成，總筆數：\", len(data))\n",
+    "\n",
+    "# ====== 🔹 評估函式 ======\n",
+    "def evaluation(y_true, y_pred, model_name=\"Model\"):\n",
+    "    print(f\"\\n📊 {model_name} 評估結果\")\n",
+    "    print(\"=\"*40)\n",
+    "    print(\"Accuracy :\", accuracy_score(y_true, y_pred))\n",
+    "    print(\"Precision:\", precision_score(y_true, y_pred))\n",
+    "    print(\"Recall   :\", recall_score(y_true, y_pred))\n",
+    "    print(\"F1 Score :\", f1_score(y_true, y_pred))\n",
+    "    print(\"\\nClassification Report:\\n\", classification_report(y_true, y_pred))\n",
+    "\n",
+    "# ====== 🔹 Random Forest：有監督式學習 ======\n",
+    "X = np.asarray(data.drop(columns=['Class']))\n",
+    "Y = np.asarray(data['Class'])\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, Y, test_size=0.3, random_state=42, stratify=Y\n",
+    ")\n",
+    "\n",
+    "rf_model = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')\n",
+    "rf_model.fit(X_train, y_train)\n",
+    "y_pred_rf = rf_model.predict(X_test)\n",
+    "\n",
+    "evaluation(y_test, y_pred_rf, \"Random Forest\")\n",
+    "\n",
+    "# ====== 🔹 KMeans：非監督式學習 ======\n",
+    "scaler = StandardScaler()\n",
+    "X_scaled = scaler.fit_transform(X)\n",
+    "\n",
+    "X_train_unsupervised = X_scaled[Y == 0][:1000]  # 取前 1000 筆非詐欺樣本\n",
+    "\n",
+    "# 選擇最佳 k 值\n",
+    "scores = []\n",
+    "for k in range(2, 5):\n",
+    "    kmeans = KMeans(n_clusters=k, random_state=42)\n",
+    "    kmeans.fit(X_train_unsupervised)\n",
+    "    score = silhouette_score(X_train_unsupervised, kmeans.labels_)\n",
+    "    scores.append(score)\n",
+    "\n",
+    "optimal_k = np.argmax(scores) + 2\n",
+    "print(\"🌀 KMeans 最佳群數 k =\", optimal_k)\n",
+    "\n",
+    "# 用最佳 k 訓練模型\n",
+    "kmeans = KMeans(n_clusters=optimal_k, random_state=42)\n",
+    "kmeans.fit(X_train_unsupervised)\n",
+    "X_test_scaled = scaler.transform(X_test)\n",
+    "y_pred_kmeans = kmeans.predict(X_test_scaled)\n",
+    "\n",
+    "# 對齊群集標籤\n",
+    "def align_labels(y_true, y_pred, n_clusters):\n",
+    "    labels = np.zeros_like(y_pred)\n",
+    "    for i in range(n_clusters):\n",
+    "        mask = (y_pred == i)\n",
+    "        if np.sum(mask) > 0:\n",
+    "            labels[mask] = np.bincount(y_true[mask]).argmax()\n",
+    "        else:\n",
+    "            labels[mask] = 0\n",
+    "    return labels\n",
+    "\n",
+    "y_pred_aligned = align_labels(y_test, y_pred_kmeans, optimal_k)\n",
+    "evaluation(y_test, y_pred_aligned, \"KMeans (Unsupervised)\")\n",
+    "\n",
+    "# ====== 🔹 TODO：你可以在這裡進行改進 ======\n",
+    "# 例如：\n",
+    "# - 改用其他分類器（如 XGBoost、SVM）\n",
+    "# - 嘗試調整 Random Forest 參數\n",
+    "# - SMOTE 資料平衡處理\n",
+    "# - 比較更多非監督模型\n",
+    "# - 把結果寫入 ex1.md 檔案\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/acs111125-ex1/ex1.md b/acs111125-ex1/ex1.md
new file mode 100644
index 0000000..d4571ee
--- /dev/null
+++ b/acs111125-ex1/ex1.md
@@ -0,0 +1,116 @@
+
+# 💼 ex1.md - 挑戰一 練習作業報告
+> 📌 課程練習目標：使用監督與非監督式方法進行詐欺交易偵測
+
+---
+
+## 👤 基本資訊
+- 作者：[資三甲周庭嫻ACS111125]
+- 作業名稱：挑戰一 - 信用卡詐欺資料分析
+
+---
+
+## 🎯 目標說明
+
+本次練習目的為透過機器學習方法，對信用卡詐欺偵測資料集進行處理與模型建立，並嘗試比較 **監督式學習（Random Forest）** 以及 **非監督式學習（KMeans）** 的偵測效果。
+
+---
+
+## 📦 使用資料集
+
+- 資料來源：[Kaggle - Credit Card Fraud Detection](https://www.kaggle.com/datasets/mlg-ulb/creditcardfraud)
+- 資料筆數：284,807 筆
+- 欄位數量：30 個欄位（經 PCA 處理）
+- 資料不平衡比例：
+  - 正常交易（Class=0）：99.8%
+  - 詐欺交易（Class=1）：0.2%
+
+---
+
+## 🧹 資料前處理
+
+1. 移除 `Time` 欄位
+2. 使用 `StandardScaler` 對 `Amount` 欄位進行標準化
+3. 分離特徵 X 與標籤 Y
+4. 使用 `train_test_split` 切分資料為 70% 訓練 / 30% 測試（保留類別比例）
+
+---
+
+## ✅ 模型一：Random Forest（有監督式學習）
+
+- 模型參數：
+  - `n_estimators=100`
+  - `class_weight='balanced'`
+- 訓練資料：70%
+- 測試資料：30%
+
+### 📊 評估結果
+
+```
+Accuracy : 0.9994
+Precision: 0.9719
+Recall   : 0.7027
+F1 Score : 0.8159
+```
+
+| 類別 | precision | recall | f1-score | support |
+|------|-----------|--------|----------|---------|
+| 0    | 1.00      | 1.00   | 1.00     | 85295   |
+| 1    | 0.97      | 0.70   | 0.82     | 148     |
+
+> ✅ 模型在極度不平衡資料下仍能達到高 precision 與合理 recall，透過 `class_weight='balanced'` 可提升少數類別偵測效果。
+
+---
+
+## ✅ 模型二：KMeans（非監督式學習）
+
+- 使用非詐欺樣本（Class = 0）前 1000 筆進行群聚學習
+- 探索最佳群數 k ∈ {2, 3, 4}
+- 使用 silhouette score 選出最佳群數
+- 最佳 k = **2**
+
+### 📊 評估結果
+
+```
+Accuracy : 0.9983
+Precision: 0.00
+Recall   : 0.00
+F1 Score : 0.00
+```
+
+| 指標類型     | 值   |
+|--------------|------|
+| macro avg    | 0.50 |
+| weighted avg | 1.00 |
+
+> ⚠️ 雖然整體 accuracy 看似很高，但實際未能有效辨識詐欺樣本，precision 與 recall 為 0，表示所有詐欺樣本皆被錯判。
+
+---
+
+## 📊 模型比較與總結
+
+| 模型        | Accuracy | Precision | Recall | F1 Score |
+|-------------|----------|-----------|--------|----------|
+| RandomForest| 0.9994   | 0.9719    | 0.7027 | 0.8159   |
+| KMeans      | 0.9983   | 0.0000    | 0.0000 | 0.0000   |
+
+> ✅ **Random Forest** 在處理不平衡資料中表現穩定，能有效抓出詐欺樣本。  
+> ⚠️ **KMeans** 雖然是無監督方法，accuracy 偏高主要是因為資料極度不平衡，實際上未成功辨識任何詐欺交易。
+
+---
+
+## 🔁 建議改進方向（TODO）
+
+- 嘗試 **XGBoost**，進一步提升 Recall 與 F1 分數
+- 使用 **SMOTE** 進行少數類別過採樣
+- 嘗試調整門檻值（如 `predict_proba >= 0.3~0.5`）
+- 加入更多非監督模型：如 Isolation Forest、DBSCAN
+- 將模型評估結果可視化（ROC 曲線、PR 曲線、混淆矩陣）
+
+---
+
+## ✅ 結論
+
+本次實驗展示監督與非監督學習方法在信用卡詐欺偵測中的應用，Random Forest 能有效從極度不平衡的資料中辨識詐欺行為，而 KMeans 雖為無監督方法，在未經調整的情況下效果有限。透過後續進階技術（如 SMOTE 或 Boosting），可望進一步提升偵測表現。
+
+---
diff --git a/acs111125-ex2/ex2.ipynb b/acs111125-ex2/ex2.ipynb
new file mode 100644
index 0000000..c17dd94
--- /dev/null
+++ b/acs111125-ex2/ex2.ipynb
@@ -0,0 +1,332 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "ce0293c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🧪 進行多重非監督特徵工程...\n",
+      "🛡️ 生成Isolation Forest特徵...\n",
+      "🔍 使用KMeans建立群集特徵...\n",
+      "🛡️ 使用One-Class SVM產生異常分數...\n",
+      "🌲 使用隨機森林產生異常分數...\n",
+      "\n",
+      "🎯 訓練XGBoost（scale_pos_weight = 578.55）...\n",
+      "\n",
+      "📊 XGBoost模型（默認門檻0.5） 評估結果\n",
+      "==================================================\n",
+      "Accuracy   : 0.9994733330992591\n",
+      "Precision  : 0.9724770642201835\n",
+      "Recall     : 0.7162162162162162\n",
+      "F1 Score   : 0.8249027237354085\n",
+      "\n",
+      "Classification Report:\n",
+      "               precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00     85295\n",
+      "           1       0.97      0.72      0.82       148\n",
+      "\n",
+      "    accuracy                           1.00     85443\n",
+      "   macro avg       0.99      0.86      0.91     85443\n",
+      "weighted avg       1.00      1.00      1.00     85443\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x500 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "📊 XGBoost模型（最佳門檻0.0001） 評估結果\n",
+      "==================================================\n",
+      "Accuracy   : 0.9995318516437859\n",
+      "Precision  : 0.95\n",
+      "Recall     : 0.7702702702702703\n",
+      "F1 Score   : 0.8507462686567164\n",
+      "\n",
+      "Classification Report:\n",
+      "               precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00     85295\n",
+      "           1       0.95      0.77      0.85       148\n",
+      "\n",
+      "    accuracy                           1.00     85443\n",
+      "   macro avg       0.97      0.89      0.93     85443\n",
+      "weighted avg       1.00      1.00      1.00     85443\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x500 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔍 高精度模式（Precision ≥ 95%）：門檻 = 0.0001\n",
+      "\n",
+      "📊 高精度模式 評估結果\n",
+      "==================================================\n",
+      "Accuracy   : 0.9995318516437859\n",
+      "Precision  : 0.95\n",
+      "Recall     : 0.7702702702702703\n",
+      "F1 Score   : 0.8507462686567164\n",
+      "\n",
+      "Classification Report:\n",
+      "               precision    recall  f1-score   support\n",
+      "\n",
+      "           0       1.00      1.00      1.00     85295\n",
+      "           1       0.95      0.77      0.85       148\n",
+      "\n",
+      "    accuracy                           1.00     85443\n",
+      "   macro avg       0.97      0.89      0.93     85443\n",
+      "weighted avg       1.00      1.00      1.00     85443\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 600x500 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "✅ 模型訓練與評估完成！\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ex2.ipynb - 信用卡詐欺檢測（修正版）\n",
+    "# Author: [請寫上你的名字或學號]\n",
+    "\n",
+    "# ====== 🔹 套件匯入區 ======\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler, RobustScaler\n",
+    "from sklearn.metrics import classification_report, accuracy_score, precision_score, recall_score, f1_score, ConfusionMatrixDisplay\n",
+    "from sklearn.ensemble import IsolationForest, RandomForestClassifier\n",
+    "from sklearn.cluster import KMeans\n",
+    "from sklearn.svm import OneClassSVM\n",
+    "from xgboost import XGBClassifier\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# ====== 🔹 資料載入與前處理 ======\n",
+    "try:\n",
+    "    import kagglehub\n",
+    "    path = kagglehub.dataset_download(\"mlg-ulb/creditcardfraud\")\n",
+    "    data = pd.read_csv(f\"{path}/creditcard.csv\")\n",
+    "except:\n",
+    "    print(\"使用本地資料路徑\")\n",
+    "    data = pd.read_csv(\"creditcard.csv\")\n",
+    "\n",
+    "# 處理欄位與標準化\n",
+    "data['Class'] = data['Class'].astype(int)\n",
+    "data = data.drop(['Time'], axis=1)\n",
+    "\n",
+    "# 使用RobustScaler對Amount進行標準化\n",
+    "scaler = RobustScaler()\n",
+    "data['Amount'] = scaler.fit_transform(data['Amount'].values.reshape(-1, 1))\n",
+    "\n",
+    "# ====== 🔹 特徵切分（先分割再生成特徵） ======\n",
+    "X = data.drop(columns=['Class'])\n",
+    "y = data['Class'].values\n",
+    "\n",
+    "# 先分割數據集\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y, test_size=0.3, random_state=42, stratify=y\n",
+    ")\n",
+    "\n",
+    "# ====== 🔹 多重非監督特徵工程（修正後） ======\n",
+    "print(\"\\n🧪 進行多重非監督特徵工程...\")\n",
+    "\n",
+    "# 標準化特徵用於聚類\n",
+    "scaler_cluster = StandardScaler()\n",
+    "X_train_scaled = scaler_cluster.fit_transform(X_train)\n",
+    "X_test_scaled = scaler_cluster.transform(X_test)\n",
+    "\n",
+    "# 1. Isolation Forest 特徵（僅在訓練集上擬合）\n",
+    "print(\"🛡️ 生成Isolation Forest特徵...\")\n",
+    "iso_model = IsolationForest(n_estimators=150, contamination=0.0017, random_state=42)\n",
+    "iso_model.fit(X_train_scaled[y_train == 0])  # 僅使用正常樣本訓練\n",
+    "\n",
+    "# 為訓練集和測試集生成特徵\n",
+    "X_train['IsoOutlier'] = (iso_model.predict(X_train_scaled) == -1).astype(int)\n",
+    "X_train['AnomalyScore'] = -iso_model.decision_function(X_train_scaled)\n",
+    "X_test['IsoOutlier'] = (iso_model.predict(X_test_scaled) == -1).astype(int)\n",
+    "X_test['AnomalyScore'] = -iso_model.decision_function(X_test_scaled)\n",
+    "\n",
+    "# 2. KMeans 群集特徵\n",
+    "print(\"🔍 使用KMeans建立群集特徵...\")\n",
+    "kmeans_model = KMeans(n_clusters=5, random_state=42)\n",
+    "kmeans_model.fit(X_train_scaled[y_train == 0])  # 僅使用正常樣本訓練\n",
+    "\n",
+    "X_train['KMeansCluster'] = kmeans_model.predict(X_train_scaled)\n",
+    "X_test['KMeansCluster'] = kmeans_model.predict(X_test_scaled)\n",
+    "\n",
+    "# 3. One-Class SVM 異常分數（修正後的版本）\n",
+    "print(\"🛡️ 使用One-Class SVM產生異常分數...\")\n",
+    "ocsvm = OneClassSVM(nu=0.01, kernel='rbf', gamma='scale')\n",
+    "ocsvm.fit(X_train_scaled[y_train == 0])  # 僅使用正常樣本訓練\n",
+    "\n",
+    "X_train['OCSVM_Score'] = -ocsvm.decision_function(X_train_scaled)\n",
+    "X_test['OCSVM_Score'] = -ocsvm.decision_function(X_test_scaled)\n",
+    "\n",
+    "# 4. 隨機森林異常分數\n",
+    "print(\"🌲 使用隨機森林產生異常分數...\")\n",
+    "rf = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')\n",
+    "rf.fit(X_train, y_train)\n",
+    "\n",
+    "X_train['RF_Anomaly'] = rf.predict_proba(X_train)[:, 1]\n",
+    "X_test['RF_Anomaly'] = rf.predict_proba(X_test)[:, 1]\n",
+    "\n",
+    "# ====== 🔹 訓練XGBoost分類器 ======\n",
+    "pos_weight = (y_train == 0).sum() / (y_train == 1).sum()\n",
+    "print(f\"\\n🎯 訓練XGBoost（scale_pos_weight = {pos_weight:.2f}）...\")\n",
+    "\n",
+    "xgb_model = XGBClassifier(\n",
+    "    n_estimators=500,\n",
+    "    max_depth=8,\n",
+    "    learning_rate=0.05,\n",
+    "    subsample=0.9,\n",
+    "    colsample_bytree=0.9,\n",
+    "    scale_pos_weight=pos_weight,\n",
+    "    random_state=42,\n",
+    "    use_label_encoder=False,\n",
+    "    eval_metric='logloss'\n",
+    ")\n",
+    "\n",
+    "xgb_model.fit(X_train, y_train)\n",
+    "\n",
+    "# ====== 🔹 模型評估 ======\n",
+    "def enhanced_evaluation(y_true, y_pred, y_prob=None, model_name=\"模型\"):\n",
+    "    print(f\"\\n📊 {model_name} 評估結果\")\n",
+    "    print(\"=\"*50)\n",
+    "    print(\"Accuracy   :\", accuracy_score(y_true, y_pred))\n",
+    "    print(\"Precision  :\", precision_score(y_true, y_pred))\n",
+    "    print(\"Recall     :\", recall_score(y_true, y_pred))\n",
+    "    print(\"F1 Score   :\", f1_score(y_true, y_pred))\n",
+    "    print(\"\\nClassification Report:\\n\", classification_report(y_true, y_pred))\n",
+    "    \n",
+    "    # 繪製混淆矩陣\n",
+    "    plt.figure(figsize=(6,5))\n",
+    "    ConfusionMatrixDisplay.from_predictions(y_true, y_pred, \n",
+    "                                          display_labels=['正常', '詐欺'],\n",
+    "                                          cmap='Blues')\n",
+    "    plt.title(f'{model_name} 混淆矩陣')\n",
+    "    plt.show()\n",
+    "\n",
+    "# 預測測試集\n",
+    "y_prob = xgb_model.predict_proba(X_test)[:, 1]\n",
+    "y_pred = (y_prob >= 0.5).astype(int)  # 默認0.5門檻\n",
+    "\n",
+    "enhanced_evaluation(y_test, y_pred, y_prob, \"XGBoost模型（默認門檻0.5）\")\n",
+    "\n",
+    "# ====== 🔹 門檻優化 ======\n",
+    "from sklearn.metrics import precision_recall_curve\n",
+    "\n",
+    "# 計算PR曲線\n",
+    "precision, recall, thresholds = precision_recall_curve(y_test, y_prob)\n",
+    "\n",
+    "# 找出最佳F1分數的門檻值\n",
+    "f1_scores = 2 * (precision * recall) / (precision + recall + 1e-8)\n",
+    "best_idx = np.argmax(f1_scores)\n",
+    "best_thresh = thresholds[best_idx]\n",
+    "y_pred_best = (y_prob >= best_thresh).astype(int)\n",
+    "\n",
+    "enhanced_evaluation(y_test, y_pred_best, y_prob, f\"XGBoost模型（最佳門檻{best_thresh:.4f}）\")\n",
+    "\n",
+    "# ====== 🔹 高精度模式 ======\n",
+    "# 找出Precision >= 0.95的最小門檻\n",
+    "high_prec_idx = np.where(precision >= 0.95)[0][0]\n",
+    "high_prec_thresh = thresholds[high_prec_idx]\n",
+    "y_pred_high_prec = (y_prob >= high_prec_thresh).astype(int)\n",
+    "\n",
+    "print(f\"\\n🔍 高精度模式（Precision ≥ 95%）：門檻 = {high_prec_thresh:.4f}\")\n",
+    "enhanced_evaluation(y_test, y_pred_high_prec, y_prob, \"高精度模式\")\n",
+    "\n",
+    "print(\"\\n✅ 模型訓練與評估完成！\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/acs111125-ex2/ex2.md b/acs111125-ex2/ex2.md
new file mode 100644
index 0000000..c8880c7
--- /dev/null
+++ b/acs111125-ex2/ex2.md
@@ -0,0 +1,99 @@
+
+# 💼 ex2.md - 挑戰二：融合監督與非監督學習報告（強化版 + 精準結果）
+> 📌 本報告說明如何融合多種異常偵測方法以提升信用卡詐欺偵測模型的精準度與整體效能。
+
+---
+
+## 👤 基本資訊
+- 作者：[周庭嫻ACS111125]
+- 作業名稱：挑戰二 - 信用卡詐欺融合模型
+
+---
+
+## 🎯 任務目標
+
+本次挑戰目的為整合非監督式異常偵測模型與監督式分類器，提升在極端不平衡資料中偵測詐欺交易的能力，尤其著重於 Precision 的提升。
+
+---
+
+## 📦 使用資料集
+
+- 資料來源：[Kaggle - Credit Card Fraud Detection](https://www.kaggle.com/datasets/mlg-ulb/creditcardfraud)
+- 總筆數：284,807 筆
+- 欄位數量：30（含 Amount 欄，經標準化處理）
+- 詐欺比例：約 0.172%（極度不平衡）
+
+---
+
+## 🧪 特徵工程與模型設計
+
+本次實作融合多種非監督式異常偵測技術來擴增特徵空間，提供 XGBoost 模型更豐富的資訊來源。
+
+### 非監督特徵工程：
+
+| 方法              | 說明                                       |
+|-------------------|--------------------------------------------|
+| Isolation Forest  | 產出 IsoOutlier + AnomalyScore 兩種特徵     |
+| KMeans Clustering | 加入群集編號作為特徵                        |
+| One-Class SVM     | 產出 OCSVM_Score（異常距離）               |
+| Random Forest     | RF_Anomaly 為其對詐欺的預測分數             |
+
+### 監督分類器：
+
+- 主模型：XGBoost
+- 重要參數：
+  - `scale_pos_weight = 578.55`（自動計算詐欺樣本不平衡比）
+  - `n_estimators = 500`
+  - `max_depth = 8`
+  - `learning_rate = 0.05`
+
+---
+
+## ⚙️ 評估流程與門檻策略
+
+- 使用預設門檻 0.5 先行評估
+- 接著使用 `precision_recall_curve` 掃描所有門檻
+- 依據 F1-score 最佳值進行門檻優化
+- 額外提供高精度模式（Precision ≥ 0.95）
+
+---
+
+## 📊 模型評估結果（門檻 0.5）
+
+```
+Accuracy   : 0.9995
+Precision  : 0.9725
+Recall     : 0.7162
+F1 Score   : 0.8249
+```
+
+| 類別 | precision | recall | f1-score | support |
+|------|-----------|--------|----------|---------|
+| 0    | 1.00      | 1.00   | 1.00     | 85295   |
+| 1    | 0.972     | 0.716  | 0.825    | 148     |
+
+> ✅ 該模型在極度不平衡下仍保有 0.972 的 Precision 與良好的 F1 Score，顯示融合特徵有效提升分類品質。
+
+---
+
+## 🧠 模型選擇建議
+
+- 若 **精準率（Precision）為優先考量**（例如降低誤報），目前模型已能達成良好效果（Precision > 0.97）
+- 若 **召回率（Recall）也很重要**，可透過門檻調整或採用最佳 F1 點進行微調
+
+---
+
+## 📂 檔案結構
+
+```
+<學號>_ex2/
+├── ex2.ipynb         # 主程式碼（融合模型）
+├── ex2.md            # 說明文件（本檔案）
+```
+
+---
+
+## ✅ 結論
+
+本挑戰成功透過多種非監督特徵結合 XGBoost 模型，於詐欺偵測任務中取得高 Precision 的穩健表現，並保持良好的 Recall 與整體準確率，適合應用於實際詐欺防制系統中。
+
diff --git "a/\343\200\214CNN_Assignment_ipynb\343\200\215\347\232\204\345\211\257\346\234\254.ipynb" "b/\343\200\214CNN_Assignment_ipynb\343\200\215\347\232\204\345\211\257\346\234\254.ipynb"
new file mode 100644
index 0000000..464035a
--- /dev/null
+++ "b/\343\200\214CNN_Assignment_ipynb\343\200\215\347\232\204\345\211\257\346\234\254.ipynb"
@@ -0,0 +1,499 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/Radcliffe0731/NTCU-Machine-Learning/blob/main/%E3%80%8CCNN_Assignment_ipynb%E3%80%8D%E7%9A%84%E5%89%AF%E6%9C%AC.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qt8xvGTcxYIJ"
+      },
+      "outputs": [],
+      "source": [
+        "# CNN Classroom Exercise: Image Classification with CIFAR-10\n",
+        "# Objective: Practice building, training, and evaluating a CNN using TensorFlow/Keras\n",
+        "# Environment: Google Colab with GPU\n",
+        "# Dataset: CIFAR-10 (10 classes of 32x32 color images)\n",
+        "\n",
+        "# Step 1: Import Libraries\n",
+        "import tensorflow as tf\n",
+        "from tensorflow.keras import datasets, layers, models\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 2: Load and Preprocess CIFAR-10 Dataset\n",
+        "# CIFAR-10 contains 60,000 32x32 color images in 10 classes (e.g., airplane, cat, dog)\n",
+        "(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()\n",
+        "\n",
+        "# Normalize pixel values to range [0, 1]\n",
+        "train_images, test_images = train_images / 255.0, test_images / 255.0\n",
+        "\n",
+        "# Define class names for visualization\n",
+        "class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n",
+        "               'dog', 'frog', 'horse', 'ship', 'truck']"
+      ],
+      "metadata": {
+        "id": "Cr5NO7K8xbNc",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c62343f1-d504-46d0-d9bc-0f354e0541cd"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
+            "\u001b[1m170498071/170498071\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 0us/step\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 3: Visualize Sample Data\n",
+        "plt.figure(figsize=(10, 10))\n",
+        "for i in range(9):\n",
+        "    plt.subplot(3, 3, i+1)\n",
+        "    plt.imshow(train_images[i])\n",
+        "    plt.title(class_names[train_labels[i][0]])\n",
+        "    plt.axis('off')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 829
+        },
+        "id": "h0iI0xHbxfp_",
+        "outputId": "89953ce6-4e52-4a72-dd1e-3f0d9b5836a5"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x1000 with 9 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 4: Build the CNN Model\n",
+        "model = models.Sequential([\n",
+        "    # Convolutional Layer 1: 32 filters, 3x3 kernel, ReLU activation\n",
+        "    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),\n",
+        "    layers.MaxPooling2D((2, 2)),\n",
+        "    # Convolutional Layer 2: 64 filters, 3x3 kernel\n",
+        "    layers.Conv2D(64, (3, 3), activation='relu'),\n",
+        "    layers.MaxPooling2D((2, 2)),\n",
+        "    # Convolutional Layer 3: 64 filters, 3x3 kernel\n",
+        "    layers.Conv2D(64, (3, 3), activation='relu'),\n",
+        "    # Flatten the output for dense layers\n",
+        "    layers.Flatten(),\n",
+        "    # Dense Layer: 64 units\n",
+        "    layers.Dense(64, activation='relu'),\n",
+        "    # Output Layer: 10 units (one per class) with softmax\n",
+        "    layers.Dense(10, activation='softmax')\n",
+        "])\n",
+        "# Display model summary\n",
+        "model.summary()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "Df_O6VPQxin1",
+        "outputId": "1eeee0bc-e85e-4788-b0ad-e8848269aaa8"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\u001b[1mModel: \"sequential\"\u001b[0m\n"
+            ],
+            "text/html": [
+              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n",
+              "</pre>\n"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+              "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
+              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+              "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m30\u001b[0m, \u001b[38;5;34m30\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │           \u001b[38;5;34m896\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m)    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m15\u001b[0m, \u001b[38;5;34m15\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m13\u001b[0m, \u001b[38;5;34m64\u001b[0m)     │        \u001b[38;5;34m18,496\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m)  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m64\u001b[0m)       │             \u001b[38;5;34m0\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m64\u001b[0m)       │        \u001b[38;5;34m36,928\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ flatten (\u001b[38;5;33mFlatten\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m)           │             \u001b[38;5;34m0\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ dense (\u001b[38;5;33mDense\u001b[0m)                   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)             │        \u001b[38;5;34m65,600\u001b[0m │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)             │           \u001b[38;5;34m650\u001b[0m │\n",
+              "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+            ],
+            "text/html": [
+              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+              "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+              "│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">30</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">30</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │           <span style=\"color: #00af00; text-decoration-color: #00af00\">896</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ max_pooling2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">15</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">15</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ conv2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">13</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">13</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │        <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ max_pooling2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">6</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">6</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)       │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ conv2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)       │        <span style=\"color: #00af00; text-decoration-color: #00af00\">36,928</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1024</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)             │        <span style=\"color: #00af00; text-decoration-color: #00af00\">65,600</span> │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │           <span style=\"color: #00af00; text-decoration-color: #00af00\">650</span> │\n",
+              "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+              "</pre>\n"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m122,570\u001b[0m (478.79 KB)\n"
+            ],
+            "text/html": [
+              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">122,570</span> (478.79 KB)\n",
+              "</pre>\n"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m122,570\u001b[0m (478.79 KB)\n"
+            ],
+            "text/html": [
+              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">122,570</span> (478.79 KB)\n",
+              "</pre>\n"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
+            ],
+            "text/html": [
+              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
+              "</pre>\n"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 5: Compile the Model\n",
+        "model.compile(optimizer='adam',\n",
+        "              loss='sparse_categorical_crossentropy',\n",
+        "              metrics=['accuracy'])"
+      ],
+      "metadata": {
+        "id": "0oZQ0jj7xlN8"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+        "\n",
+        "# Create an ImageDataGenerator with augmentation\n",
+        "datagen = ImageDataGenerator(\n",
+        "    rotation_range=20,\n",
+        "    width_shift_range=0.1,\n",
+        "    height_shift_range=0.1,\n",
+        "    horizontal_flip=True)\n",
+        "\n",
+        "# Fit the generator to training data\n",
+        "datagen.fit(train_images)\n",
+        "\n",
+        "# Train using generator\n",
+        "history = model.fit(datagen.flow(train_images, train_labels, batch_size=64),\n",
+        "                    epochs=10,\n",
+        "                    validation_data=(test_images, test_labels))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ces2ji7ExrlR",
+        "outputId": "ba7baa7a-7f70-4fc8-9fc1-9b6631eb90a1"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 45ms/step - accuracy: 0.3475 - loss: 1.7648 - val_accuracy: 0.5322 - val_loss: 1.2682\n",
+            "Epoch 2/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 43ms/step - accuracy: 0.5611 - loss: 1.2266 - val_accuracy: 0.6003 - val_loss: 1.1286\n",
+            "Epoch 3/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 42ms/step - accuracy: 0.6285 - loss: 1.0580 - val_accuracy: 0.6495 - val_loss: 1.0044\n",
+            "Epoch 4/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 43ms/step - accuracy: 0.6652 - loss: 0.9460 - val_accuracy: 0.6507 - val_loss: 0.9971\n",
+            "Epoch 5/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 42ms/step - accuracy: 0.6931 - loss: 0.8697 - val_accuracy: 0.6796 - val_loss: 0.9160\n",
+            "Epoch 6/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 43ms/step - accuracy: 0.7104 - loss: 0.8259 - val_accuracy: 0.6803 - val_loss: 0.9241\n",
+            "Epoch 7/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 44ms/step - accuracy: 0.7329 - loss: 0.7636 - val_accuracy: 0.6918 - val_loss: 0.8821\n",
+            "Epoch 8/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 42ms/step - accuracy: 0.7465 - loss: 0.7163 - val_accuracy: 0.7030 - val_loss: 0.8741\n",
+            "Epoch 9/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 41ms/step - accuracy: 0.7666 - loss: 0.6689 - val_accuracy: 0.7098 - val_loss: 0.8420\n",
+            "Epoch 10/10\n",
+            "\u001b[1m1563/1563\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 42ms/step - accuracy: 0.7749 - loss: 0.6375 - val_accuracy: 0.7056 - val_loss: 0.8789\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 7: Evaluate the Model\n",
+        "test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\n",
+        "print(f\"\\nTest accuracy: {test_acc:.4f}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "LlddYNoVxvNS",
+        "outputId": "69b74c58-67ce-4d5d-9180-7af4095c8971"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "313/313 - 3s - 11ms/step - accuracy: 0.7056 - loss: 0.8789\n",
+            "\n",
+            "Test accuracy: 0.7056\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "# Step 8: Plot Training and Validation Accuracy\n",
+        "plt.figure(figsize=(12, 4))\n",
+        "plt.subplot(1, 2, 1)\n",
+        "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
+        "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
+        "plt.title('Training and Validation Accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.legend()\n",
+        "\n",
+        "plt.subplot(1, 2, 2)\n",
+        "plt.plot(history.history['loss'], label='Training Loss')\n",
+        "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
+        "plt.title('Training and Validation Loss')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.legend()\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 410
+        },
+        "id": "wq0d_xxJxxq8",
+        "outputId": "6afcb6bf-7258-49cc-dfe6-bcdd985a3866"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x400 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 9: Make Predictions\n",
+        "predictions = model.predict(test_images[:5])\n",
+        "for i in range(5):\n",
+        "    predicted_label = class_names[np.argmax(predictions[i])]\n",
+        "    true_label = class_names[test_labels[i][0]]\n",
+        "    print(f\"Image {i+1}: Predicted: {predicted_label}, True: {true_label}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yfcB0fJWxy16",
+        "outputId": "4205e60d-22af-4d36-812b-6ca8de72a32a"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 127ms/step\n",
+            "Image 1: Predicted: cat, True: cat\n",
+            "Image 2: Predicted: ship, True: ship\n",
+            "Image 3: Predicted: ship, True: ship\n",
+            "Image 4: Predicted: airplane, True: airplane\n",
+            "Image 5: Predicted: frog, True: frog\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Step 10: Save Model Performance for Autograding\n",
+        "# This cell saves the model performance to a text file for GitHub Actions\n",
+        "try:\n",
+        "    # Get final training accuracy\n",
+        "    final_train_acc = history.history['accuracy'][-1]\n",
+        "    final_val_acc = history.history['val_accuracy'][-1]\n",
+        "    final_train_loss = history.history['loss'][-1]\n",
+        "    final_val_loss = history.history['val_loss'][-1]\n",
+        "\n",
+        "    # Create performance summary\n",
+        "    performance_text = f\"\"\"Model Performance Summary:\n",
+        "Test Accuracy: {test_acc:.4f}\n",
+        "Test Loss: {test_loss:.4f}\n",
+        "Final Training Accuracy: {final_train_acc:.4f}\n",
+        "Final Validation Accuracy: {final_val_acc:.4f}\n",
+        "Final Training Loss: {final_train_loss:.4f}\n",
+        "Final Validation Loss: {final_val_loss:.4f}\n",
+        "Training Epochs: {len(history.history['accuracy'])}\n",
+        "Model Parameters: {model.count_params()}\"\"\"\n",
+        "\n",
+        "    # Save to file for GitHub Actions\n",
+        "    with open('model_accuracy.txt', 'w') as f:\n",
+        "        f.write(performance_text)\n",
+        "\n",
+        "    print(\"Model performance saved to model_accuracy.txt\")\n",
+        "    print(performance_text)\n",
+        "\n",
+        "except Exception as e:\n",
+        "    print(f\"Error saving model performance: {e}\")\n",
+        "    # Create a basic file even if there's an error\n",
+        "    with open('model_accuracy.txt', 'w') as f:\n",
+        "        f.write(f\"Model execution completed with errors: {e}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "snKW8jQ4nO1-",
+        "outputId": "9e85a74c-765e-44cf-e105-72411054aa5c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Model performance saved to model_accuracy.txt\n",
+            "Model Performance Summary:\n",
+            "Test Accuracy: 0.7056\n",
+            "Test Loss: 0.8789\n",
+            "Final Training Accuracy: 0.7727\n",
+            "Final Validation Accuracy: 0.7056\n",
+            "Final Training Loss: 0.6478\n",
+            "Final Validation Loss: 0.8789\n",
+            "Training Epochs: 10\n",
+            "Model Parameters: 122570\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file