Enhance training process with improved early stopping and metrics tracking. Update README with training results and insights. Modify .gitignore to allow Metrics plots. Add plotting functionality for inference results in plotting.py. Update configuration parameters for CAPTCHA length limits.

.gitignore

@@ -66,7 +66,7 @@ logs/
 Thumbs.db
 desktop.ini
 
-# Images/artifacts
+# Images/artifacts (but allow Metrics plots)
 *.png
 *.jpg
 *.jpeg
@@ -75,6 +75,10 @@ desktop.ini
 *.tiff
 *.webp
 
+# Allow Metrics plots
+!Metrics/*.png
+!Metrics/*.jpg
+
 # Models and checkpoints
 checkpoints/
 *.ckpt

Metrics/training_metrics.txt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:edef5b371d7b2c75153063f41c43f0e3dff8d58d5fda50e7a0db52d230e04f3c
-size 807
+oid sha256:7fb9b2125cd77da83e51022b8de31388541a080c2f63d11e8b85cb6b34efe534
+size 822

README.md

@@ -36,8 +36,18 @@ This project implements an end-to-end CAPTCHA OCR system that can recognize text
 - **Character Diversity**: Limited to a few characters, needs more training
 
 ### 🎯 Training Status
-- **Current**: Epoch 3, basic character recognition starting
-- **Estimated**: 20-40 epochs needed for decent CAPTCHA accuracy
+- **Current**: Epoch 8, excellent convergence achieved
+- **Best Model**: Validation loss 0.1782, early stopping working perfectly
+- **Performance**: 75-100% accuracy on fresh CAPTCHAs (varies by run)
+
+### 📊 Training Results
+![Training Losses](Metrics/training_losses.png)
+![Loss Comparison](Metrics/loss_comparison.png)
+
+**Key Insights:**
+- **Rapid convergence**: Loss dropped from 21→0.1 in first 7 epochs
+- **No overfitting**: Enhanced early stopping prevents overfitting
+- **Stable training**: Val/Train ratio stays healthy throughout training
 
 ## 📁 Project Structure
 

inference.py

@@ -0,0 +1,188 @@
+import torch
+import cv2
+import os
+import random
+import numpy as np
+from src.config import cfg
+from src.model_crnn import CRNN
+from src.vocab import ctc_greedy_decode, vocab_size
+from src.plotting import TrainingMetrics
+from captcha.image import ImageCaptcha
+
+def load_model(checkpoint_path="checkpoints/best_model.pth"):
+    """Load the trained model from checkpoint."""
+    if not os.path.exists(checkpoint_path):
+        raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}")
+    
+    # Detect available device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # Load checkpoint to the detected device
+    checkpoint = torch.load(checkpoint_path, map_location=device)
+    print(f"✅ Loaded model from epoch {checkpoint['epoch']}")
+    print(f"   Best validation loss: {checkpoint['best_val_loss']:.4f}")
+    print(f"   Loading to device: {device}")
+    
+    # Create model and load weights
+    model = CRNN(vocab_size=vocab_size(), hidden=320, dropout=0.05)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+    
+    return model
+
+def preprocess_image(image_path, target_size=(cfg.W_max, cfg.H)):
+    """Preprocess image for inference (same as training)."""
+    # Load image
+    if not os.path.exists(image_path):
+        raise FileNotFoundError(f"Image not found: {image_path}")
+    
+    # Read and preprocess
+    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE if cfg.grayscale else cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError(f"Failed to load image: {image_path}")
+    
+    # Resize to target dimensions
+    img = cv2.resize(img, target_size)
+    
+    # Convert to tensor and normalize
+    img_tensor = torch.from_numpy(img).float() / 255.0
+    
+    # Add batch and channel dimensions
+    if cfg.grayscale:
+        img_tensor = img_tensor.unsqueeze(0).unsqueeze(0)  # [1, 1, H, W]
+    else:
+        img_tensor = img_tensor.permute(2, 0, 1).unsqueeze(0)  # [1, 3, H, W]
+    
+    return img_tensor
+
+def predict_captcha(model, image_tensor, device):
+    """Run inference on a single image."""
+    with torch.no_grad():
+        # Move to device
+        image_tensor = image_tensor.to(device)
+        
+        # Forward pass
+        logits = model(image_tensor)
+        
+        # Decode prediction
+        prediction = ctc_greedy_decode(logits)
+        
+        return prediction[0] if prediction else ""
+
+def generate_test_captcha(text, filename, width=160, height=60):
+    """Generate a test CAPTCHA image."""
+    image = ImageCaptcha(width=width, height=height)
+    filepath = os.path.join(cfg.RESULT_DIR, filename)
+    image.write(text, filepath)
+    print(f"📸 Generated test CAPTCHA: {filename}")
+    return filepath
+
+def main():
+    # Setup
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"🚀 Using device: {device}")
+    
+    os.makedirs(cfg.RESULT_DIR, exist_ok=True)
+    
+    try:
+        # Load trained model
+        print("📥 Loading trained model...")
+        model = load_model()
+        model = model.to(device)
+        print("✅ Model loaded successfully!")
+        
+        # Generate test CAPTCHAs
+        print("\n🎯 Generating test CAPTCHAs...")
+        test_cases = []
+        
+        for i in range(4):
+            # Generate random text
+            text = ''.join(random.choices(cfg.chars, k=random.randint(cfg.CAPTCHA_LEN_LOWER_LIMIT, cfg.CAPTCHA_LEN_UPPER_LIMIT)))
+            filename = f"{text}_{i}.png"
+            
+            # Generate image
+            image_path = generate_test_captcha(text, filename)
+            test_cases.append((text, image_path, ""))  # Add empty prediction slot
+        
+        # Run inference
+        print("\n🔍 Running inference...")
+        print("-" * 60)
+        print(f"{'Target':<15} {'Prediction':<15} {'Correct':<10} {'Image':<20}")
+        print("-" * 60)
+        
+        correct_count = 0
+        for i, (target_text, image_path, _) in enumerate(test_cases):
+            try:
+                # Preprocess image
+                image_tensor = preprocess_image(image_path)
+                
+                # Run prediction
+                prediction = predict_captcha(model, image_tensor, device)
+                
+                # Store prediction in test_cases
+                test_cases[i] = (target_text, image_path, prediction)
+                
+                # Check if correct
+                is_correct = prediction == target_text
+                if is_correct:
+                    correct_count += 1
+                
+                # Display result
+                status = "✅" if is_correct else "❌"
+                print(f"{target_text:<15} {prediction:<15} {status:<10} {os.path.basename(image_path):<20}")
+                
+            except Exception as e:
+                print(f"❌ Error processing {image_path}: {e}")
+        
+        # Summary
+        print("-" * 60)
+        accuracy = (correct_count / len(test_cases)) * 100
+        print(f"📊 Overall Accuracy: {correct_count}/{len(test_cases)} ({accuracy:.1f}%)")
+        
+        # Calculate individual character accuracy
+        total_chars = 0
+        correct_chars = 0
+        for target_text, _, prediction in test_cases:
+            total_chars += len(target_text)
+            # Count correct characters (position by position)
+            min_len = min(len(target_text), len(prediction))
+            for i in range(min_len):
+                if target_text[i] == prediction[i]:
+                    correct_chars += 1
+        
+        char_accuracy = (correct_chars / total_chars) * 100 if total_chars > 0 else 0
+        print(f"🔤 Character Accuracy: {correct_chars}/{total_chars} ({char_accuracy:.1f}%)")
+        
+        if accuracy >= 80:
+            print("🎉 Excellent performance!")
+        elif accuracy >= 60:
+            print("👍 Good performance!")
+        else:
+            print("🤔 Room for improvement...")
+        
+        # Create and save results plot
+        print("\n📊 Generating results visualization...")
+        try:
+            metrics = TrainingMetrics()
+            image_paths = [case[1] for case in test_cases]
+            predictions = [case[2] for case in test_cases]
+            targets = [case[0] for case in test_cases]
+            
+            # Create results directory if it doesn't exist
+            os.makedirs("Metrics", exist_ok=True)
+            
+            # Plot results
+            metrics.plot_results(image_paths, predictions, targets)
+            print("✅ Results plot generated successfully!")
+            
+        except Exception as e:
+            print(f"⚠️  Warning: Could not generate plot: {e}")
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        print("💡 Make sure you have a trained model in checkpoints/best_model.pth")
+
+if __name__ == "__main__":
+    main()
+
+

src/config.py

@@ -7,7 +7,10 @@ class Config:
     data_root: str = os.getenv("DATA_ROOT","Dataset_test\captchas")
 
     chars: str = string.ascii_letters + string.digits
-    
+    CAPTCHA_LEN_LOWER_LIMIT: int = 5
+    CAPTCHA_LEN_UPPER_LIMIT: int = 7
+
+    RESULT_DIR: str = "Results"
     # Image dimensions - increased for better character detail
     H: int = 60  # Increased from 48 for more vertical detail
     W_max: int = 256  # Increased from 224 for more time steps (T=64)

src/plotting.py

@@ -104,4 +104,83 @@ class TrainingMetrics:
             f.write("Sample Predictions:\n")
             f.write("-" * 20 + "\n")
             for i, (pred, target) in enumerate(zip(self.sample_predictions[:10], self.sample_targets[:10])):
-                f.write(f"Sample {i+1}: Predicted='{pred}', Target='{target}'\n")
+                f.write(f"Sample {i+1}: Predicted='{pred}', Target='{target}'\n")
+    
+    def plot_results(self, image_paths, predictions, targets, save_path="Metrics/inference_results.png"):
+        """
+        Plot CAPTCHA images with their predictions and targets.
+        
+        Args:
+            image_paths: List of paths to CAPTCHA images
+            predictions: List of predicted texts
+            targets: List of target texts
+            save_path: Path to save the plot
+        """
+        import cv2
+        
+        n_images = len(image_paths)
+        if n_images == 0:
+            print("No images to plot!")
+            return
+        
+        # Force 2x2 grid for 4 images
+        rows, cols = 2, 2
+        fig, axes = plt.subplots(rows, cols, figsize=(12, 8))
+        
+        # Flatten axes for easier indexing
+        axes = axes.flatten()
+        
+        for i, (img_path, pred, target) in enumerate(zip(image_paths, predictions, targets)):
+            if i >= len(axes):
+                break
+                
+            ax = axes[i]
+            
+            # Load and display image
+            try:
+                img = cv2.imread(img_path)
+                if img is not None:
+                    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                    ax.imshow(img)
+                    
+                    # Determine if prediction is correct
+                    is_correct = pred == target
+                    color = 'green' if is_correct else 'red'
+                    status = 'CORRECT' if is_correct else 'WRONG'
+                    
+                    # Set title with prediction and target
+                    title = f"Pred: {pred}\nTarget: {target}\n{status}"
+                    ax.set_title(title, fontsize=10, color=color, fontweight='bold')
+                    
+                else:
+                    ax.text(0.5, 0.5, f"Failed to load\n{os.path.basename(img_path)}", 
+                           ha='center', va='center', transform=ax.transAxes, fontsize=12)
+                    
+            except Exception as e:
+                ax.text(0.5, 0.5, f"Error loading image\n{str(e)[:30]}...", 
+                       ha='center', va='center', transform=ax.transAxes, fontsize=10, color='red')
+            
+            # Remove axes
+            ax.axis('off')
+        
+        # Hide unused subplots
+        for i in range(n_images, len(axes)):
+            axes[i].axis('off')
+        
+        # Add overall title
+        fig.suptitle('CAPTCHA OCR Inference Results', fontsize=16, fontweight='bold', y=0.98)
+        
+        # Calculate accuracy
+        correct = sum(1 for p, t in zip(predictions, targets) if p == t)
+        accuracy = (correct / len(targets)) * 100
+        
+        # Add accuracy info
+        fig.text(0.5, 0.02, f'Accuracy: {correct}/{len(targets)} ({accuracy:.1f}%)', 
+                ha='center', fontsize=14, fontweight='bold',
+                bbox=dict(boxstyle="round,pad=0.3", facecolor="lightblue", alpha=0.7))
+        
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.9, bottom=0.15)
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        plt.close()
+        print(f"Results plot saved to: {save_path}")

train.py

@@ -57,6 +57,12 @@ def main():
     print(f"\nStarting training for {epochs} epochs...")
     
     metrics = TrainingMetrics()
+    
+    # Early stopping setup
+    best_val_loss = float('inf')
+    patience = 5  # Stop if no improvement for 5 epochs
+    patience_counter = 0
+    early_stop = False
 
     for epoch in range(epochs):
         # Training phase
@@ -134,6 +140,50 @@ def main():
         print(f"  Train Loss: {avg_train_loss:.4f}")
         print(f"  Val Loss: {avg_val_loss:.4f}")
         metrics.add_epoch(epoch+1, avg_train_loss, avg_val_loss)
+        
+        # Enhanced early stopping check
+        val_train_ratio = avg_val_loss / (avg_train_loss + 1e-8)  # Avoid division by zero
+        
+        if avg_val_loss < best_val_loss:
+            best_val_loss = avg_val_loss
+            patience_counter = 0
+            print(f"  🎯 New best validation loss: {best_val_loss:.4f}")
+            print(f"  📊 Val/Train ratio: {val_train_ratio:.3f}")
+            
+            # Save best model checkpoint with metadata
+            checkpoint = {
+                'epoch': epoch + 1,
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'scheduler_state_dict': scheduler.state_dict(),
+                'best_val_loss': best_val_loss,
+                'train_loss': avg_train_loss,
+                'val_loss': avg_val_loss,
+                'val_train_ratio': val_train_ratio,
+                'config': {
+                    'vocab_size': vocab_size(),
+                    'hidden_size': 320,
+                    'total_stride': cfg.total_stride,
+                    'H': cfg.H,
+                    'W_max': cfg.W_max
+                }
+            }
+            torch.save(checkpoint, "checkpoints/best_model.pth")
+            print(f"  💾 Best model saved to checkpoints/best_model.pth")
+            
+        else:
+            patience_counter += 1
+            print(f"  ⚠️  No improvement for {patience_counter} epochs")
+            print(f"  📊 Val/Train ratio: {val_train_ratio:.3f}")
+            
+        # Enhanced early stopping: Check both absolute loss and ratio
+        if patience_counter >= patience or val_train_ratio > 3.0:  # Stop if ratio > 3x
+            if val_train_ratio > 3.0:
+                print(f"  🛑 Early stopping triggered! Val/Train ratio too high: {val_train_ratio:.3f}")
+            else:
+                print(f"  🛑 Early stopping triggered! No improvement for {patience} epochs")
+            early_stop = True
+            break
 
         # Test some predictions
         if epoch % 2 == 0:  # Every 2 epochs
@@ -181,7 +231,30 @@ def main():
                 
                 metrics.add_predictions(test_preds, test_targets)
 
-    print("\nTraining complete!")
+    if early_stop:
+        print(f"\nTraining stopped early at epoch {epoch+1} due to no improvement!")
+    else:
+        print(f"\nTraining completed for all {epochs} epochs!")
+    
+    # Save final model
+    final_checkpoint = {
+        'epoch': epoch + 1,
+        'model_state_dict': model.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'scheduler_state_dict': scheduler.state_dict(),
+        'final_val_loss': avg_val_loss,
+        'final_train_loss': avg_train_loss,
+        'config': {
+            'vocab_size': vocab_size(),
+            'hidden_size': 320,
+            'total_stride': cfg.total_stride,
+            'H': cfg.H,
+            'W_max': cfg.W_max
+        }
+    }
+    torch.save(final_checkpoint, "checkpoints/final_model.pth")
+    print(f"💾 Final model saved to checkpoints/final_model.pth")
+    
     print("\nGenerating training metrics and plots...")
     os.makedirs("Metrics", exist_ok=True)
     metrics.plot_losses()