Upload 3 files

圖片驗證碼識別.py

@@ -0,0 +1,296 @@
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+from torch.amp import autocast, GradScaler
+from torchvision import transforms
+from datasets import load_dataset
+import numpy as np
+import string
+import math
+from tqdm import tqdm
+import os
+import json
+from torch.optim.lr_scheduler import LambdaLR
+# --- 1. 設定參數 ---
+class CFG:
+    # 資料集與字元集
+    dataset_name = "gary109/captcha-synth-v3"
+    characters = string.digits + string.ascii_lowercase + string.ascii_uppercase # '0123...abc...ABC...'
+    
+    # 圖片尺寸
+    img_width = 200
+    img_height = 50
+    
+    # 模型參數
+    d_model = 256  # Transformer 的特徵維度 (embedding dim)
+    nhead = 8      # Transformer 的多頭注意力頭數
+    num_encoder_layers = 4 # Transformer Encoder 的層數
+    dim_feedforward = 1024 # Transformer 前饋網路的維度
+    
+    # 訓練參數
+    epochs = 10
+    batch_size = 128
+    lr = 1e-4
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# --- 2. 資料準備 ---
+
+# PyTorch Dataset
+class CaptchaDataset(Dataset):
+    def __init__(self, hf_dataset,char_to_id, transform=None):
+        self.dataset = hf_dataset
+        self.transform = transform
+        self.char_to_id = char_to_id
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def __getitem__(self, idx):
+        item = self.dataset[idx]
+        image = item['image'].convert("L") # 轉為灰階
+        label = item['text']
+
+        if self.transform:
+            image = self.transform(image)
+        
+        # 將文字標籤轉換為數字序列
+        label_encoded = [self.char_to_id[char] for char in label]
+        
+        return image, torch.tensor(label_encoded, dtype=torch.long)
+
+# Dataloader 的 Collate Function，用於處理不同長度的標籤
+def collate_fn(batch):
+    images, labels = zip(*batch)
+    images = torch.stack(images, 0)
+    
+    # 對標籤進行填充
+    label_lengths = torch.tensor([len(label) for label in labels], dtype=torch.long)
+    padded_labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=0)
+    
+    return images, padded_labels, label_lengths
+
+# 定義圖像轉換
+transform = transforms.Compose([
+    transforms.Resize((CFG.img_height, CFG.img_width)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,)) # 歸一化
+])
+
+# --- 3. 模型架構 (CNN + Transformer) ---
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        x = x + self.pe[:x.size(0), :]
+        return self.dropout(x)
+
+class CaptchaTransformer(nn.Module):
+    def __init__(self, num_classes):
+        super(CaptchaTransformer, self).__init__()
+        # CNN Backbone
+        self.cnn = nn.Sequential(
+            nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(),
+            nn.AdaptiveMaxPool2d((1, None)),
+            nn.Conv2d(256, CFG.d_model, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(CFG.d_model),
+            nn.ReLU()
+        )
+        
+        self.pos_encoder = PositionalEncoding(CFG.d_model)
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=CFG.d_model, nhead=CFG.nhead, 
+            dim_feedforward=CFG.dim_feedforward, dropout=0.1
+        )
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=CFG.num_encoder_layers)
+        
+        # 輸出層
+        self.output_layer = nn.Linear(CFG.d_model, num_classes)
+
+    def forward(self, x):
+        # x shape: [batch_size, channels, height, width]
+        x = self.cnn(x)
+        # x shape: [batch_size, d_model, new_height, new_width]
+
+        # 準備 Transformer 輸入
+        # (W, N, E) -> (sequence_length, batch_size, embedding_dim)
+        x = x.squeeze(2) # 壓縮高度維度
+        x = x.permute(2, 0, 1) # [width, batch_size, d_model]
+        
+        x = self.pos_encoder(x)
+        x = self.transformer_encoder(x)
+        
+        # x shape: [width, batch_size, d_model]
+        output = self.output_layer(x)
+        
+        # CTC Loss 需要 log_softmax
+        return nn.functional.log_softmax(output, dim=2)
+
+# --- 4. 訓練與驗證 ---
+
+def greedy_decode(preds, id_to_char_map):
+    decoded_texts = []
+    # preds shape: [seq_len, batch_size, num_classes]
+    preds = preds.permute(1, 0, 2) # -> [batch_size, seq_len, num_classes]
+    pred_indices = torch.argmax(preds, dim=2)
+    
+    for indices in pred_indices:
+        text = []
+        last_char_id = 0
+        for char_id in indices:
+            char_id = char_id.item()
+            if char_id != 0 and char_id != last_char_id: # 忽略 blank 和連續重複
+                text.append(id_to_char_map[char_id])
+            last_char_id = char_id
+        decoded_texts.append("".join(text))
+    return decoded_texts
+char_to_id, id_to_char, VOCAB_SIZE = {}, {}, 0
+def main():
+    global char_to_id, id_to_char, VOCAB_SIZE
+    print(f"Using device: {CFG.device}")
+    
+    # 載入資料集
+    print("Loading dataset from Hugging Face Hub...")
+    train_hf_dataset = load_dataset(CFG.dataset_name, split="train")
+    
+    # 切分訓練集和驗證集
+    val_hf_dataset = load_dataset(CFG.dataset_name, split="validation")
+    print("Generating vocabulary from the dataset...")
+    vocab_path = "vocab.json"
+    if os.path.exists(vocab_path):
+        print(f"Loading vocabulary from {vocab_path}...")
+        with open(vocab_path, 'r', encoding='utf-8') as f:
+            characters = json.load(f)
+    else:
+        # 1. 遍歷數據集，收集所有字元到一個 set 中以確保唯一性
+        all_chars = set()
+        total_samples = len(train_hf_dataset) 
+        for i in tqdm(range(total_samples), desc="Scanning labels"):
+            label = train_hf_dataset[i]['text']
+            all_chars.update(list(label))
+        total_samples = len(val_hf_dataset) 
+        for i in tqdm(range(total_samples), desc="Scanning labels"):
+            label = val_hf_dataset[i]['text']
+            all_chars.update(list(label))
+        # 2. 將 set 轉換為排序後的 list，確保每次運行的順序都一樣
+        #    這對模型的可複現性至關重要！
+        characters = sorted(list(all_chars))
+        with open(vocab_path, 'w', encoding='utf-8') as f:
+            json.dump(characters, f, ensure_ascii=False, indent=2)
+        print(f"Vocabulary saved to {vocab_path}")
+    print(f"Unique characters found: {''.join(characters)}")
+    CFG.characters = "".join(characters) # 為了方便查看
+
+    # 建立字元對應 ID 的字典
+
+    char_to_id = {char: i + 1 for i, char in enumerate(CFG.characters)}
+    id_to_char = {i + 1: char for i, char in enumerate(CFG.characters)}
+    VOCAB_SIZE = len(CFG.characters) + 1  # +1 for CTC blank token at index 0
+    print(f"Total unique characters: {VOCAB_SIZE - 1}")
+    train_dataset = CaptchaDataset(train_hf_dataset,char_to_id=char_to_id, transform=transform)
+    val_dataset = CaptchaDataset(val_hf_dataset,char_to_id=char_to_id, transform=transform)
+    
+    train_loader = DataLoader(train_dataset, batch_size=CFG.batch_size, shuffle=True, collate_fn=collate_fn, num_workers=4)
+    val_loader = DataLoader(val_dataset, batch_size=CFG.batch_size, shuffle=False, collate_fn=collate_fn, num_workers=4)
+    
+    print(f"Train samples: {len(train_dataset)}, Val samples: {len(val_dataset)}")
+    # 初始化模型、損失函數、優化器
+    model = CaptchaTransformer(num_classes=VOCAB_SIZE).to(CFG.device)
+    criterion = nn.CTCLoss(blank=0, zero_infinity=True)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=CFG.lr)
+    warmup_steps = 1000
+    def warmup_lambda(current_step):
+        if current_step < warmup_steps:
+            # 在 warmup 期間，學習率從 0 線性增加到 1.0
+            return float(current_step) / float(max(1, warmup_steps))
+        # warmup 之後，學習率保持不變 (乘以 1.0)
+        return 1.0
+    scheduler = LambdaLR(optimizer, lr_lambda=warmup_lambda)
+    scaler = GradScaler()
+    # 訓練迴圈
+    for epoch in range(CFG.epochs):
+        model.train() # <<< 移到 Epoch 迴圈的開頭
+        train_loss = 0
+        loop = tqdm(train_loader, leave=True)
+        
+        for i, (images, labels, label_lengths) in enumerate(loop):
+            images = images.to(CFG.device)
+            labels = labels.to(CFG.device)
+            label_lengths = label_lengths.to(CFG.device)
+            
+            # <<< 1. 將 zero_grad 移到迴圈內，並使用 set_to_none=True
+            optimizer.zero_grad(set_to_none=True)
+            
+            # <<< 2. 將 autocast 只包裹前向傳播和損失計算
+            with autocast(device_type=CFG.device, dtype=torch.bfloat16):
+                preds = model(images)
+                input_lengths = torch.full(size=(preds.size(1),), fill_value=preds.size(0), dtype=torch.long)
+                loss = criterion(preds, labels, input_lengths, label_lengths)
+
+            # <<< 3. 後續的 scaler 操作和優化器步驟在 autocast 之外
+            scaler.scale(loss).backward()
+            scaler.unscale_(optimizer) # 在裁剪前 unscale 梯度
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
+            scaler.step(optimizer)
+            scaler.update()
+            
+            scheduler.step() # 每一步都要更新學習率
+            
+            train_loss += loss.item()
+            loop.set_description(f"Epoch [{epoch+1}/{CFG.epochs}]")
+            loop.set_postfix(loss=loss.item(), lr=optimizer.param_groups[0]['lr'])
+                
+        # 驗證迴圈
+        model.eval()
+        correct_predictions = 0
+        total_predictions = 0
+        is_printed = False
+        with torch.no_grad():
+            for images, labels, label_lengths in tqdm(val_loader, desc="Validation", leave=True):
+                with autocast(device_type=CFG.device, dtype=torch.bfloat16):
+                    images = images.to(CFG.device)
+                    preds = model(images)
+                
+                decoded_preds = greedy_decode(preds, id_to_char)
+                # 將 padded labels 轉回文字
+                original_texts = []
+                for label, length in zip(labels, label_lengths):
+                    original_texts.append("".join([id_to_char[l.item()] for l in label[:length]]))
+                
+                for pred, target in zip(decoded_preds, original_texts):
+                    if not is_printed:
+                        print(pred,target)
+                        is_printed = True
+                    if pred == target:
+                        correct_predictions += 1
+                    total_predictions += 1
+        
+        accuracy = correct_predictions / total_predictions
+        print(f"Epoch {epoch+1}, Train Loss: {train_loss/len(train_loader):.4f}, Val Accuracy: {accuracy:.4f}")
+        
+    # 保存模型
+    torch.save(model.state_dict(), "captcha_transformer.pth")
+    print("Model saved to captcha_transformer.pth")
+
+
+if __name__ == "__main__":
+    main()

