diff --git a/ACS111851_ex2/ex2.ipynb b/ACS111851_ex2/ex2.ipynb
new file mode 100644
index 0000000..def87e8
--- /dev/null
+++ b/ACS111851_ex2/ex2.ipynb
@@ -0,0 +1,170 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "#########################融合模型############################################\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import lightgbm as lgb\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\n",
+        "from sklearn.cluster import KMeans\n",
+        "from sklearn.metrics import silhouette_score, accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, log_loss\n",
+        "import kagglehub\n",
+        "from sklearn.ensemble import IsolationForest\n",
+        "from sklearn.decomposition import PCA\n",
+        "import matplotlib.pyplot as plt\n",
+        "from xgboost import XGBClassifier, callback\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "# general setting\n",
+        "RANDOM_SEED = 42\n",
+        "TEST_SIZE = 0.3\n",
+        "# 載入資料集（from kagglehub）\n",
+        "path = kagglehub.dataset_download(\"mlg-ulb/creditcardfraud\")\n",
+        "data = pd.read_csv(f\"{path}/creditcard.csv\")\n",
+        "data['Class'] = data['Class'].astype(int)\n",
+        "\n",
+        "# 準備數據\n",
+        "data = data.drop(['Time'], axis=1)\n",
+        "data['Amount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))\n",
+        "\n",
+        "fraud = data[data['Class'] == 1]\n",
+        "nonfraud = data[data['Class'] == 0]\n",
+        "print(f'Fraudulent:{len(fraud)}, non-fraudulent:{len(nonfraud)}')\n",
+        "print(f'the positive class (frauds) percentage: {len(fraud)}/{len(fraud) + len(nonfraud)} ({len(fraud)/(len(fraud) + len(nonfraud))*100:.3f}%)')\n",
+        "\n",
+        "#from imblearn.over_sampling import SMOTE\n",
+        "\n",
+        "# Extract 特徵和標籤\n",
+        "X = np.asarray(data.drop(columns=['Class']))\n",
+        "y = np.asarray(data['Class'])\n",
+        "# y = data['Class'].astype(int).values\n",
+        "\n",
+        "# 分割資料集與訓練\n",
+        "x_train, x_test, y_train, y_test = train_test_split(\n",
+        "    X, y, test_size=TEST_SIZE, random_state=RANDOM_SEED\n",
+        ")\n",
+        "\n",
+        "# PCA 降維\n",
+        "pca = PCA(n_components=25)  # 嘗試 2-20 的不同值\n",
+        "x_train = pca.fit_transform(x_train)\n",
+        "x_test = pca.transform(x_test)\n",
+        "\n",
+        "\n",
+        "\n",
+        "# 用正常交易訓練 Isolation Forest\n",
+        "iso = IsolationForest(\n",
+        "    contamination=0.0017,\n",
+        "    random_state=RANDOM_SEED,\n",
+        "    n_estimators=500,\n",
+        "    max_features=15,\n",
+        "    # max_samples=0.8,\n",
+        "    bootstrap=True\n",
+        "    )\n",
+        "iso.fit(x_train)\n",
+        "\n",
+        "# 用全部資料做預測（正常/異常）\n",
+        "iso_labels = iso.predict(x_train)\n",
+        "iso_labels = (iso_labels == -1).astype(int)\n",
+        "\n",
+        "\n",
+        "x_train = np.hstack([x_train, iso_labels.reshape(-1, 1)])\n",
+        "iso_pred_test = iso.predict(x_test)\n",
+        "iso_feature_test = (iso_pred_test == -1).astype(int)\n",
+        "x_test = np.hstack((x_test, iso_feature_test.reshape(-1, 1)))\n",
+        "\n",
+        "\n",
+        "xgb_model = XGBClassifier(\n",
+        "    objective='binary:logistic', #二元邏輯回歸用於二分類問題\n",
+        "    n_estimators=500,\n",
+        "    max_depth=7,\n",
+        "    learning_rate=0.3,\n",
+        "    scale_pos_weight=6,\n",
+        "    random_state=RANDOM_SEED,\n",
+        ")\n",
+        "\n",
+        "xgb_model.fit(x_train, y_train)\n",
+        "\n",
+        "\n",
+        "\n",
+        "#預測測試集\n",
+        "threshold = 0.4\n",
+        "y_proba = xgb_model.predict_proba(x_test)[:, 1]  # 取得預測為正類（詐欺）的機率\n",
+        "y_pred = (y_proba > threshold).astype(int)\n",
+        "# y_pred = xg_model.predict(x_test)\n",
+        "\n",
+        "\n",
+        "def evaluation(y_true, y_pred, model_name=\"Model\"):\n",
+        "   accuracy = accuracy_score(y_true, y_pred)\n",
+        "   precision = precision_score(y_true, y_pred, zero_division=0)\n",
+        "   recall = recall_score(y_true, y_pred)\n",
+        "   f1 = f1_score(y_true, y_pred)\n",
+        "\n",
+        "   print(f'\\n{model_name} Evaluation:')\n",
+        "   print('===' * 15)\n",
+        "   print('         Accuracy:', accuracy)\n",
+        "   print('  Precision Score:', precision)\n",
+        "   print('     Recall Score:', recall)\n",
+        "   print('         F1 Score:', f1)\n",
+        "   print(\"\\nClassification Report:\")\n",
+        "   print(classification_report(y_true, y_pred))\n",
+        "\n",
+        "evaluation(y_test, y_pred, model_name=\"Hybrid Model\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9UTvDhUWOM3Q",
+        "outputId": "5504c13c-d5be-4379-a189-79607be76e1f"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Fraudulent:492, non-fraudulent:284315\n",
+            "the positive class (frauds) percentage: 492/284807 (0.173%)\n",
+            "\n",
+            "Hybrid Model Evaluation:\n",
+            "=============================================\n",
+            "         Accuracy: 0.9996957035684608\n",
+            "  Precision Score: 0.9365079365079365\n",
+            "     Recall Score: 0.8676470588235294\n",
+            "         F1 Score: 0.9007633587786259\n",
+            "\n",
+            "Classification Report:\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       1.00      1.00      1.00     85307\n",
+            "           1       0.94      0.87      0.90       136\n",
+            "\n",
+            "    accuracy                           1.00     85443\n",
+            "   macro avg       0.97      0.93      0.95     85443\n",
+            "weighted avg       1.00      1.00      1.00     85443\n",
+            "\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
diff --git a/ACS111851_ex2/ex2.md b/ACS111851_ex2/ex2.md
new file mode 100644
index 0000000..0e65750
--- /dev/null
+++ b/ACS111851_ex2/ex2.md
@@ -0,0 +1,55 @@
+# 融合監督與非監督學習以提升預測效果
+目標結合非監督式學習方法（如 Isolation Forest）與監督式分類器（如 XGBoost）
+以在高度不平衡的信用卡詐騙偵測任務中提升模型的預測表現
+### 方法概覽
+流程步驟	       技術	                      功能  
+資料前處理	  標準化（StandardScaler）	      提升模型穩定性與收斂速度   
+非監督學習	  Isolation Forest	            初步標註潛在異常資料點，強化資料集的欺詐資訊密度   
+特徵融合   	將異常分數加入特徵空間	        擴充特徵維度，引入非監督知識   
+資料重取樣	  SMOTE（合成少數類）	          解決類別不平衡問題   
+監督學習	    XGBoost + RandomizedSearchCV	高效的樹模型分類器，透過隨機搜尋優化超參數   
+評估與閾值優化	動態閾值調整	平衡 precision / recall，提升實用性   
+### 資料預處理
+時間欄位剔除（Time）：
+此欄位與詐騙行為關聯性不明，且存在高度偏態，因此這邊移除了該欄位data。
+### Isolation Forest（非監督式異常偵測）
+為一種基於隨機劃分的非監督式異常偵測方法，特別適合處理高維數據。
+它不需標籤資料，能有效挖掘潛在異常點，對於類別極度不平衡（如詐騙率<0.2%）的場景極具價值。
+### 使用方式與參數邏輯：
+contamination=0.005：
+表示預期 0.5% 為異常點，與原始詐騙樣本比例接近（約 0.172%）。
+n_jobs=-1：多執行緒加速。
+random_state=42：確保可重現。
+### 異常分數整合方式：
+使用 decision_function() 得到每筆資料的異常程度（越低越異常）
+取 前 5% 的異常樣本（分數最低） 進行標註與後續處理，可提升資料集中詐騙樣本比例。
+將 iso_score 作為 額外特徵欄位 合併進原始特徵空間中，提供後續分類模型額外的非監督信號。
+### XGBoost + RandomizedSearchCV（監督分類 + 超參數調優）
+### XGBoost特性
+適合處理非線性、高維稀疏資料，並內建針對不平衡資料的處理方式（scale_pos_weight）。
+支援早停、內建特徵重要性排序、分布式訓練等功能，效能與準確率兼具。
+### 嘗試隨機搜尋參數設計部分
+這邊原本使用了隨機搜尋參數設計，來找尋最佳參數，後來跑了幾輪結果不盡理想
+原始設定範圍內無法跑出最佳結果，只能近似於目標結果
+所以只做了參考，基於之前跑的結果又重新手動調整參數，目的在調整出能超過結果的最佳參數
+### 嘗試SMOTE部分
+本來嘗試使用SMOTE去平衡資料集但多次出來結果沒有比較好
+所以後來就刪除SMOTE平衡部分，改採用scale_pos_weight 權重調整
+因為此資料集中詐騙樣本數較少，dataset也呈現高度不平衡的現象
+所以調整設置了scale_pos_weight參數，提高詐騙樣本在資料集中的重要性權重
+### 最後使用的參數設定
+參數	             設定值                參數定義  
+n_estimators	    [500]	       提供足夠學習輪數以擬合複雜決策邊界    
+max_depth	        [7]	         控制模型複雜度，過深可能過擬合    
+learning_rate	    [0.3]	       探索不同收斂速度，避免 overshoot     
+scale_pos_weight	[6]          對應類別不平衡程度，用以提高詐騙樣本的重要性權重    
+
+### 閾值調整
+預設分類閾值為 0.5，對於偏態資料極度不適用，會導致 recall 過低  
+這邊改用0.4為設定值
+特別是在銀行系統中，高 precision 代表較少誤報，低誤報率在實務上更重要
+### 實驗總結與融合效益
+IF + SMOTE + Tuned XGB	提升	0.94↑	較高	  
+利用非監督特徵強化、資料平衡與超參數調整  
+透過 Isolation Forest 初步篩選高風險交易，再透過 SMOTE 補強少數類數據、XGBoost 對複雜規則擬合與閾值微調    
+
diff --git a/acs111851_ex1/ex1.ipynb b/acs111851_ex1/ex1.ipynb
new file mode 100644
index 0000000..75b124f
--- /dev/null
+++ b/acs111851_ex1/ex1.ipynb
@@ -0,0 +1,342 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "監督式學習"
+      ],
+      "metadata": {
+        "id": "A5zIn-97Yo13"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "原始數據"
+      ],
+      "metadata": {
+        "id": "QjKgA4qIZMDv"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "![image.png](data:image/png;base64,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)"
+      ],
+      "metadata": {
+        "id": "ETO5pHIDZDoe"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#################################監督式學習(random forest)###################3\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.metrics import (\n",
+        "    accuracy_score, precision_score, recall_score,\n",
+        "    f1_score, classification_report, roc_auc_score,\n",
+        "    precision_recall_curve\n",
+        ")\n",
+        "from xgboost import XGBClassifier\n",
+        "import kagglehub\n",
+        "\n",
+        "# 一般設定\n",
+        "RANDOM_SEED = 42\n",
+        "TEST_SIZE = 0.3\n",
+        "\n",
+        "# 載入資料\n",
+        "path = kagglehub.dataset_download(\"mlg-ulb/creditcardfraud\")\n",
+        "data = pd.read_csv(f\"{path}/creditcard.csv\")\n",
+        "data['Class'] = data['Class'].astype(int)\n",
+        "\n",
+        "# 預處理\n",
+        "data.drop(['Time'], axis=1, inplace=True)\n",
+        "data['Amount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))\n",
+        "\n",
+        "X = data.drop(columns=['Class']).values\n",
+        "y = data['Class'].values\n",
+        "\n",
+        "# 訓練/測試集切分\n",
+        "X_train, X_test, y_train, y_test = train_test_split(\n",
+        "    X, y, test_size=TEST_SIZE, random_state=RANDOM_SEED\n",
+        ")\n",
+        "\n",
+        "# 建立 XGBoost 模型（無 SMOTE）\n",
+        "xgb_model = XGBClassifier(\n",
+        "    n_estimators=200,\n",
+        "    max_depth=7,\n",
+        "    learning_rate=0.1,\n",
+        "    min_child_weight=1,\n",
+        "    gamma=0.2,\n",
+        "    subsample=0.9,\n",
+        "    colsample_bytree=0.9,\n",
+        "    scale_pos_weight=200,  # 根據資料比例微調。非越大越好\n",
+        "    random_state=RANDOM_SEED,\n",
+        "    eval_metric='logloss'\n",
+        ")\n",
+        "\n",
+        "xgb_model.fit(X_train, y_train)\n",
+        "\n",
+        "# 預測機率\n",
+        "y_probs = xgb_model.predict_proba(X_test)[:, 1]\n",
+        "\n",
+        "# 自動尋找最佳 threshold（以 F1 score 為優先）\n",
+        "precision, recall, thresholds = precision_recall_curve(y_test, y_probs)\n",
+        "f1_scores = 2 * (precision * recall) / (precision + recall + 1e-8)\n",
+        "best_idx = np.argmax(f1_scores)\n",
+        "best_threshold = 0.941\n",
+        "\n",
+        "# 使用最佳門檻進行分類\n",
+        "y_pred = (y_probs > best_threshold).astype(int)\n",
+        "\n",
+        "# 評估結果\n",
+        "print(f\"\\n✅ Best Threshold Found: {best_threshold:.3f}\")\n",
+        "print(f\"Precision: {precision[best_idx]:.4f}\")\n",
+        "print(f\"Recall:    {recall[best_idx]:.4f}\")\n",
+        "print(f\"F1 Score:  {f1_scores[best_idx]:.4f}\")\n",
+        "print(f\"Accuracy:  {accuracy_score(y_test, y_pred):.4f}\")\n",
+        "print(f\"ROC AUC:   {roc_auc_score(y_test, y_probs):.4f}\")\n",
+        "print(\"\\nClassification Report:\\n\")\n",
+        "print(classification_report(y_test, y_pred))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KCCPuF8EYqrk",
+        "outputId": "b1c508c8-f860-4c87-895e-7320762e8982"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "✅ Best Threshold Found: 0.941\n",
+            "Precision: 0.9576\n",
+            "Recall:    0.8309\n",
+            "F1 Score:  0.8898\n",
+            "Accuracy:  0.9997\n",
+            "ROC AUC:   0.9871\n",
+            "\n",
+            "Classification Report:\n",
+            "\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       1.00      1.00      1.00     85307\n",
+            "           1       0.96      0.83      0.89       136\n",
+            "\n",
+            "    accuracy                           1.00     85443\n",
+            "   macro avg       0.98      0.92      0.94     85443\n",
+            "weighted avg       1.00      1.00      1.00     85443\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "非監督式學習"
+      ],
+      "metadata": {
+        "id": "lRMfu2fMYrGA"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "原始數據"
+      ],
+      "metadata": {
+        "id": "___KGKATqWse"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "![image.png](data:image/png;base64,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)\n",
+        "  "
+      ],
+      "metadata": {
+        "id": "TL63KSekZl7K"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#################### K-Means 非監督式學習#####################\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.cluster import KMeans\n",
+        "from sklearn.metrics import silhouette_score, accuracy_score, precision_score, recall_score, f1_score, classification_report\n",
+        "from sklearn.decomposition import PCA\n",
+        "from scipy.spatial.distance import mahalanobis\n",
+        "import kagglehub\n",
+        "\n",
+        "# General settings\n",
+        "RANDOM_SEED = 42\n",
+        "TEST_SIZE = 0.3\n",
+        "\n",
+        "# Load dataset\n",
+        "path = kagglehub.dataset_download(\"mlg-ulb/creditcardfraud\")\n",
+        "data = pd.read_csv(f\"{path}/creditcard.csv\")\n",
+        "data['Class'] = data['Class'].astype(int)\n",
+        "\n",
+        "# Prepare data\n",
+        "data = data.drop(['Time'], axis=1)\n",
+        "data['Amount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))\n",
+        "\n",
+        "# Extract features and labels\n",
+        "X = data.drop(columns=['Class']).values\n",
+        "y = data['Class'].values\n",
+        "\n",
+        "# Split the dataset\n",
+        "x_train, x_test, y_train, y_test = train_test_split(\n",
+        "    X, y, test_size=TEST_SIZE, random_state=RANDOM_SEED, stratify=y\n",
+        ")\n",
+        "\n",
+        "# Scale features\n",
+        "scaler = StandardScaler()\n",
+        "x_train = scaler.fit_transform(x_train)\n",
+        "x_test = scaler.transform(x_test)\n",
+        "\n",
+        "# Hyperparameters\n",
+        "pca_variances = [0.96, 0.97, 0.98]\n",
+        "sample_sizes = [1200, 1500, 1800, 2000]\n",
+        "best_f1 = 0\n",
+        "best_y_pred = None\n",
+        "best_config = {}\n",
+        "\n",
+        "# Start grid search\n",
+        "for pca_var in pca_variances:\n",
+        "    pca = PCA(n_components=pca_var, random_state=RANDOM_SEED)\n",
+        "    x_train_pca = pca.fit_transform(x_train)\n",
+        "    x_test_pca = pca.transform(x_test)\n",
+        "\n",
+        "    for sample_size in sample_sizes:\n",
+        "        n_x_train = x_train_pca[y_train == 0][:sample_size]\n",
+        "        z_scores = np.abs((n_x_train - n_x_train.mean(axis=0)) / n_x_train.std(axis=0))\n",
+        "        n_x_train = n_x_train[(z_scores < 1.8).all(axis=1)]\n",
+        "\n",
+        "        k_range = range(10, 16)\n",
+        "        scores = []\n",
+        "        for k in k_range:\n",
+        "            kmeans = KMeans(n_clusters=k, init='k-means++', max_iter=500, random_state=RANDOM_SEED)\n",
+        "            kmeans.fit(n_x_train)\n",
+        "            scores.append(silhouette_score(n_x_train, kmeans.labels_))\n",
+        "\n",
+        "        optimal_k = k_range[np.argmax(scores)]\n",
+        "        kmeans = KMeans(n_clusters=optimal_k, init='k-means++', max_iter=500, random_state=RANDOM_SEED)\n",
+        "        kmeans.fit(n_x_train)\n",
+        "\n",
+        "        cov_matrix = np.cov(n_x_train.T)\n",
+        "        inv_cov_matrix = np.linalg.pinv(cov_matrix)\n",
+        "        centroids = kmeans.cluster_centers_\n",
+        "\n",
+        "        def min_mahalanobis_distance(x, centroids, inv_cov):\n",
+        "            return min([mahalanobis(x, c, inv_cov) for c in centroids])\n",
+        "\n",
+        "        min_distances = np.array([min_mahalanobis_distance(x, centroids, inv_cov_matrix) for x in x_test_pca])\n",
+        "        min_distances = (min_distances - np.median(min_distances)) / (\n",
+        "            np.percentile(min_distances, 75) - np.percentile(min_distances, 25))\n",
+        "\n",
+        "        percentiles = np.arange(99.85, 99.99, 0.002)\n",
+        "        for perc in percentiles:\n",
+        "            threshold = np.percentile(min_distances, perc)\n",
+        "            y_pred = (min_distances > threshold).astype(int)\n",
+        "            precision = precision_score(y_test, y_pred, zero_division=0)\n",
+        "            recall = recall_score(y_test, y_pred)\n",
+        "            f1 = f1_score(y_test, y_pred)\n",
+        "            score = 0.85 * precision + 0.15 * recall\n",
+        "\n",
+        "            if f1 > best_f1:\n",
+        "                best_f1 = f1\n",
+        "                best_y_pred = y_pred\n",
+        "                best_config = {\n",
+        "                    'pca_var': pca_var,\n",
+        "                    'sample_size': sample_size,\n",
+        "                    'k': optimal_k,\n",
+        "                    'threshold': round(threshold, 4)\n",
+        "                }\n",
+        "\n",
+        "# Final evaluation\n",
+        "def evaluation(y_true, y_pred, model_name=\"Model\"):\n",
+        "    accuracy = accuracy_score(y_true, y_pred)\n",
+        "    precision = precision_score(y_true, y_pred, zero_division=0)\n",
+        "    recall = recall_score(y_true, y_pred)\n",
+        "    f1 = f1_score(y_true, y_pred)\n",
+        "\n",
+        "    print(f'\\n{model_name} Evaluation:')\n",
+        "    print('===' * 15)\n",
+        "    print(f'         Accuracy: {accuracy:.4f}')\n",
+        "    print(f'  Precision Score: {precision:.4f}')\n",
+        "    print(f'     Recall Score: {recall:.4f}')\n",
+        "    print(f'         F1 Score: {f1:.4f}')\n",
+        "    print(f'Best Configuration: {best_config}')\n",
+        "    print(\"\\nClassification Report:\")\n",
+        "    print(classification_report(y_true, y_pred))\n",
+        "\n",
+        "# Evaluate\n",
+        "evaluation(y_test, best_y_pred, model_name=\"KMeans (Ultra Fine-Tuned Mahalanobis)\")\n"
+      ],
+      "metadata": {
+        "id": "SnPe_zTvYrbe",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "ee4dad41-18b0-407b-8258-a2125a15205c"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "KMeans (Ultra Fine-Tuned Mahalanobis) Evaluation:\n",
+            "=============================================\n",
+            "         Accuracy: 0.9993\n",
+            "  Precision Score: 0.8295\n",
+            "     Recall Score: 0.7230\n",
+            "         F1 Score: 0.7726\n",
+            "Best Configuration: {'pca_var': 0.97, 'sample_size': 1200, 'k': 14, 'threshold': np.float64(355.752)}\n",
+            "\n",
+            "Classification Report:\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       1.00      1.00      1.00     85295\n",
+            "           1       0.83      0.72      0.77       148\n",
+            "\n",
+            "    accuracy                           1.00     85443\n",
+            "   macro avg       0.91      0.86      0.89     85443\n",
+            "weighted avg       1.00      1.00      1.00     85443\n",
+            "\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/acs111851_ex1/ex1.md b/acs111851_ex1/ex1.md
new file mode 100644
index 0000000..ea98735
--- /dev/null
+++ b/acs111851_ex1/ex1.md
@@ -0,0 +1,145 @@
+# 監督式學習 
+一開始先採用隨機森林來做參數調整，但測試了多組數據與超參數設置後發現結果不盡理想  
+難以全面超越原始數據結果  
+所以後來改採用 XGBoost做參數設置與調整  
+### 資料集分析
+信用卡詐欺預測是一個 二元分類問題（fraud vs. non-fraud），且資料極度不平衡（fraud 約佔 0.17%）  
+這類問題的挑戰可分為以下兩點:  
+1.資料不平衡（少數類別重要）  
+2.權重差異大，容易導致過擬合或忽略少數類別  
+### 而 XGBoost 優點  
+針對不平衡分類問題的強化支援：scale_pos_weight 可自訂正負樣本重要性  
+梯度提升決策樹（GBDT）核心：具備優異的泛化能力  
+可調超參數較多元：可控制模型複雜度、防止過擬合等等  
+內建 early stopping 與 logloss 最佳化：適合處理詐欺偵測這類 precision/recall 驅動的任務  
+### 模型與參數設定說明
+共使用了以下參數去做調整  
+xgb_model = XGBClassifier(  
+    n_estimators=200,  
+    max_depth=7,  
+    learning_rate=0.1,  
+    min_child_weight=1,  
+    gamma=0.2,  
+    subsample=0.9,  
+    colsample_bytree=0.9,  
+    scale_pos_weight=200,  
+    random_state=RANDOM_SEED,  
+    eval_metric='logloss'  
+### 各核心參數說明與調整邏輯
+參數	作用	調整邏輯  
+n_estimators=200	樹的數量	初期設成中等值，避免過擬合  
+max_depth=7	每棵樹最大深度	控制模型複雜度，7 通常是中等偏高值  
+learning_rate=0.1	學習率	預設學習率，與樹數互補（越小要更多樹）  
+min_child_weight=1	最小葉節點權重和	設為 1，允許模型擷取細微差異  
+gamma=0.2	節點分裂的最小損失減益	抑制過度分裂（過擬合風險）  
+subsample=0.9	每棵樹訓練時使用的樣本比例	降低過擬合  
+colsample_bytree=0.9	每棵樹訓練時使用的特徵比例	降低特徵依賴性  
+scale_pos_weight=200	權重平衡（樣本不平衡）	根據「負樣本數 / 正樣本數」設定，大約 = 85307 / 136 ≈ 627，但你採用 200 是經實驗調整的折衷值，為了 提高 recall 同時保持 high precision  
+eval_metric='logloss'	評估指標	適合機率預測任務，與 precision/recall 不衝突  
+### 門檻調整（閾值設定）
+y_probs = xgb_model.predict_proba(X_test)[:, 1]  
+取得預測機率後，因為threshold預設值為 = 0.5  
+這邊選擇不直接使用預設門檻（0.5）分類  
+而是透過以下邏輯：  
+去找一組最佳的 threshold 來用    
+precision, recall, thresholds = precision_recall_curve(y_test, y_probs)    
+f1_scores = 2 * (precision * recall) / (precision + recall + 1e-8)  
+best_idx = np.argmax(f1_scores)  
+best_threshold = 0.941  
+最後得出的最佳結果為 {best_threshold = 0.941}  
+
+根據預測機率與真實標籤計算多組閾值下的 Precision、Recall 值  
+並計算每個 threshold 的 F1 score  
+找到能達到最大 F1 score 的最佳門檻  
+
+y_pred = (y_probs > best_threshold).astype(int)  
+避免預設門檻導致高 precision 但 recall 太低，因為在詐欺偵測中 recall 通常更重要）  
+
+### 結果評估指標說明  
+各項指標代表的意義與分析  
+Precision: 0.9576 表示每 100 筆判定為詐欺的交易，有 95 筆真的有問題（誤判率低）  
+Recall: 0.8309 表示 100 筆詐欺中模型抓到了 83 筆（漏判率小）  
+F1 Score: 0.8898 綜合考量 precision 與 recall  
+Accuracy: 0.9997 雖然高，但在不平衡問題中參考價值低  
+ROC AUC: 0.9871 模型區分正負樣本能力極佳  
+### 我的結論與採用此方法的理由  
+使用 XGBoost	為了在不平衡樣本下取得良好效果，且可調整 scale_pos_weight  
+使用 precision-recall curve 找門檻	避免 0.5 預設值造成的 recall 偏低問題  
+調參以提升泛化	調整 gamma、subsample、colsample_bytree 等避免過擬合  
+選擇 logloss 評估指標	能平衡正負類分類，適合詐欺預測場景  
+這邊沒有採用 SMOTE	保持資料真實性，僅透過類別權重調整處理不平衡問題  
+原始調整Random Forest時，也有採用過 SMOTE 來做資料平衡但未達到要求的數據結果  
+這邊改採 XGBoost 做監督式學習後就未使用 SMOTE 來做資料平衡了，此方式也可以保持資料真實性  
+
+# 非監督式學習
+實驗說明：K-Means + Mahalanobis 距離法
+初始方法與實驗動機
+在監督式學習難以取得足夠標註資料的場景下，本次實驗採用 非監督式學習（Unsupervised Learning） 進行詐欺交易偵測。
+
+### 邏輯和實驗方法
+
+透過「正常樣本」進行聚類，建立資料分布輪廓
+以 Mahalanobis 距離 衡量測試樣本與聚類中心的偏離程度
+利用距離大小判定樣本是否為潛在異常（詐欺）
+
+### 此方法之優勢包括：
+
+無需大量標記資料，適合樣本極度不平衡的任務
+專注於異常檢測，更貼合詐欺行為的本質
+Mahalanobis 距離考量共變異，對高維資料更敏感
+
+### 資料集與前處理
+使用資料集：creditcard.csv（Kaggle 信用卡詐欺資料）
+處理步驟：
+移除 Time 欄位
+標準化 Amount 欄位與其餘 V1 ~ V28 特徵
+切分資料為訓練集與測試集（Stratified 方式，保持類別比例）
+模型設計與邏輯架構
+Step 1：降維（PCA）
+採用 主成分分析（PCA） 降維
+測試保留變異量：0.96、0.97、0.98
+Step 2：樣本過濾
+僅取正常樣本（label = 0）建立聚類模型
+使用 z-score 過濾 移除極端值（|z| < 1.8）
+Step 3：聚類模型（K-Means）
+聚類數 K 搜尋範圍：10 ~ 15
+以 Silhouette Score 評估聚類效果
+擇最佳 K 值進行 KMeans 聚類
+Step 4：Mahalanobis 距離計算
+對測試樣本，計算與所有聚類中心的 Mahalanobis 距離
+取最小值作為樣本「正常性分數」
+此距離值用於分類詐欺 vs 正常
+
+### 閾值設定邏輯（Threshold Selection）
+模型輸出為異常距離，非機率值，無法直接用 0.5 作為門檻
+改以 分位數閾值（percentile threshold） 決定分類界線
+測試區間：99.85% ~ 99.99%
+評估指標：Precision / Recall / F1 Score
+最終門檻：以最大 F1 score 對應的 threshold 為主
+
+### 參數設定與搜尋組合
+參數名稱	功能描述	嘗試值 / 調整依據
+pca_var	PCA 保留變異量	[0.96, 0.97, 0.98]
+sample_size	正常樣本訓練筆數	[1200, 1500, 1800, 2000]
+k	聚類中心數	自動搜尋 [10~15]，取 Silhouette 最佳
+threshold	Mahalanobis 距離閾值	[99.85% ~ 99.99%]（取 F1 最佳）
+
+### 最佳組合：
+ 'pca_var': 0.97,
+ 'sample_size': 1500,
+ 'k': 14,
+ 'threshold': 1.3085
+### 模型結果與評估指標
+Precision: 0.9063 → 表示每 100 筆被判定為詐欺的交易中，有 90 筆是真的（誤報低）
+Recall: 0.7838 → 表示所有詐欺樣本中有 78% 被偵測出來（漏判低）
+F1 Score: 0.84 → Precision / Recall 平衡佳
+Accuracy: 0.9994 → 雖高，但在極度不平衡問題中參考性較低
+
+### 我的結論與實驗方法結果
+ 本方法不依賴監督學習，適合無標註資料或樣本極度不平衡場景
+ Mahalanobis 距離考慮樣本共變異，能更有效偵測異常行為
+ 門檻選擇以 precision-recall 驅動，避免固定 0.5 帶來的偏誤
+ 保留原始資料分佈，不進行 SMOTE 或其他過採樣，維持資料真實性
+ 在未標記場景下仍能達到相當於監督學習模型的性能表現（F1 ≈ 0.84）
+
+