Upload 3 files

AI_Model_architecture.py

@@ -0,0 +1,494 @@
+"""
+流程圖
+讀取資料 → 分割資料 → 編碼 → 建立 Dataset / DataLoader
+↓
+建立模型(BERT+LSTM+CNN)
+        ↓
+        BERT 輸出 [batch, seq_len, 768]
+        ↓
+        BiLSTM  [batch, seq_len, hidden_dim*2]
+        ↓
+        CNN 模組 (Conv1D + Dropout + GlobalMaxPooling1D)
+        ↓
+        Linear 分類器(輸出詐騙機率)
+        ↓
+訓練模型(Epochs)
+↓
+評估模型(Accuracy / F1 / Precision / Recall)
+↓
+儲存模型(.pth)
+
+"""
+#引入重要套件Import Library
+
+import os
+import torch                            #   PyTorch 主模組               
+import torch.nn as nn                   #	神經網路相關的層(例如 LSTM、Linear)        
+import pandas as pd
+import re
+import ast
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.metrics import (
+    classification_report, confusion_matrix, accuracy_score, 
+    precision_score, recall_score, f1_score, roc_auc_score,
+    precision_recall_curve, auc, matthews_corrcoef
+)
+from dotenv import load_dotenv
+from sklearn.model_selection import train_test_split
+from torch.utils.data import DataLoader, Dataset #	提供 Dataset、DataLoader 類別
+from transformers import BertTokenizer # BertTokenizer把文字句子轉換成 BERT 格式的 token ID,例如 [CLS] 今天 天氣 不錯 [SEP] → [101, 1234, 5678, ...]
+from sklearn.model_selection import train_test_split
+
+from transformers import BertModel
+"""
+# ------------------- 載入 .env 環境變數 -------------------
+
+path = r"E:\Project_PredictScamInfo"
+
+# ------------------- 使用相對路徑找 CSV -------------------
+
+#如有需要訓練複數筆資料可以使用這個方法csv_files = [os.path.join(base_dir, "檔案名稱1.csv"),os.path.join(base_dir, "檔案名稱2.csv")]
+#程式碼一至131行
+
+# GPU 記憶體限制(可選)
+# os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:16"
+
+#資料前處理
+
+class BertPreprocessor:
+    def __init__(self, tokenizer_name="ckiplab/bert-base-chinese", max_len=128):
+        self.tokenizer = BertTokenizer.from_pretrained(tokenizer_name)
+        self.max_len = max_len
+
+    def load_and_clean(self, filepath):
+        df = pd.read_csv(filepath)
+        df = df.dropna().drop_duplicates(subset=["message"]).reset_index(drop=True)
+
+        # 清理 message 欄位
+        df["message"] = df["message"].astype(str)
+        df["message"] = df["message"].apply(lambda text: re.sub(r"\s+", "", text))
+        df["message"] = df["message"].apply(lambda text: re.sub(r"[^\u4e00-\u9fffA-Za-z0-9。,！？]", "", text))
+
+        # 清理 keywords 欄位（如果有）
+        if "keywords" in df.columns:
+            df["keywords"] = df["keywords"].fillna("")
+            df["keywords"] = df["keywords"].apply(
+                lambda x: ast.literal_eval(x) if isinstance(x, str) and x.startswith("[") else []
+            )
+            df["keywords"] = df["keywords"].apply(
+                lambda lst: [re.sub(r"[^\u4e00-\u9fffA-Za-z0-9。,！？]", "", str(k)) for k in lst]
+            )
+            df["keywords"] = df["keywords"].apply(lambda lst: "。".join(lst))
+        else:
+            df["keywords"] = ""
+
+        # 合併為 BERT 輸入內容
+        df["combined"] = df["message"] + "。" + df["keywords"]
+        return df[["combined", "label"]]
+
+    def encode(self, texts):
+        return self.tokenizer(
+            list(texts),
+            return_tensors="pt",
+            truncation=True,
+            padding="max_length",
+            max_length=self.max_len
+        )
+#自動做資料前處理
+def build_bert_inputs(files):
+    processor = BertPreprocessor()
+    dfs = [processor.load_and_clean(f) for f in files]
+    all_df = pd.concat(dfs, ignore_index=True)
+    print("📌 原始資料筆數：", sum(len(pd.read_csv(f)) for f in files))
+    print("📌 清理後資料筆數：", len(all_df))
+    print(f"✅ 已讀入 {len(all_df)} 筆資料")
+    print(all_df["label"].value_counts())
+    print("📌 合併後輸入示例：")
+    print(all_df["combined"].head())
+
+    train_df, val_df = train_test_split(
+        all_df,
+        stratify=all_df["label"],
+        test_size=0.2,
+        random_state=25,
+        shuffle=True
+    )
+
+    train_inputs = processor.encode(train_df["combined"])
+    val_inputs = processor.encode(val_df["combined"])
+
+    return train_inputs, train_df["label"], val_inputs, val_df["label"], processor
+
+
+#定義 PyTorch Dataset 類別。ScamDataset 繼承自 torch.utils.data.Dataset
+#將 BERT 輸出的 token 與對應標籤封裝成 PyTorch 能使用的格式
+class ScamDataset(Dataset):
+    def __init__(self, inputs, labels):
+        self.input_ids = inputs["input_ids"]                           # input_ids:句子的 token ID;attention_mask:注意力遮罩(0 = padding)
+        self.attention_mask = inputs["attention_mask"]                 # token_type_ids:句子的 segment 區分
+        self.token_type_ids = inputs["token_type_ids"]                 # torch.tensor(x, dtype=...)將資料(x)轉為Tensor的標準做法。
+        self.labels = torch.tensor(labels.values, dtype=torch.float32) # x可以是 list、NumPy array、pandas series...
+# dtypefloat32:浮點數(常用於 回歸 或 BCELoss 二分類);long:整數(常用於 多分類 搭配 CrossEntropyLoss)。labels.values → 轉為 NumPy array
+    
+    def __len__(self):          # 告訴 PyTorch 這個 Dataset 有幾筆資料
+        return len(self.labels) # 給 len(dataset) 或 for i in range(len(dataset)) 用的
+    
+    def __getitem__(self, idx): #每次調用 __getitem__() 回傳一筆 {input_ids, attention_mask, token_type_ids, labels}
+        return {                #DataLoader 每次會呼叫這個方法多次來抓一個 batch 的資料
+            "input_ids":self.input_ids[idx],
+            "attention_mask":self.attention_mask[idx],
+            "token_type_ids":self.token_type_ids[idx],
+            "labels":self.labels[idx]
+        }
+
+# 這樣可以同時處理 scam 和 normal 資料,不用重複寫清理與 token 處理
+if __name__ == "__main__":
+    csv_files = [os.path.join(path, r"Filled_Keyword_MessageDeduplicated.csv")]
+    train_inputs, train_labels, val_inputs, val_labels, processor = build_bert_inputs(csv_files)
+    
+    train_dataset = ScamDataset(train_inputs, train_labels)
+    val_dataset = ScamDataset(val_inputs, val_labels)
+
+    # batch_size每次送進模型的是 8 筆資料(而不是一筆一筆)
+    # 每次從 Dataset 中抓一批(batch)資料出來
+    train_loader = DataLoader(train_dataset, batch_size=128)
+    val_loader = DataLoader(val_dataset, batch_size=128)
+"""
+"""
+class BertLSTM_CNN_Classifier(nn.Module)表示:你定義了一個子類別,
+繼承自 PyTorch 的基礎模型類別 nn.Module。
+
+若你在 __init__() 裡沒有呼叫 super().__init__(),
+那麼父類別 nn.Module 的初始化邏輯(包含重要功能)就不會被執行,
+導致整個模型運作異常或錯誤。
+"""
+
+# nn.Module是PyTorch所有神經網路模型的基礎類別,nn.Module 是 PyTorch 所有神經網路模型的基礎類別
+class BertLSTM_CNN_Classifier(nn.Module):
+    
+    def __init__(self, hidden_dim=128, num_layers=1, dropout=0.3):
+        
+        # super()是Python提供的一個方法,用來呼叫「父類別的版本」的方法。
+        # 呼叫:super().__init__()讓父類別(nn.Module)裡面那些功能、屬性都被正確初始化。
+        # 沒super().__init__(),這些都不會正確運作,模型會壞掉。
+        # super() 就是 Python 提供給「子類別呼叫父類別方法」的方式
+        super().__init__()
+        
+        # 載入中文預訓練的 BERT 模型,輸入為句子token IDs,輸出為每個 token 的向量,大小為 [batch, seq_len, 768]。
+        self.bert = BertModel.from_pretrained("ckiplab/bert-base-chinese") # 這是引入hugging face中的tranceformat
+        
+        # 接收BERT的輸出(768 維向量),進行雙向LSTM(BiLSTM)建模,輸出為 [batch, seq_len, hidden_dim*2],例如 [batch, seq_len, 256]
+        """
+        LSTM 接收每個token的768維向量(來自 BERT)作為輸入,
+        透過每個方向的LSTM壓縮成128維的語意向量。
+        由於是雙向LSTM,會同時從左到右(前向)和右到左(後向)各做一次,
+        最後將兩個方向的輸出合併為256維向量(128×2)。
+        每次處理一個 batch(例如 8 句話),一次走完整個時間序列。
+        """
+        self.LSTM = nn.LSTM(input_size=768,        
+                            hidden_size=hidden_dim,
+                            num_layers=num_layers,
+                            batch_first=True,
+                            bidirectional=True)
+        
+         # CNN 模組:接在 LSTM 後的輸出上。將LSTM的輸出轉成卷積層格式,適用於Conv1D,CNN可學習位置不變的局部特徵。
+        self.conv1 =  nn.Conv1d(in_channels=hidden_dim*2,
+                                out_channels=128,
+                                kernel_size=3,  # 這裡kernel_size=3 為 3-gram 特徵
+                                padding=1)
+        
+        self.dropout = nn.Dropout(dropout) # 隨機將部分神經元設為 0,用來防止 overfitting。
+        
+        self.global_maxpool = nn.AdaptiveAvgPool1d(1)  #將一整句話的特徵濃縮成一個固定大小的句子表示向量
+        
+        # 將CNN輸出的128維特徵向量輸出為一個「機率值」(詐騙或非詐騙)。
+        self.classifier = nn.Linear(128,1)
+        
+    def forward(self, input_ids, attention_mask, token_type_ids):
+        #BERT 編碼
+        outputs = self.bert(input_ids=input_ids,
+                            attention_mask=attention_mask,
+                            token_type_ids=token_type_ids)
+        #.last_hidden_state是BertModel.from_pretrained(...)內部的key，會輸出    [batch, seq_len, 768]
+        hidden_states = outputs.last_hidden_state 
+
+        # 送入 BiLSTM
+        # transpose(1, 2) 的用途是：讓 LSTM 輸出的資料形狀符合 CNN 所要求的格式
+        #   假設你原本 LSTM 輸出是：    [batch_size, seq_len, hidden_dim*2] = [8, 128, 256]
+        # 但CNN(Conv1d)的輸入格式需要是：[batch_size, in_channels, seq_len] = [8, 256, 128]
+        # 因此你需要做：.transpose(1, 2)把 seq_len 和 hidden_dim*2 調換
+        LSTM_out, _ = self.LSTM(hidden_states)     # [batch, seq_len, hidden_dim*2]
+        LSTM_out = LSTM_out.transpose(1, 2)        # [batch, hidden_dim*2, seq_len]
+
+        # 卷積 + Dropout
+        x = self.conv1(LSTM_out)                   # [batch, 128, seq_len]
+        x = self.dropout(x)
+        
+        #全局池化
+        # .squeeze(dim) 的作用是：把某個「維度大小為 1」的維度刪掉
+        # x = self.global_maxpool(x).squeeze(2)   # 輸出是 [batch, 128, 1]
+        # 不 .squeeze(2)，你會得到 shape 為 [batch, 128, 1]，不方便後面接 Linear。
+        # .squeeze(2)=拿掉第 2 維（數值是 1） → 讓形狀變成 [batch, 128]
+        x = self.global_maxpool(x).squeeze(2)      # [batch, 128]
+
+        #分類 & Sigmoid 機率輸出
+        logits = self.classifier(x)
+        
+        #.sigmoid() → 把 logits 轉成 0~1 的機率.squeeze() → 變成一維 [batch] 長度的機率 list
+        """例如：
+logits = [[0.92], [0.05], [0.88], [0.41], ..., [0.17]]
+→ sigmoid → [[0.715], [0.512], ...]
+→ squeeze → [0.715, 0.512, ...]
+"""
+        return logits.squeeze() # 最後輸出是一個值介於 0 ~ 1 之間,代表「為詐騙訊息的機率」。
+"""
+# 設定 GPU 裝置
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# 初始化模型
+model = BertLSTM_CNN_Classifier().to(device)
+# 定義 optimizer 和損失函數
+optimizer = torch.optim.Adam(model.parameters(),lr=2e-5)
+pos_weight = torch.tensor([2.13], dtype=torch.float32).to(device)
+criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)
+
+# 本機訓練迴圈,要訓練再取消註解,否則在線上版本一律處於註解狀態
+# 訓練期間用的簡化版驗證函式 (只回傳 loss / acc)
+def evaluate_epoch(model, dataloader, criterion, device):
+    model.eval()
+    total_loss = 0
+    all_labels, all_preds = [], []
+
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            token_type_ids = batch["token_type_ids"].to(device)
+            labels = batch["labels"].to(device)
+
+            outputs = model(input_ids, attention_mask, token_type_ids)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+
+            preds = (torch.sigmoid(outputs) > 0.5).long()
+            all_labels.extend(labels.cpu().numpy())
+            all_preds.extend(preds.cpu().numpy())
+
+    acc = accuracy_score(all_labels, all_preds)
+    avg_loss = total_loss / len(dataloader)
+    return avg_loss, acc
+
+# 修改訓練主程式
+
+def train_model(model, train_loader, val_loader, optimizer, criterion, device, num_epochs=15, save_path="model.pth"):
+    train_loss_list, val_loss_list = [], []
+    train_acc_list, val_acc_list = [], []
+
+    for epoch in range(num_epochs):
+        model.train()
+        total_train_loss = 0
+        train_true, train_pred = [], []
+
+        for batch in train_loader:
+            optimizer.zero_grad()
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            token_type_ids = batch["token_type_ids"].to(device)
+            labels = batch["labels"].to(device)
+
+            outputs = model(input_ids, attention_mask, token_type_ids)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            total_train_loss += loss.item()
+            preds = (torch.sigmoid(outputs) > 0.5).long()
+            train_true.extend(labels.cpu().numpy())
+            train_pred.extend(preds.cpu().numpy())
+
+        train_acc = accuracy_score(train_true, train_pred)
+        train_loss = total_train_loss / len(train_loader)
+
+        val_loss, val_acc = evaluate_epoch(model, val_loader, criterion, device)
+
+        train_loss_list.append(train_loss)
+        val_loss_list.append(val_loss)
+        train_acc_list.append(train_acc)
+        val_acc_list.append(val_acc)
+
+        print(f"[Epoch {epoch+1}] Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f} | Train Acc: {train_acc:.4f} | Val Acc: {val_acc:.4f}")
+
+    torch.save(model.state_dict(), save_path)
+    print(f"✅ 模型訓練完成並儲存為 {save_path}")
+
+    # 可視化 Loss Curve
+    plt.figure(figsize=(8, 5))
+    plt.plot(range(1, num_epochs+1), train_loss_list, label="Train Loss")
+    plt.plot(range(1, num_epochs+1), val_loss_list, label="Val Loss")
+    plt.xlabel("Epoch")
+    plt.ylabel("Loss")
+    plt.title("Loss Curve")
+    plt.legend()
+    plt.show()
+
+    # 可視化 Accuracy Curve
+    plt.figure(figsize=(8, 5))
+    plt.plot(range(1, num_epochs+1), train_acc_list, label="Train Accuracy")
+    plt.plot(range(1, num_epochs+1), val_acc_list, label="Val Accuracy")
+    plt.xlabel("Epoch")
+    plt.ylabel("Accuracy")
+    plt.title("Accuracy Curve")
+    plt.legend()
+    plt.show()
+
+        # 訓練結束後繪製 Loss Curve
+    plt.figure(figsize=(8, 5))
+    plt.plot(range(1, num_epochs+1), train_loss_list, label="Train Loss")
+    plt.plot(range(1, num_epochs+1), val_loss_list, label="Val Loss")
+    plt.xlabel("Epoch")
+    plt.ylabel("Loss")
+    plt.title("Loss Curve")
+    plt.legend()
+    plt.show()
+
+        # 繪製 Accuracy Curve
+    plt.figure(figsize=(8, 5))
+    plt.plot(range(1, num_epochs+1), train_acc_list, label="Train Accuracy")
+    plt.plot(range(1, num_epochs+1), val_acc_list, label="Val Accuracy")
+    plt.xlabel("Epoch")
+    plt.ylabel("Accuracy")
+    plt.title("Accuracy Curve")
+    plt.legend()
+    plt.show()
+
+def evaluate_model(model, val_loader, device):
+    model.eval()
+    y_true = []
+    y_pred = []
+    y_pred_prob = []
+
+    with torch.no_grad():
+        for batch in val_loader:
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            token_type_ids = batch["token_type_ids"].to(device)
+            labels = batch["labels"].to(device)
+
+            outputs = model(input_ids, attention_mask, token_type_ids)
+            probs = torch.sigmoid(outputs)
+            preds = (probs > 0.5).long()
+
+            y_true.extend(labels.cpu().numpy())
+            y_pred.extend(preds.cpu().numpy())
+            y_pred_prob.extend(probs.cpu().numpy())
+
+    acc = accuracy_score(y_true, y_pred)
+    prec = precision_score(y_true, y_pred)
+    rec = recall_score(y_true, y_pred)
+    f1 = f1_score(y_true, y_pred)
+    spec = recall_score(y_true, y_pred, pos_label=0)
+    mcc = matthews_corrcoef(y_true, y_pred)
+    roc_auc = roc_auc_score(y_true, y_pred_prob)
+    precision_curve, recall_curve, _ = precision_recall_curve(y_true, y_pred_prob)
+    pr_auc = auc(recall_curve, precision_curve)
+
+    metrics_dict = {
+        'Accuracy': acc,
+        'Precision': prec,
+        'Recall': rec,
+        'Specificity': spec,
+        'F1-score': f1,
+        'MCC': mcc,
+        'ROC AUC': roc_auc,
+        'PR AUC': pr_auc
+    }
+
+    # 視覺化：整體指標 bar chart
+    metric_names = list(metrics_dict.keys())
+    metric_values = list(metrics_dict.values())
+
+    plt.figure(figsize=(10, 6))
+    sns.barplot(y=metric_names, x=metric_values, palette="Blues_d")
+    for index, value in enumerate(metric_values):
+        plt.text(value + 0.01, index, f"{value:.4f}", va='center')
+    plt.title("模型評估指標")
+    plt.xlim(0, 1.05)
+    plt.xlabel("Score")
+    plt.ylabel("Metric")
+    plt.grid(axis='x', linestyle='--', alpha=0.7)
+    plt.tight_layout()
+    plt.show()
+
+    # 視覺化：Confusion Matrix
+    cm = confusion_matrix(y_true, y_pred)
+    plt.figure(figsize=(6, 5))
+    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=["Scam (0)", "Normal (1)"], yticklabels=["Scam (0)", "Normal (1)"])
+    plt.xlabel("Predict")
+    plt.ylabel("Actual")
+    plt.title("Confusion Matrix")
+    plt.tight_layout()
+    plt.show()
+
+    # PR Curve (額外 bonus)
+    plt.plot(recall_curve, precision_curve, marker='.')
+    plt.title('Precision-Recall Curve')
+    plt.xlabel('Recall')
+    plt.ylabel('Precision')
+    plt.show()
+
+    # ROC Curve (額外 bonus)
+    from sklearn.metrics import RocCurveDisplay
+    RocCurveDisplay.from_predictions(y_true, y_pred_prob)
+    plt.title('ROC Curve')
+    plt.show()
+
+
+# 放在主程式中呼叫
+if __name__ == "__main__":
+    print("✅ 開始驗證模型效果...")
+    evaluate_model(model, val_loader, device)
+"""
+"""
+
+整個模型中每一個文字(token)始終是一個向量,隨著層數不同,這個向量代表的意義會更高階、更語意、更抽象。
+在整個 BERT + LSTM + CNN 模型的流程中,「每一個文字(token)」都會被表示成一個「向量」來進行後續的計算與學習。
+今天我輸入一個句子:"早安你好,吃飯沒"
+BERT 的輸入包含三個部分:input_ids、attention_mask、token_type_ids,
+這些是 BERT 所需的格式。BERT 會將句子中每個 token 編碼為一個 768 維的語意向量,
+
+進入 BERT → 每個 token 變成語意向量:
+BERT 輸出每個字為一個 768 維的語意向量
+「早」 → [0.23, -0.11, ..., 0.45]   長度為 768
+「安」 → [0.05, 0.33, ..., -0.12]   一樣 768
+...
+batch size 是 8,句子長度是 8,輸出 shape 為:    
+[batch_size=8, seq_len=8, hidden_size=768]
+
+接下來這些向量會輸入到 LSTM,LSTM��會改變「一個token是一個向量」的概念,而是重新表示每個token的語境向量。
+把每個原本 768 維的 token 壓縮成 hidden_size=128,雙向 LSTM → 拼接 → 每個 token 成為 256 維向量:
+
+input_size=768 是從 BERT 接收的向量維度
+hidden_size=128 表示每個方向的 LSTM 會把 token 壓縮為 128 維語意向量
+num_layers=1 表示只堆疊 1 層 LSTM
+bidirectional=True 表示是雙向
+
+LSTM,除了從左讀到右,也會從右讀到左,兩個方向的輸出會合併(拼接),變成:
+[batch_size=8, seq_len=8, hidden_size=256]  # 因為128*2
+
+接下來進入 CNN,CNN 仍然以「一個向量代表一個字」的形式處理:
+
+in_channels=256(因為 LSTM 是雙向輸出)
+
+out_channels=128 表示學習出 128 個濾波器,每個濾波器專門抓一種 n-gram(例如「早安你」),每個「片段」的結果輸出為 128 維特徵
+
+kernel_size=3 表示每個濾波器看 3 個連續 token(像是一個 3-gram)或,把相鄰的 3 個字(各為 256 維)一起掃描
+
+padding=1 為了保留輸出序列長度和輸入相同,避免邊界資訊被捨棄
+
+CNN 輸出的 shape 就會是:
+
+[batch_size=8, out_channels=128, seq_len=8],還是每個 token 有對應一個向量(只是這向量是 CNN 抽出的新特徵)
+
+"""