微調驗證碼識別模型.py

@@ -0,0 +1,248 @@
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch.amp import autocast, GradScaler
+from torchvision import transforms
+from datasets import load_dataset
+import numpy as np
+import string
+import math
+from tqdm import tqdm
+import os
+import json
+
+# ===================================================================
+# 幾乎所有的定義都和原檔案一樣，可以直接複製過來
+# 這樣能確保權重可以被正確載入
+# ===================================================================
+
+# --- 1. 設定參數 (微調專用) ---
+class CFG_FINETUNE:
+    # 載入的模型和詞表路徑
+    model_path = "captcha_transformer_best_finetune.pth" # 確保這是你保存的最佳模型檔名
+    vocab_path = "vocab.json"
+    
+    # 資料集 (保持不變)
+    dataset_name = "gary109/captcha-synth-v3"
+    
+    # 圖片尺寸 (保持不變)
+    img_width = 200
+    img_height = 50
+    
+    # 模型參數 (必須和原模型完全一致！)
+    d_model = 256
+    nhead = 8
+    num_encoder_layers = 4
+    dim_feedforward = 1024
+    
+    # 微調參數 (這是關鍵！)
+    epochs = 5  # 微調通常不需要太多輪
+    batch_size = 32
+    lr = 1e-5   # <<< 使用一個更小的學習率！
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# --- 2. 需要用到的類別和函數 (從原檔案複製) ---
+# (為了讓此腳本能獨立運行，我們把所有必要的定義都複製過來)
+
+class CaptchaDataset(Dataset):
+    def __init__(self, hf_dataset, char_to_id, transform=None):
+        self.dataset = hf_dataset
+        self.transform = transform
+        self.char_to_id = char_to_id
+    def __len__(self):
+        return len(self.dataset)
+    def __getitem__(self, idx):
+        item = self.dataset[idx]
+        image = item['image'].convert("L")
+        label = item.get('label') or item.get('text')
+        if self.transform:
+            image = self.transform(image)
+        label_encoded = [self.char_to_id[char] for char in label]
+        return image, torch.tensor(label_encoded, dtype=torch.long)
+
+def collate_fn(batch):
+    images, labels = zip(*batch)
+    images = torch.stack(images, 0)
+    label_lengths = torch.tensor([len(label) for label in labels], dtype=torch.long)
+    padded_labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=0)
+    return images, padded_labels, label_lengths
+
+transform = transforms.Compose([
+    # 輕微的幾何扭曲，模擬字元黏連和變形
+    transforms.RandomAffine(
+        degrees=8,           # 隨機旋轉 ±8 度
+        translate=(0.1, 0.1),  # 隨機平移 10%
+        scale=(0.9, 1.1),    # 隨機縮放 10%
+        shear=5              # 隨機錯切
+    ),
+    transforms.RandomPerspective(distortion_scale=0.2, p=0.5), # 隨機透視變換
+    # 調整大小
+    transforms.Resize((CFG_FINETUNE.img_height, CFG_FINETUNE.img_width)),
+    # 顏色抖動
+    transforms.ColorJitter(brightness=0.4, contrast=0.4),
+    # 轉換為 Tensor
+    transforms.ToTensor(),
+    # 隨機擦除 (關鍵！)，模擬干擾線或字元斷裂
+    # 注意：這個操作必須在 ToTensor 之後
+    transforms.RandomErasing(p=0.5, scale=(0.02, 0.1), ratio=(0.3, 3.3), value=0),
+    # 歸一化
+    transforms.Normalize((0.5,), (0.5,))
+])
+val_transform = transforms.Compose([
+    transforms.Resize((CFG_FINETUNE.img_height, CFG_FINETUNE.img_width)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+class PositionalEncoding(nn.Module):
+    # ... (從原檔案完整複製 PositionalEncoding 的程式碼)
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+        self.register_buffer('pe', pe)
+    def forward(self, x):
+        x = x + self.pe[:x.size(0), :]
+        return self.dropout(x)
+
+class CaptchaTransformer(nn.Module):
+    # ... (從原檔案完整複製 CaptchaTransformer 的程式碼)
+    def __init__(self, num_classes):
+        super(CaptchaTransformer, self).__init__()
+        self.cnn = nn.Sequential(
+            nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(256), nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(),
+            nn.AdaptiveMaxPool2d((1, None)),
+            nn.Conv2d(256, CFG_FINETUNE.d_model, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(CFG_FINETUNE.d_model), nn.ReLU()
+        )
+        self.pos_encoder = PositionalEncoding(CFG_FINETUNE.d_model)
+        encoder_layer = nn.TransformerEncoderLayer(d_model=CFG_FINETUNE.d_model, nhead=CFG_FINETUNE.nhead, dim_feedforward=CFG_FINETUNE.dim_feedforward, dropout=0.1)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=CFG_FINETUNE.num_encoder_layers)
+        self.output_layer = nn.Linear(CFG_FINETUNE.d_model, num_classes)
+    def forward(self, x):
+        x = self.cnn(x)
+        x = x.squeeze(2)
+        x = x.permute(2, 0, 1)
+        x = self.pos_encoder(x)
+        x = self.transformer_encoder(x)
+        output = self.output_layer(x)
+        return nn.functional.log_softmax(output, dim=2)
+
+def greedy_decode(preds, id_to_char_map):
+    # ... (從原檔案完整複製 greedy_decode 的程式碼)
+    decoded_texts = []
+    preds = preds.permute(1, 0, 2)
+    pred_indices = torch.argmax(preds, dim=2)
+    for indices in pred_indices:
+        text = []
+        last_char_id = 0
+        for char_id in indices:
+            char_id = char_id.item()
+            if char_id != 0 and char_id != last_char_id:
+                text.append(id_to_char_map[char_id])
+            last_char_id = char_id
+        decoded_texts.append("".join(text))
+    return decoded_texts
+
+# --- 3. 微調主程式 ---
+def finetune():
+    print(f"Starting fine-tuning process on device: {CFG_FINETUNE.device}")
+
+    # --- 載入詞表 ---
+    with open(CFG_FINETUNE.vocab_path, 'r', encoding='utf-8') as f:
+        characters = json.load(f)
+    
+    char_to_id = {char: i + 1 for i, char in enumerate(characters)}
+    id_to_char = {i + 1: char for i, char in enumerate(characters)}
+    VOCAB_SIZE = len(characters) + 1
+    print(f"Vocabulary loaded. Size: {VOCAB_SIZE - 1}")
+
+    # --- 準備資料 ---
+    print("Loading dataset for fine-tuning...")
+    train_hf_dataset = load_dataset(CFG_FINETUNE.dataset_name, split="train")
+    val_hf_dataset = load_dataset(CFG_FINETUNE.dataset_name, split="validation")
+    train_dataset = CaptchaDataset(train_hf_dataset, char_to_id, transform=transform)
+    val_dataset = CaptchaDataset(val_hf_dataset, char_to_id, transform=val_transform)
+    train_loader = DataLoader(train_dataset, batch_size=CFG_FINETUNE.batch_size, shuffle=True, collate_fn=collate_fn, num_workers=8,pin_memory=True)
+    val_loader = DataLoader(val_dataset, batch_size=CFG_FINETUNE.batch_size*8, shuffle=False, collate_fn=collate_fn, num_workers=8,pin_memory=True)
+    
+    # --- 關鍵步驟：初始化模型並載入預訓練權重 ---
+    model = CaptchaTransformer(num_classes=VOCAB_SIZE).to(CFG_FINETUNE.device)
+    print(f"Loading pre-trained weights from: {CFG_FINETUNE.model_path}")
+    model.load_state_dict(torch.load(CFG_FINETUNE.model_path, map_location=CFG_FINETUNE.device))
+    print("Weights loaded successfully.")
+    
+    # --- 設定新的優化器和學習率排程器 ---
+    optimizer = torch.optim.AdamW(model.parameters(), lr=CFG_FINETUNE.lr)
+    scaler = GradScaler()
+    
+    # 使用餘弦退火學習率排程器
+    total_steps = len(train_loader) * CFG_FINETUNE.epochs
+    scheduler = CosineAnnealingLR(optimizer, T_max=total_steps, eta_min=1e-11) # 讓學習率平滑下降到接近0
+    
+    best_accuracy = 0.8979 # <<< 從你已知的最佳準確率開始！
+    
+    # --- 微調迴圈 ---
+    for epoch in range(CFG_FINETUNE.epochs):
+        model.train()
+        train_loss = 0
+        loop = tqdm(train_loader, leave=True)
+        
+        for i, (images, labels, label_lengths) in enumerate(loop):
+            images, labels, label_lengths = images.to(CFG_FINETUNE.device), labels.to(CFG_FINETUNE.device), label_lengths.to(CFG_FINETUNE.device)
+            optimizer.zero_grad(set_to_none=True)
+            
+            with autocast(device_type=CFG_FINETUNE.device, dtype=torch.bfloat16):
+                preds = model(images)
+                input_lengths = torch.full(size=(preds.size(1),), fill_value=preds.size(0), dtype=torch.long)
+                loss = nn.CTCLoss(blank=0, zero_infinity=True)(preds, labels, input_lengths, label_lengths)
+
+            scaler.scale(loss).backward()
+            scaler.unscale_(optimizer)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
+            scaler.step(optimizer)
+            scaler.update()
+            scheduler.step() # 更新學習率
+            
+            train_loss += loss.item()
+            loop.set_description(f"Fine-tune Epoch [{epoch+1}/{CFG_FINETUNE.epochs}]")
+            loop.set_postfix(loss=loss.item(), lr=optimizer.param_groups[0]['lr'])
+        
+        # 驗證迴圈
+        model.eval()
+        correct_predictions, total_predictions = 0, 0
+        with torch.no_grad():
+            for images, labels, label_lengths in tqdm(val_loader, desc="Validation"):
+                images = images.to(CFG_FINETUNE.device)
+                with autocast(device_type=CFG_FINETUNE.device, dtype=torch.bfloat16):
+                    preds = model(images)
+                
+                decoded_preds = greedy_decode(preds, id_to_char)
+                original_texts = ["".join([id_to_char[l.item()] for l in label[:length]]) for label, length in zip(labels, label_lengths)]
+                
+                for pred, target in zip(decoded_preds, original_texts):
+                    if pred == target:
+                        correct_predictions += 1
+                    total_predictions += 1
+        
+        accuracy = correct_predictions / total_predictions
+        print(f"Epoch {epoch+1}, Train Loss: {train_loss/len(train_loader):.4f}, Val Accuracy: {accuracy:.4f}")
+
+        # 保存更好的模型
+        if accuracy > best_accuracy:
+            best_accuracy = accuracy
+            # 使用一個新的檔名，避免覆蓋原始的最佳模型
+            torch.save(model.state_dict(), "captcha_transformer_best_finetune.pth")
+            print(f"🎉 New best fine-tuned model saved with accuracy: {best_accuracy:.4f}")
+
+if __name__ == "__main__":
+    finetune()

找錯誤識別圖片.py

@@ -0,0 +1,311 @@
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+from torch.amp import autocast
+from torchvision import transforms
+from datasets import load_dataset
+import os
+import json
+import math
+from tqdm import tqdm
+import re
+from collections import Counter
+import Levenshtein
+from torchvision.transforms import functional as F
+from PIL import Image
+# ===================================================================
+# 這是一個獨立腳本，所以我們從之前的檔案複製所有必要的定義
+# ===================================================================
+
+# --- 1. 設定參數 ---
+class CFG_ANALYSIS:
+    # 載入的模型和詞表路徑 (使用你微調後的最佳模型)
+    model_path = "captcha_transformer_best_finetune.pth"
+    vocab_path = "vocab.json"
+    
+    # 資料集 (使用驗證集)
+    dataset_name = "gary109/captcha-synth-v3"
+    
+    # 儲存錯誤圖片的資料夾
+    output_dir = "error_analysis_results"
+    
+    # 模型參數 (必須和訓練時完全一致！)
+    d_model = 256
+    nhead = 8
+    num_encoder_layers = 4
+    dim_feedforward = 1024
+    img_width = 200
+    img_height = 50
+    
+    # 推理參數
+    batch_size = 1024 # 推理時可以使用更大的 batch size 來加速
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# --- 2. 必要的類別和函數 (從原檔案複製) ---
+
+class CaptchaDataset(Dataset):
+    def __init__(self, hf_dataset, char_to_id, transform=None):
+        self.dataset = hf_dataset
+        self.transform = transform
+        self.char_to_id = char_to_id
+    def __len__(self):
+        return len(self.dataset)
+    def __getitem__(self, idx):
+        item = self.dataset[idx]
+        image = item['image'].convert("L")
+        label = item.get('label') or item.get('text')
+        if self.transform:
+            image = self.transform(image)
+        label_encoded = [self.char_to_id[char] for char in label]
+        return image, torch.tensor(label_encoded, dtype=torch.long)
+
+def collate_fn(batch):
+    images, labels = zip(*batch)
+    images = torch.stack(images, 0)
+    label_lengths = torch.tensor([len(label) for label in labels], dtype=torch.long)
+    padded_labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=0)
+    return images, padded_labels, label_lengths
+class PadAndResize:
+    """
+    一個自定義的 transform，它會將圖片縮放到指定的尺寸，同時保持原始長寬比。
+    不足的部分會用指定的顏色進行填充 (padding)。
+    """
+    def __init__(self, output_size, fill=0):
+        """
+        :param output_size: (height, width) 的元組
+        :param fill: 用於填充的像素值 (0=黑色, 255=白色)
+        """
+        self.output_size = output_size
+        self.fill = fill
+
+    def __call__(self, img):
+        # 獲取目標尺寸和原始尺寸
+        target_h, target_w = self.output_size
+        original_w, original_h = img.size
+
+        # 計算長寬比
+        target_ratio = target_w / target_h
+        original_ratio = original_w / original_h
+
+        if original_ratio > target_ratio:
+            # 原始圖片比目標更「寬」，以寬度為基準進行縮放
+            new_w = target_w
+            new_h = int(new_w / original_ratio)
+            img = F.resize(img, (new_h, new_w))
+            
+            # 計算需要填充的高度
+            pad_h = target_h - new_h
+            # 上下各填充一半
+            padding = (0, pad_h // 2, 0, target_h - new_h - (pad_h // 2))
+        else:
+            # 原始圖片比目標更「高」或長寬比相同，以高度為基準進行縮放
+            new_h = target_h
+            new_w = int(new_h * original_ratio)
+            img = F.resize(img, (new_h, new_w))
+
+            # 計算需要填充的寬度
+            pad_w = target_w - new_w
+            # 左右各填充一半
+            padding = (pad_w // 2, 0, target_w - new_w - (pad_w // 2), 0)
+        
+        # 應用填充
+        return F.pad(img, padding, self.fill)
+transform = transforms.Compose([
+    PadAndResize((CFG_ANALYSIS.img_height, CFG_ANALYSIS.img_width), fill=0),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+        self.register_buffer('pe', pe)
+    def forward(self, x):
+        x = x + self.pe[:x.size(0), :]
+        return self.dropout(x)
+
+class CaptchaTransformer(nn.Module):
+    def __init__(self, num_classes):
+        super(CaptchaTransformer, self).__init__()
+        self.cnn = nn.Sequential(
+            nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(256), nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(),
+            nn.AdaptiveMaxPool2d((1, None)),
+            nn.Conv2d(256, CFG_ANALYSIS.d_model, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(CFG_ANALYSIS.d_model), nn.ReLU()
+        )
+        self.pos_encoder = PositionalEncoding(CFG_ANALYSIS.d_model)
+        encoder_layer = nn.TransformerEncoderLayer(d_model=CFG_ANALYSIS.d_model, nhead=CFG_ANALYSIS.nhead, dim_feedforward=CFG_ANALYSIS.dim_feedforward, dropout=0.1)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=CFG_ANALYSIS.num_encoder_layers)
+        self.output_layer = nn.Linear(CFG_ANALYSIS.d_model, num_classes)
+    def forward(self, x):
+        x = self.cnn(x)
+        x = x.squeeze(2)
+        x = x.permute(2, 0, 1)
+        x = self.pos_encoder(x)
+        x = self.transformer_encoder(x)
+        output = self.output_layer(x)
+        return nn.functional.log_softmax(output, dim=2)
+
+def greedy_decode(preds, id_to_char_map):
+    decoded_texts = []
+    preds = preds.permute(1, 0, 2)
+    pred_indices = torch.argmax(preds, dim=2)
+    for indices in pred_indices:
+        text = []
+        last_char_id = 0
+        for char_id in indices:
+            char_id = char_id.item()
+            if char_id != 0 and char_id != last_char_id:
+                text.append(id_to_char_map[char_id])
+            last_char_id = char_id
+        decoded_texts.append("".join(text))
+    return decoded_texts
+
+# --- 3. 錯誤分析主程式 ---
+def analyze_errors():
+    print("--- Starting Quantitative Error Analysis ---")
+    
+    # --- 準備工作 (和之前一樣) ---
+    CFG_ANALYSIS.output_dir = "error_analysis_v2_results"
+    os.makedirs(CFG_ANALYSIS.output_dir, exist_ok=True)
+    
+    with open(CFG_ANALYSIS.vocab_path, 'r', encoding='utf-8') as f:
+        characters = json.load(f)
+    id_to_char = {i + 1: char for i, char in enumerate(characters)}
+    VOCAB_SIZE = len(characters) + 1
+
+    val_hf_dataset = load_dataset(CFG_ANALYSIS.dataset_name, split="validation")
+    char_to_id = {c: i + 1 for i, c in enumerate(characters)}
+    val_torch_dataset = CaptchaDataset(val_hf_dataset, char_to_id, transform=transform)
+    val_loader = DataLoader(val_torch_dataset, batch_size=CFG_ANALYSIS.batch_size, shuffle=False, collate_fn=collate_fn,num_workers=8,pin_memory=True)
+
+    model = CaptchaTransformer(num_classes=VOCAB_SIZE).to(CFG_ANALYSIS.device)
+    model.load_state_dict(torch.load(CFG_ANALYSIS.model_path, map_location=CFG_ANALYSIS.device))
+    model.eval()
+    print("Model loaded successfully.")
+    
+    error_counts = Counter()
+    confusion_matrix = {char: Counter() for char in characters}
+
+    # --- 準備 list 來收集所有批次的結果 ---
+    all_preds_list = []
+    all_labels_list = []
+    all_label_lengths_list = []
+    all_indices_list = [] # <<< 新增：記錄每個樣本的原始索引
+
+    # ==========================================================
+    # ============[ Phase 1: GPU-Intensive Pass ]============
+    # ==========================================================
+    # 這個迴圈只負責模型推理，速度會非常快
+    with torch.no_grad():
+        for batch_idx, (images, labels, label_lengths) in enumerate(tqdm(val_loader, desc="Phase 1: GPU Inference")):
+            images = images.to(CFG_ANALYSIS.device)
+            with autocast(device_type=CFG_ANALYSIS.device, dtype=torch.bfloat16):
+                preds = model(images)
+            
+            # 將結果從 GPU 移至 CPU RAM 並儲存
+            all_preds_list.append(preds.cpu())
+            all_labels_list.append(labels)
+            all_label_lengths_list.append(label_lengths)
+            
+            # 記錄這個批次中每個樣本的原始索引
+            start_idx = batch_idx * CFG_ANALYSIS.batch_size
+            end_idx = start_idx + len(images)
+            all_indices_list.extend(range(start_idx, end_idx))
+
+    # ==========================================================
+    # ============[ Phase 2: CPU-Intensive Analysis ]===========
+    # ==========================================================
+    # 現在 GPU 已完成工作，我們在 CPU 上一次性處理所有收集到的結果
+    print("\nPhase 2: Analyzing results on CPU...")
+
+    # 1. 預測結果 (preds) 的序列長度是固定的，所��可以安全地合併
+    all_preds_tensor = torch.cat(all_preds_list, dim=1)
+    decoded_preds = greedy_decode(all_preds_tensor, id_to_char)
+
+    # 2. 標籤 (labels) 的長度是可變的，所以我們需要逐個批次處理
+    original_texts = []
+    for labels, label_lengths in zip(all_labels_list, all_label_lengths_list):
+        batch_texts = ["".join([id_to_char[l.item()] for l in label[:length]]) for label, length in zip(labels, label_lengths)]
+        original_texts.extend(batch_texts)
+
+    # 現在，我們在 CPU 上迴圈處理結果，進行分類和存檔
+    for i in tqdm(range(len(decoded_preds)), desc="Phase 2: Classifying errors and saving files"):
+        pred = decoded_preds[i]
+        target = original_texts[i]
+        
+        if pred != target:
+            # --- 錯誤分類和統計 (和之前一樣) ---
+            error_type = "unknown"
+            if len(pred) != len(target):
+                error_type = "length_mismatch"
+            else:
+                distance = Levenshtein.distance(pred, target)
+                if distance == 1:
+                    error_type = "substitution"
+                    for j in range(len(pred)):
+                        if pred[j] != target[j]:
+                            confusion_matrix[target[j]][pred[j]] += 1
+                            break
+                elif distance > 1:
+                    error_type = "complex_error"
+            error_counts[error_type] += 1
+            
+            # --- 存檔 (和之前一樣，但使用記錄好的索引) ---
+            error_dir = os.path.join(CFG_ANALYSIS.output_dir, error_type)
+            os.makedirs(error_dir, exist_ok=True)
+            
+            original_idx = all_indices_list[i]
+            original_pil_image = val_hf_dataset[original_idx]['image']
+            
+            pred_sanitized = re.sub(r'[\\/*?:"<>|]', "", pred) or "EMPTY"
+            target_sanitized = re.sub(r'[\\/*?:"<>|]', "", target)
+            filename = f"idx{original_idx}_pred_{pred_sanitized}_target_{target_sanitized}.png"
+            filepath = os.path.join(error_dir, filename)
+            original_pil_image.save(filepath)
+
+    # --- 3. 生成並打印統計報告 ---
+    total_errors = sum(error_counts.values())
+    report = "--- Error Analysis Report ---\n\n"
+    report += f"Total Errors Found: {total_errors}\n\n"
+    report += "Error Type Distribution:\n"
+    for error_type, count in error_counts.most_common():
+        percentage = (count / total_errors) * 100
+        report += f"- {error_type:<20}: {count:>5} errors ({percentage:.2f}%)\n"
+    
+    # 找出最常見的15個替換錯誤
+    substitution_pairs = []
+    for target_char, preds in confusion_matrix.items():
+        for pred_char, count in preds.items():
+            if count > 0:
+                substitution_pairs.append(((target_char, pred_char), count))
+    
+    # 按數量排序
+    top_15_substitutions = sorted(substitution_pairs, key=lambda item: item[1], reverse=True)[:15]
+
+    report += "\n\nTop 15 Character Substitution Errors (Target -> Prediction):\n"
+    for (target, pred), count in top_15_substitutions:
+        report += f"- '{target}' -> '{pred}': {count:>5} times\n"
+
+    print("\n" + report)
+    
+    # 將報告寫入檔案
+    with open(os.path.join(CFG_ANALYSIS.output_dir, "report.txt"), "w", encoding="utf-8") as f:
+        f.write(report)
+        
+    print(f"\nAnalysis complete. Report saved to '{os.path.join(CFG_ANALYSIS.output_dir, 'report.txt')}'")
+    print("You can now review the categorized images in the results folder.")
+
+if __name__ == "__main__":
+    analyze_errors()