Upload 4 files

AI_Model_architecture.py

@@ -0,0 +1,324 @@
+"""
+流程圖
+讀取資料 → 分割資料 → 編碼 → 建立 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
+
+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 環境變數 -------------------
+load_dotenv()
+base_dir = os.getenv("DATA_DIR", "./data")  # 如果沒設環境變數就預設用 ./data
+
+# ------------------- 使用相對路徑找 CSV -------------------
+#,os.path.join(base_dir, "NorANDScamInfo_data1.csv"),os.path.join(base_dir, "ScamInfo_data1.csv"),os.path.join(base_dir, "NormalInfo_data1.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):
+        #載入 CSV 並清理 message 欄位。
+        df = pd.read_csv(filepath)
+        df = df.dropna().drop_duplicates().reset_index(drop=True)
+        # 文字清理:移除空白、保留中文英數與標點
+        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))
+        return df[["message", "label"]]  # 保留必要欄位
+
+    def encode(self, messages):
+        #使用 HuggingFace BERT Tokenizer 將訊息編碼成Bert模型輸入格式。
+        return self.tokenizer(
+            list(messages),
+            return_tensors="pt",
+            truncation=True,
+            padding="max_length",
+            max_length=self.max_len
+        )
+#自動做資料前處理
+def build_bert_inputs(files):
+    #將正常與詐騙資料分別指定 label,統一清理、編碼,回傳模型可用的 input tensors 與 labels。
+    processor = BertPreprocessor()
+    dfs = []
+    # 合併正常 + 詐騙檔案清單
+    all_files = files
+
+    for filepath in all_files:
+        df = processor.load_and_clean(filepath)
+        dfs.append(df)
+    
+    # 合併所有資料。在資料清理過程中dropna():刪除有空值的列,drop_duplicates():刪除重複列,filter()或df[...]做條件過濾,concat():將多個 DataFrame合併
+    # 這些操作不會自動重排索引,造成索引亂掉。
+    # 合併後統一編號(常見於多筆資料合併)all_df = pd.concat(dfs, 關鍵-->ignore_index=True)
+    all_df = pd.concat(dfs, ignore_index=True)
+    print(f"✅ 已讀入 {len(all_df)} 筆資料")
+    print(all_df["label"].value_counts())
+    #製作 train/val 資料集
+    train_texts, val_texts, train_labels, val_labels = train_test_split(
+    all_df["message"], all_df["label"],
+    stratify=all_df["label"],
+    test_size=0.2,
+    random_state=25,
+    shuffle=True
+    )
+    # 進行 BERT tokenizer 編碼
+    train_inputs = processor.encode(train_texts)
+    val_inputs = processor.encode(val_texts)
+
+    return train_inputs, train_labels, val_inputs, val_labels, 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(base_dir, "NorANDScamInfo_data3k.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=8)
+    val_loader = DataLoader(val_dataset, batch_size=8)
+"""
+
+
+"""
+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 torch.sigmoid(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)
+criterion = nn.BCELoss()
+
+# 本機訓練迴圈,要訓練再取消註解,否則在線上版本一律處於註解狀態
+
+if __name__ == "__main__": # 只有當我「直接執行這個檔案」時,才執行以下訓練程式(不是被別人 import 使用時)。
+    if os.path.exists("model.pth"):
+        print("✅ 已找到 model.pth,載入模型跳過訓練")
+        model.load_state_dict(torch.load("model.pth", map_location=device))
+    else:
+        print("🚀 未找到 model.pth,開始訓練模型...")
+        num_epochs = 15 # batch_size設定在train_loader和test_loader那
+        for epoch in range(num_epochs):
+            model.train() # 從nn.Module繼承的方法。將模型設為「訓練模式」,有些層(像 Dropout 或 BatchNorm)會啟用訓練行為。
+            total_loss = 0.0
+            for batch in train_loader:
+            
+                # 清理舊梯度,以免累加。為甚麼要?因為PyTorch 預設每次呼叫 .backward() 都會「累加」梯度(不會自動清掉)
+                # 沒 .zero_grad(),梯度會越累積越多,模型會亂掉。
+                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) # 比較 預測結果 outputs(Sigmoid 的機率)和 真實答案 labels
+                
+                # 用鏈式法則(Chain Rule)計算每一層「參數對 loss 的影響」,也就是梯度
+                # PyTorch 利用自動微分(autograd)幫你計算整個計算圖的偏導數,然後存在每一層的 .grad 裡。
+                loss.backward()
+                
+                # 用 .grad 中的梯度資訊根
+                # 據學習率和優化器的規則
+                # 改變每一個參數的值,以讓下一次預測更接近真實
+                optimizer.step()
+                
+                # loss 是一個 tensor(需要 backward);.item() 把它轉成 Python 的純數字(float)
+                total_loss += loss.item()
+            print(f"[Epoch{epoch+1}]Training Loss:{total_loss:.4f}")
+        torch.save(model.state_dict(), "model.pth")# 儲存模型權重
+        print("✅ 模型訓練完成並儲存為 model.pth")
+"""
+
+"""
+整個模型中每一個文字(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 抽出的新特徵)
+
+"""