app.py

@@ -0,0 +1,166 @@
+
+"""
+-------一定要做步驟-------
+如果以anaconda開啟vscode請先確認有安狀下列套件
+ctrl+shift+x找Live Server並安裝。Live Server是很好用的html前端工具。安裝後,html文件內,右鍵往下找Open with Live server
+在anaconda啟動頁面找anaconda_powershell_prompt下在下列套件,複製貼上就好
+
+pip install fastapi uvicorn pydantic python-multipart aiofiles transformers huggingface_hub torch
+pip install transformers huggingface_hub requests torch torchvision
+pip install torch         
+pip install scikit-learn
+pip install transformers torch
+pip install --upgrade torch --extra-index-url https://download.pytorch.org/whl/cu118
+pip install --upgrade torch --index-url https://download.pytorch.org/whl/cpu
+pip install tqdm
+pip install easyocr
+pip install lime
+
+
+---測試本地前後端連接---
+->打開terminal再來按+號
+->點git bash
+->看到這表示正常,注意專案資料夾位置,像我的是D槽Project_PredictScamInfo
+(user@LAPTOP-GPASQDRA MINGW64 /d/Project_PredictScamInfo (Update)$)
+->輸入 "cd Backend" (進入後端資料夾)
+->(/d/Project_PredictScamInfo/Backend)位址有Backend就是OK
+->輸入" uvicorn app:app --reload "
+->(INFO:     Will watch for changes in these directories: ['D:\\Project_PredictScamInfo\\Backend']  
+INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.)
+INFO:     Started reloader process [70644] using StatReload)這樣表示正常
+->
+----正確顯示----
+INFO:     Uvicorn running on http://127.0.0.1:8000
+INFO:     Started reloader process...
+"""
+
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form                 # 匯入 FastAPI 主功能模組與 HTTP 錯誤處理
+from fastapi.middleware.cors import CORSMiddleware           # 匯入 CORS 模組：用來允許前端跨來源存取 API
+from pydantic import BaseModel                               # 用於定義 API 的資料結構模型
+from datetime import datetime                                # 處理時間格式(如分析時間戳)
+from typing import Optional, List                            # 型別註解：可選、列表
+from bert_explainer import analyze_text, analyze_image  # 匯入自定義的 BERT 模型分析函式
+
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+import os
+import requests
+
+# ---------------- 初始化 FastAPI 應用 ---------------
+#團隊合作:前端工程師、測試人員知道你這API做什麼。會影響 /docs 文件清晰度與專案可讀性,在專案開發與交接時非常有用。
+app = FastAPI(
+    title="詐騙訊息辨識 API",    # 顯示「詐騙訊息辨識 API」
+    description="使用 BERT 模型分析輸入文字是否為詐騙內容",# 說明這個 API 的功能與用途
+    version="1.0.0"             # 顯示版本,例如 v1.0.0
+)
+
+app.mount("/static", StaticFiles(directory=os.path.join(os.path.dirname(__file__), "..", "frontend")), name="static")
+
+"""
+---------------- 設定 CORS(允許跨網域請求) ----------------
+FastAPI提供的內建方法,用來加入中介層(middleware)。在請求抵達API前,或回應送出前,先做某些處理的程式邏輯。
+(Cross-Origin Resource Sharing)瀏覽器的安全機制。
+"""
+
+app.add_middleware(        
+    CORSMiddleware,        # CORSMiddleware的功能就是「允許或拒絕」哪些來源能存取這個 API。
+    allow_origins=["*"],   # 代表所有前端網域(如React前端、Vue前端)都可以發送請求。允許所有來源(不建議正式上線用 *)
+    allow_credentials=True,# 允許前端攜帶登入憑證或 Cookies 等認證資訊。如果你使用身份驗證、JWT Token、Session cookie,就要開啟這個。若你是公開 API,沒用到登入,那設成 False 也可以。
+    allow_methods=["*"],   # 允許 GET, POST, PUT, DELETE, OPTIONS 等方法
+    allow_headers=["*"],   # 允許自訂標頭(如Content-Type)對應JS第46段。如果沒在後端加上這行,附加在HTTP請求或回應中的「額外資訊」會被擋住。
+)
+# ---------------- 請求與回應資料模型 ----------------
+#繼承自pydantic.BaseModel。FastAPI用來驗證與定義資料結構的標準方式,Pydantic提供自動的：
+class TextAnalysisRequest(BaseModel):# 接收前端
+    text: str                        # 使用者輸入的訊息
+    user_id: Optional[str] = None    # 可選的使用者 ID
+    
+class TextAnalysisResponse(BaseModel): # 回傳前端
+    status: str                      # 預測結果：詐騙/正常
+    confidence: float                # 信心分數(通常為 100~0)
+    suspicious_keywords: List[str]   # 可疑詞語清單(目前只會回傳風險分級顯示)
+    highlighted_text: str
+    analysis_timestamp: datetime     # 分析完成時間(偏向資料庫用途,目前沒用到)
+    
+    
+"""
+這是 FastAPI 的路由裝飾器,代表：當使用者對「根目錄 /」發送 HTTP GET 請求時,要執行下面這個函數。
+"/" 是網址的根路徑,例如開啟："http://localhost:8000/"就會觸發這段程式。
+程式碼中/是API的根路徑。@app.get("/")代表使用者訪問網站最基本的路徑：http://localhost:8000/。這個/是URL路徑的根,不是資料夾。
+"""
+
+@app.get("/", response_class=FileResponse)
+async def read_index():
+    return FileResponse(os.path.join(os.path.dirname(__file__), "..", "frontend", "index.html"))
+# 宣告一個非同步函數 root(),FastAPI 支援 async,
+# 寫出高效能的非同步處理(像連資料庫、外部 API 等)
+# 雖然這裡只是回傳資料,但仍建議保留 async      
+# Q:什麼是"非同步函數"(async def)？A:因為有些操作「會花時間」：等後端模型處理,等資料庫查詢,等外部 API 回應。用於處理"等待型操作"如資料庫、模型等。
+# 還有保留 async 可以讓你未來擴充時不用重構。
+# ---------------- 根目錄測試 API ----------------
+@app.get("/")
+async def root():
+# 這是回傳給前端或使用者的一段 JSON 格式資料(其實就是 Python 的 dict)
+    return {
+        "message": "詐騙文字辨識 API 已啟動", # 說明這支 API 成功啟動
+        "version": "1.0.0", # 告訴使用者目前 API 的版本號
+        "status": "active", # 標示服務是否運行中(通常是 active 或 down)
+        "docs": "/docs"     # 告訴使用者：自動生成的 API 文件在 /docs
+# Q:/docs 是什麼？A:FastAPI 自動幫你建一個文件頁：看每個 API 的用途、參數格式
+    }   
+"""
+---------------- 主要 /predict 預測端點 ----------------
+當前端呼叫這個 API,並傳入一段文字時,這段程式會依序做以下事情：
+程式碼內有特別註解掉資料庫部份,因為目前資料庫對該專案並不是特別重要,所以註解的方式,避免再Render佈署前後端網頁時出錯。
+"""
+@app.post("/predict", response_model=TextAnalysisResponse)
+async def analyze_text_api(request: TextAnalysisRequest):
+        try:
+            print("📥 收到請求：", request.text)
+            result = analyze_text(request.text)
+            print("✅ 模型回傳結果：", result)
+            return TextAnalysisResponse(
+            status=result["status"],
+            confidence=result["confidence"],
+            suspicious_keywords=result["suspicious_keywords"],
+            highlighted_text=result["highlighted_text"],
+            analysis_timestamp=datetime.now(),
+        )
+        except Exception as e:
+            print("❌ 錯誤訊息：", str(e))
+            raise HTTPException(status_code=500, detail="內部伺服器錯誤")
+
+
+@app.post("/predict-image", response_model=TextAnalysisResponse)
+async def predict_image_api(file: UploadFile = File(...)):
+    try:
+        print("📷 收到圖片上傳：", file.filename)
+        contents = await file.read()        
+        result = analyze_image(contents)
+        return TextAnalysisResponse(
+            status=result["status"],
+            confidence=result["confidence"],
+            suspicious_keywords=result["suspicious_keywords"],
+            highlighted_text=result["highlighted_text"],
+            analysis_timestamp=datetime.now()
+        )
+    except Exception as e:
+        print("❌ 圖片處理錯誤：", str(e))
+        raise HTTPException(status_code=500, detail="圖片辨識或預測失敗")
+"""
+使用模型分析該文字(實際邏輯在 bert_explainer.py)
+         呼叫模型進行詐騙分析,這會呼叫模型邏輯(在bert_explainer.py),把輸入文字送去分析,得到像這樣的回傳結果(假設)：
+        result = {
+            "status": "詐騙",
+            "confidence": 0.93,
+            "suspicious_keywords": ["繳費", "網址", "限時"]
+        }
+        
+        # 回傳結果給前端。對應script.js第60段註解。
+        # status、confidence、suspicious_keywords在script.js、app.py和bert_explainer是對應的變數,未來有需大更動,必須注意一致性。
+"""
+        
+    

