Add application file

best_caligrafia_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6330ce56680a58105963cd292c1ebc3b3777cb5c3ee4180eb41d8f96d88a6eb6
+size 75112706

predictor.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+PREDICTOR Caligrafía CRNN - SOLO PREDICCIONES
+Carga best_caligrafia_model.pth → predict(imagen.png)
+Optimizado Mac Intel i9 + AMD GPU
+"""
+
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from PIL import Image
+import platform
+from pathlib import Path
+
+#  Detectar device (tu lógica original)
+IS_APPLE_SILICON = platform.machine() == 'arm64'
+def get_device():
+    if platform.machine() == 'arm64':
+        return torch.device('mps' if torch.backends.mps.is_available() else 'cpu')
+    return torch.device('cpu')  # PyTorch usa AMD automáticamente
+
+device = get_device()
+
+#  Tu modelo CRNN (copiado exacto)
+class CaligrafiaCRNN(nn.Module):
+    def __init__(self, num_classes=7):
+        super().__init__()
+        self.cnn = nn.Sequential(
+            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(),
+            nn.Conv2d(32, 32, 3, padding=1), nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(),
+            nn.Conv2d(64, 64, 3, padding=1), nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(),
+            nn.Conv2d(128, 128, 3, padding=1), nn.ReLU(),
+            nn.AdaptiveAvgPool2d((4, 16)),
+            nn.Dropout2d(0.25)
+        )
+        self.lstm = nn.LSTM(8192, 256, bidirectional=True, batch_first=True, dropout=0.3)
+        self.attention = nn.MultiheadAttention(512, 8, batch_first=True)
+        self.classifier = nn.Sequential(
+            nn.Linear(512, 256), nn.ReLU(), nn.Dropout(0.5),
+            nn.Linear(256, num_classes)
+        )
+    
+    def forward(self, x):
+        features = self.cnn(x)
+        B, C, H, W = features.shape
+        features = features.permute(0, 3, 1, 2).reshape(B, W, C*H)
+        lstm_out, _ = self.lstm(features)
+        attn_out, _ = self.attention(lstm_out, lstm_out, lstm_out)
+        pooled = attn_out.mean(dim=1)
+        return self.classifier(pooled)
+
+#  PREDICTOR (tu clase simplificada)
+class CaligrafiaPredictor:
+    def __init__(self, model_path="best_caligrafia_model.pth"):
+        self.device = get_device()
+        self.model = CaligrafiaCRNN().to(self.device)
+        self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+        self.model.eval()
+        
+        self.transform = transforms.Compose([
+            transforms.Resize((64, 256)),
+            transforms.Grayscale(num_output_channels=1),
+            transforms.ToTensor(),
+            transforms.Normalize((0.5,), (0.5,))
+        ])
+        
+        # Detecta clases reales del dataset
+        dataset_path = Path('dataset/train')
+        if dataset_path.exists():
+            self.clases = sorted([d.name for d in dataset_path.iterdir() if d.is_dir()])
+        else:
+            self.clases = [f'caligrafia_{i}' for i in range(7)]
+        print(f"🏷️ Clases: {self.clases}")
+    
+    def predict(self, image_path):
+        image = Image.open(image_path).convert('RGB')
+        image = self.transform(image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            logits = self.model(image)
+            probs = torch.softmax(logits, dim=1)
+            pred_class = probs.argmax(dim=1).cpu().item()
+            confidence = probs[0, pred_class].cpu().item()
+        
+        return {
+            "caligrafia": self.clases[pred_class],
+            "confidence": float(confidence),
+            "probs": probs[0].cpu().tolist()
+        }
+
+#  USO DIRECTO
+if __name__ == "__main__":
+    predictor = CaligrafiaPredictor("best_caligrafia_model.pth")
+    
+    # Predice cualquier imagen PNG/JPG
+    imagen = "mi_caligrafia.png"  # ← CAMBIA ESTA LÍNEA
+    resultado = predictor.predict(imagen)
+    
+    print("🎯 RESULTADO:")
+    print(f"📝 Clase: {resultado['caligrafia']}")
+    print(f"✅ Confianza: {resultado['confidence']:.1%}")
+    print(f"📊 Todas probs: {resultado['probs']}")

requirements.txt

@@ -0,0 +1,4 @@
+torch
+torchvision
+gradio
+pillow