Gradio_app.py

@@ -0,0 +1,25 @@
+import gradio as gr
+from bert_explainer import analyze_text
+
+def predict_fn(text, mode):
+    result = analyze_text(text=text, explain_mode=mode)
+    status = result['status']
+    confidence = f"{result['confidence']}%"
+    keywords = ', '.join(result['suspicious_keywords'])
+    return status, confidence, keywords
+
+iface =gr.Interface(
+    fn=predict_fn,
+    inputs = [
+        gr.TextArea(label="輸入訊息"),
+        gr.Radio(choices=["cnn", "bert", "both"], label="分析模式", value="cnn")
+    ],
+    outputs = [
+        gr.Textbox(label = "判斷結果"),
+        gr.Textbox(label = "可疑分數"),
+        gr.Textbox(label = "可疑詞彙")
+    ],
+    title= "預判詐騙訊息",
+    description="輸入訊息，AI 將判定是否為詐騙並標記可疑詞  "
+)
+iface.launch()

bert_explainer.py

@@ -0,0 +1,267 @@
+
+# 引入重要套件Import Library
+# PyTorch 主模組，和Tensorflow很像 
+# 共通點：都是深度學習框架，支援建構神經網路、訓練與推論，都支援GPU加速、載入模型，和處理tensor等。
+# 操作比較直覺，接近Python本身的風格，動態圖架構(每一次forward都即時計算)，更容易除錯、快速迭代，在研究領域非常流行。
+# re是Python內建的正則表示式(regular expression)模組，在這專案中用來"用關鍵規則篩選文字內容"。
+# requests是一個非常好用的 HTTP 請求套件，能讓你從Python發送GET/POST請求，在專案中用來從Google Drive下載模型檔案(model.pth)。
+# BertTokenizer:從Hugging Face的transformers套件載入一個專用的「分詞器（Tokenizer）」。
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+
+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
+
+
+
+
+# 設定裝置（GPU 優先）
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# 預設模型與 tokenizer 為 None，直到首次請求才載入（延遲載入）
+model = None
+tokenizer = None
+# ✅ 延遲載入模型與 tokenizer
+def load_model_and_tokenizer():
+    global model, tokenizer
+    if os.path.exists("model.pth"):
+        model_path = "model.pth"
+    else:
+        model_path = hf_hub_download(repo_id="Bennie12/Bert-Lstm-Cnn-ScamDetecter", filename="model.pth")
+    # 匯入模型架構（避免在模組初始化階段就占用大量記憶體）
+    from AI_Model_architecture import BertLSTM_CNN_Classifier
+    """
+      file_id = "19t6NlRFMc1i8bGtngRwIRtRcCmibdP9q"
+    
+    url = f"https://drive.google.com/uc?export=download&id={file_id}"  
+    if not os.path.exists(model_path):   # 如果本地還沒有這個檔案 → 才下載（避免重複）
+            print("📥 Downloading model from Google Drive...")
+            r = requests.get(url)             # 用requests發送GET請求到Google Drive
+            with open(model_path, 'wb')as f: # 把下載的檔案內容寫入到 model.pth 本地檔案
+                f.write(r.content)
+                print("✅ Model downloaded.")     
+    else:
+            print("📦 Model already exists.")
+    """
+    # 載入模型架構與參數，初始化模型架構並載入訓練權重
+    model = BertLSTM_CNN_Classifier()
+    
+    # 這行的功能是：「從 model_path把.pth 權重檔案讀進來，載入進模型裡」。
+    # model.load_state_dict(...)把上面載入的權重「套進模型架構裡」
+    # torch.load(...)載入.pth 權重檔案，會變成一份 Python 字典
+    # map_location=device指定模型載入到 CPU 還是 GPU，避免報錯
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    
+    model.to(device)
+    
+    # 這是PyTorch中的「推論模式」設定
+    # model.eval()模型處於推論狀態（關掉 Dropout 等隨機操作）
+    # 只要是用來「預測」而不是訓練，一定要加 .eval()！
+    model.eval()
+
+    # 初始化 tokenizer(不要從 build_bert_inputs 中取)
+    # 載入預訓練好的CKIP中文BERT分詞器
+    # 能把中文句子轉成 BERT 模型需要的 input 格式（input_ids, attention_mask, token_type_ids）
+    tokenizer = BertTokenizer.from_pretrained("ckiplab/bert-base-chinese")
+
+    return model, tokenizer
+
+all_preds = []
+all_labels = []
+
+# 預測單一句子的分類結果（詐騙 or 正常）
+# model: 訓練好的PyTorch模型
+# tokenizer: 分詞器，負責把中文轉成 BERT 能處理的數值格式
+# sentence: 使用者輸入的文字句子
+# max_len: 限制最大輸入長度（預設 256 個 token）
+def predict_single_sentence(model, tokenizer, sentence, max_len=256):
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # 使用 with torch.no_grad()，代表這段程式「不需要記錄梯度」
+    # 這樣可以加速推論並節省記憶體
+    with torch.no_grad():
+         # ----------- 文字前處理：清洗輸入句子 -----------
+        sentence = re.sub(r"\s+", "", sentence)  # 移除所有空白字元（空格、換行等）
+        sentence = re.sub(r"[^\u4e00-\u9fffA-Za-z0-9。，！？]", "", sentence)
+        # 保留常見中文字、英數字與標點符號，其他奇怪符號都移除
+        # ----------- 使用 BERT Tokenizer 將句子編碼 -----------
+        encoded = tokenizer(sentence,
+                            return_tensors="pt",       # 回傳 PyTorch tensor 格式（預設是 numpy 或 list）
+                            truncation=True,           # 超過最大長度就截斷
+                            padding="max_length",      # 不足最大長度則補空白（PAD token）
+                            max_length=max_len)        # 設定最大長��為 256
+        # 把 tokenizer 回傳的資料送進模型前，to(device)轉到指定的裝置（GPU or CPU）
+        input_ids = encoded["input_ids"].to(device)
+        attention_mask = encoded["attention_mask"].to(device)
+        token_type_ids = encoded["token_type_ids"].to(device)
+        # ----------- 模型推論：輸出詐騙的機率值 -----------
+        output = model(input_ids, attention_mask, token_type_ids)# 回傳的是一個機率值（float）
+        prob = output.item()  # 從 tensor 取出純數字，例如 0.86
+        label = int(prob > 0.5)  # 如果機率 > 0.5，標為「詐騙」（1），否則為「正常」（0）
+        # ----------- 根據機率進行風險分級 -----------
+        if prob > 0.9:
+            risk = "🔴 高風險（極可能是詐騙）"
+        elif prob > 0.5:
+            risk = "🟡 中風險（可疑）"
+        else:
+            risk = "🟢 低風險（正常）"
+        # ----------- 根據 label 判斷文字結果 -----------
+        pre_label ='詐騙'if label == 1 else '正常'
+        # ----------- 顯示推論資訊（後端終端機） -----------
+        print(f"\n📩 訊息內容：{sentence}")
+        print(f"✅ 預測結果：{'詐騙' if label == 1 else '正常'}")
+        print(f"📊 信心值：{round(prob*100, 2)}")
+        print(f"⚠️ 風險等級：{risk}")
+        # ----------- 回傳結果給呼叫端（通常是 API） -----------
+        # 組成一個 Python 字典（對應 API 的 JSON 輸出格式）
+        return {
+        "label" : pre_label,                  # 預測分類（"詐騙" or "正常"）
+        "prob" : prob, # 預測分類（"詐騙" or "正常"）  
+        "risk" : risk     # 用風險分級當作"可疑提示"放進 list（名稱為 suspicious_keywords）
+    }
+
+# analyze_text(text)對應app.py第117行
+# 這個函式是「對外的簡化版本」：輸入一句文字 → 回傳詐騙判定結果
+# 用在主程式或 FastAPI 後端中，是整個模型預測流程的入口點
+
+
+#------------ CNN ------------
+def extract_suspicious_tokens_cnn(model, tokenizer, text, top_k=3):
+    model.eval()
+    model.to(device)
+
+    # 清理與編碼輸入文字
+    sentence = re.sub(r"\s+", "", text)
+    sentence = re.sub(r"[^\u4e00-\u9fffA-Za-z0-9。，！？]", "", sentence)
+
+    encoded = tokenizer(sentence,
+                        return_tensors="pt",
+                        truncation=True,
+                        padding="max_length",
+                        max_length=128)
+
+    input_ids = encoded["input_ids"].to(device)
+    attention_mask = encoded["attention_mask"].to(device)
+    token_type_ids = encoded["token_type_ids"].to(device)
+
+    # 前向傳遞直到 CNN 輸出
+    with torch.no_grad():
+        hidden_states = model.bert(input_ids=input_ids,
+                                   attention_mask=attention_mask,
+                                   token_type_ids=token_type_ids).last_hidden_state
+        lstm_out, _ = model.LSTM(hidden_states)
+        conv_input = lstm_out.transpose(1, 2)
+        conv_out = model.conv1(conv_input)  # conv_out = [batch, 128, seq_len]
+
+    # 這裡會將conv_out的輸出[batch, 128, seq_len]，壓縮成[seq_len]，也就是轉換成bert編碼形勢的句子。
+    token_scores = conv_out.mean(dim=1).squeeze()
+
+    # torch.topk(token_scores, top_k)會得到分數高的token，和對應索引位置，.indices只留下索引，.cpu()把結果從GPU移到CPU（必要才能轉為 list），
+    # .tolist()轉化成list格式。挑出重要性最高的幾個 token 的位置索引。
+    topk_indices = torch.topk(token_scores, top_k).indices.cpu().tolist()
+
+    """ 
+    tokenizer.convert_ids_to_tokens(input_ids.squeeze())將bert編碼還原成原始文字
+    這段input_ids = encoded["input_ids"].to(device)輸出的編碼，還原成文字
+    .squeeze() 去掉 batch 維度，得到 [seq_len]。
+    [tokens[i] for i in topk_indices if tokens[i] not in ["[PAD]", "[CLS]", "[SEP]"]]
+    上面的程式碼為，i為topk_indices挑出的索引，token[i]為分數最高的文字，也就是可疑的詞句。
+    not in 就能避免選到就能避免選到[CLS]、[SEP]、 [PAD]
+    [CLS] 開始符號 = 101
+    [SEP] 結束符號 = 102
+    [PAD] 補空白 = 0
+    """
+    tokens = tokenizer.convert_ids_to_tokens(input_ids.squeeze())
+    suspicious_tokens = [tokens[i] for i in topk_indices if tokens[i] not in ["[PAD]", "[CLS]", "[SEP]"]]
+
+    return suspicious_tokens
+
+
+#------------ Bert Attention ------------
+def extract_suspicious_tokens_attention(model, tokenizer, text, top_k=3):
+    from transformers import BertModel  # 避免重複 import
+
+    sentence = re.sub(r"\s+", "", text)
+    sentence = re.sub(r"[^\u4e00-\u9fffA-Za-z0-9。，！？]", "", sentence)
+
+    encoded = tokenizer(sentence,
+                        return_tensors="pt",
+                        truncation=True,
+                        padding="max_length",
+                        max_length=128)
+
+    input_ids = encoded["input_ids"].to(device)
+    attention_mask = encoded["attention_mask"].to(device)
+    token_type_ids = encoded["token_type_ids"].to(device)
+
+    with torch.no_grad():
+        bert_outputs = model.bert(input_ids=input_ids,
+                                  attention_mask=attention_mask,
+                                  token_type_ids=token_type_ids,
+                                  output_attentions=True)
+        # 取第一層第0個 head 的 attention（CLS → all tokens）
+        """
+        attentions[0]第 0 層 attention（BERT 第 1 層），[0, 0, 0, :]取出第 0 個 batch、第 0 個 head、第 0 個 token（CLS）對所有 token 的注意力分數
+        
+        """
+        attention_scores = bert_outputs.attentions[0][0, 0, 0, :]  # [seq_len]
+    
+    topk_indices = torch.topk(attention_scores, top_k).indices.cpu().tolist()
+    
+    tokens = tokenizer.convert_ids_to_tokens(input_ids.squeeze())
+    suspicious_tokens = [tokens[i] for i in topk_indices if tokens[i] not in ["[PAD]", "[CLS]", "[SEP]"]]
+
+    return suspicious_tokens
+
+
+
+def analyze_text(text, explain_mode="cnn"):
+    model, tokenizer = load_model_and_tokenizer()
+    model.eval()
+
+    # 預測標籤與信心分數
+    result = predict_single_sentence(model, tokenizer, text)
+    label = result["label"]
+    prob = result["prob"]
+    risk = result["risk"]
+    # 根據模式擷取可疑詞
+    if explain_mode == "cnn":
+        suspicious = extract_suspicious_tokens_cnn(model, tokenizer, text)
+    elif explain_mode == "bert":
+        suspicious = extract_suspicious_tokens_attention(model, tokenizer, text)
+    elif explain_mode == "both":
+        cnn_tokens = extract_suspicious_tokens_cnn(model, tokenizer, text)
+        bert_tokens = extract_suspicious_tokens_attention(model, tokenizer, text)
+        suspicious = list(set(cnn_tokens + bert_tokens))
+    else:
+        suspicious = [risk]
+
+    return {
+        "status": label,
+        "confidence": round(prob * 100, 2),
+        "suspicious_keywords": [str(s) for s in suspicious]
+    }
+
+def analyze_image(file_bytes, explain_mode = "cnn"):
+    image = Image.open(io.BytesIO(file_bytes))
+    image_np = np.array(image)
+    reader = easyocr.Reader(['ch_tra', 'en'], gpu=torch.cuda.is_available())
+    results = reader.readtext(image_np)
+    
+    text = ' '.join([res[1] for res in results]).strip()
+    
+    if not text:
+        return{
+            "status" : "無法辨識文字",
+            "confidence" : 0.0,
+            "suspicious_keywords" : ["圖片中無可辨識的中文英文"]
+        }
+    return analyze_text(text, explain_mode=explain_mode)

requirements.txt

@@ -0,0 +1,20 @@
+fastapi#==0.104.1
+uvicorn#==0.24.0
+python-multipart#==0.0.6
+firebase-admin#==6.2.0
+pandas#==2.1.3
+python-jose#==3.3.0
+pydantic#==2.5.2
+python-dotenv#==1.0.0
+transformers
+torch
+requests
+scikit-learn#==1.3.2
+python-dotenv
+aiofiles
+easyocr
+Pillow
+numpy
+gradio
+
+huggingface_hub