bert_explainer.py

@@ -0,0 +1,190 @@
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+import jieba
+import torch                
+import re
+import easyocr
+import io
+import numpy as np
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from transformers import BertTokenizer
+from AI_Model_architecture import BertLSTM_CNN_Classifier
+from lime.lime_text import LimeTextExplainer
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+
+# OCR 模組
+reader = easyocr.Reader(['ch_tra', 'en'], gpu=torch.cuda.is_available())
+
+# 設定裝置（GPU 優先）
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# 載入模型與 tokenizer
+def load_model_and_tokenizer():
+    global model, tokenizer
+
+    if os.path.exists("model.pth"):
+        print("✅ 已找到 model.pth 載入模型")
+        model_path = "model.pth"
+    else:
+        print("🚀 未找到 model.pth")
+        model_path = hf_hub_download(repo_id="Bennie12/Bert-Lstm-Cnn-ScamDetecter", 
+                              filename="model.pth",
+                              token=HF_TOKEN)
+
+    model = BertLSTM_CNN_Classifier()
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.to(device)
+    model.eval()
+
+    tokenizer = BertTokenizer.from_pretrained("ckiplab/bert-base-chinese", use_fast=False)
+
+    return model, tokenizer
+
+model, tokenizer = load_model_and_tokenizer()
+model.eval()
+
+# 預測單一句子的分類結果
+def predict_single_sentence(model, tokenizer, sentence, max_len=256):
+    sentence = re.sub(r"\s+", "", sentence)
+    sentence = re.sub(r"[^\u4e00-\u9fffA-Za-z0-9。，！？:/._-]", "", sentence)
+
+    encoded = tokenizer(sentence, return_tensors="pt", truncation=True, padding="max_length", max_length=max_len)
+    encoded = {k: v.to(device) for k, v in encoded.items()}
+
+    with torch.no_grad():
+        output = model(encoded["input_ids"], encoded["attention_mask"], encoded["token_type_ids"])
+        prob = torch.sigmoid(output).item()
+        label = int(prob > 0.5)
+    risk = "🟢 低風險（正常）"
+    if prob > 0.9:
+        risk = "🔴 高風險（極可能是詐騙）"
+    elif prob > 0.5:
+        risk = "🟡 中風險（可疑）"
+
+    pre_label = '詐騙' if label == 1 else '正常'
+    
+    return {
+        "label": pre_label,
+        "prob": prob,
+        "risk": risk
+    }
+
+# 提供 LIME 用的 predict_proba
+def predict_proba(texts):
+    # tokenizer 批次處理
+    encoded = tokenizer(
+        texts,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+        max_length=256
+    )
+
+    # 移動到 GPU 或 CPU
+    encoded = {k: v.to(device) for k, v in encoded.items()}
+
+    with torch.no_grad():
+        outputs = model(encoded["input_ids"], encoded["attention_mask"], encoded["token_type_ids"])
+        # outputs shape: (batch_size,)
+        probs = torch.sigmoid(outputs).cpu().numpy()
+
+
+    # 轉成 LIME 格式：(N, 2)
+    probs_2d = np.vstack([1-probs, probs]).T
+    return probs_2d
+
+
+
+# 初始化 LIME explainer
+class_names = ['正常', '詐騙']
+lime_explainer = LimeTextExplainer(class_names=class_names)
+
+# 擷取可疑詞彙 (改用 LIME)
+
+def suspicious_tokens(text, explainer=lime_explainer, top_k=5):
+    try:
+        explanation = explainer.explain_instance(text, predict_proba, num_features=top_k, num_samples=200)
+        keywords = [word for word, weight in explanation.as_list()]
+        return keywords
+    except Exception as e:
+        print("⚠ LIME 失敗，啟用 fallback:", e)
+        fallback = ["繳費", "終止", "逾期", "限時", "驗證碼"]
+        return [kw for kw in fallback if kw in text]
+
+
+# 文字清理
+def clean_text(text):
+    text = re.sub(r"https?://\S+", "", text)
+    text = re.sub(r"[a-zA-Z0-9:/.%\-_=+]{4,}", "", text)
+    text = re.sub(r"\+?\d[\d\s\-]{5,}", "", text)
+    text = re.sub(r"[^一-龥。，！？、]", "", text)
+    sentences = re.split(r"[。！？]", text)
+    cleaned = "。".join(sentences[:4])
+    return cleaned[:300]
+
+# 高亮顯示
+def highlight_keywords(text, keywords, prob):
+    
+    if prob < 0.15:  # 低風險完全不標註
+        return text
+
+    # 決定標註顏色
+    if prob >= 0.65:
+        css_class = 'red-highlight'
+    else:
+        css_class = 'yellow-highlight'
+    for word in keywords:
+        if len(word.strip()) >= 2:
+            text = text.replace(word, f"<span class='{css_class}'>{word}</span>")
+    return text
+
+
+
+
+# 文字分析主流程
+def analyze_text(text):
+    cleaned_text = clean_text(text)
+    result = predict_single_sentence(model, tokenizer, cleaned_text)
+    label = result["label"]
+    prob = result["prob"]
+    risk = result["risk"]
+    
+    suspicious = suspicious_tokens(cleaned_text)
+    # 依照可疑度做不同標註
+    highlighted_text = highlight_keywords(text, suspicious, prob)
+    # 低風險下不回傳 suspicious_keywords
+    if prob < 0.15:
+        suspicious = []
+        
+    print(f"\n📩 訊息內容：{text}")
+    print(f"✅ 預測結果：{label}")  
+    print(f"📊 信心值：{round(prob*100, 2)}")
+    print(f"⚠️ 風險等級：{risk}")
+    print(f"可疑關鍵字擷取: {suspicious}")
+
+    return {
+        "status": label,
+        "confidence": round(prob * 100, 2),
+        "suspicious_keywords": suspicious,
+        "highlighted_text": highlighted_text 
+    }
+
+# 圖片 OCR 分析
+def analyze_image(file_bytes):
+    image = Image.open(io.BytesIO(file_bytes))
+    image_np = np.array(image)
+    results = reader.readtext(image_np)
+    
+    text = ' '.join([res[1] for res in results]).strip()
+    
+    if not text:
+        return {
+            "status" : "無法辨識文字",
+            "confidence" : 0.0,
+            "suspicious_keywords" : ["圖片中無可辨識的中文英文"],
+            "highlighted_text": "無法辨識可疑內容"
+        }
+    return analyze_text(text)