Upload 6 files

handler.py

@@ -0,0 +1,114 @@
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import requests
+from io import BytesIO
+import json
+import os
+from transformers import ViTForImageClassification, ViTConfig
+from huggingface_hub import hf_hub_download
+
+# Importar el procesador de imágenes del código de entrenamiento
+from train_categories import PaddingImageProcessor
+
+def load_model_and_config(model_path):
+    """Carga el modelo entrenado y su configuración"""
+    hf_path = "vit_multiclass_model_best"
+    # Cargar información de las clases
+    class_info_path = os.path.join(hf_path, 'class_info.json')
+    with open(class_info_path, 'r') as f:
+        class_info = json.load(f)
+    
+    # Cargar configuración del procesador
+    processor_config_path = os.path.join(hf_path, 'processor_config.json')
+    with open(processor_config_path, 'r') as f:
+        processor_config = json.load(f)
+    
+    # Crear procesador de imágenes
+    image_processor = PaddingImageProcessor(
+        target_size=processor_config['target_size'],
+        padding_color=tuple(processor_config['padding_color'])
+    )
+    
+    # Cargar modelo
+    model = ViTForImageClassification.from_pretrained(model_path)
+    model.eval()
+    
+    # Usar GPU si está disponible
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = model.to(device)
+    
+    return model, image_processor, class_info, device
+
+def download_image(url: str) -> Image.Image:
+    """Descarga una imagen desde una URL"""
+    response = requests.get(url, timeout=10)
+    response.raise_for_status()
+    image = Image.open(BytesIO(response.content)).convert('RGB')
+    return image
+
+def classify_image(model, image_processor, class_info, device, accuracy):
+
+    # Descargar y procesar imagen
+    image = download_image(image_url)
+    processed_image = image_processor(image).unsqueeze(0).to(device)
+    
+    # Realizar predicción
+    with torch.no_grad():
+        outputs = model(pixel_values=processed_image).logits
+        probabilities = torch.sigmoid(outputs).cpu().numpy()[0]
+    
+    # Obtener clases predichas (umbral 0.5)
+    predicted_classes = []
+    for i, prob in enumerate(probabilities):
+        if prob > accuracy:
+            class_name = class_info['class_columns'][i]
+            predicted_classes.append(f"{class_name}: {prob:.3f}")
+    
+    # Mostrar resultado
+    if predicted_classes:
+        for prediction in predicted_classes:
+            print(prediction)
+        return predicted_classes    
+    else:
+        # Si ninguna clase supera 0.5, mostrar la más probable
+        max_idx = probabilities.argmax()
+        max_prob = probabilities[max_idx]
+        class_name = class_info['class_columns'][max_idx]
+        print(f"{class_name}: {max_prob:.3f}")
+        return [class_name, max_prob]
+
+class EndpointHandler():
+    def __init__(self, path=""):
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        model_filename = "vit_multiclass_model_best/model.safetensors"
+        local_path = hf_hub_download(repo_id="Drazcat-AI/categories_peru", filename=model_filename)
+        self.model, self.image_processor, self.class_info, self.device = load_model_and_config(local_path)
+
+    def predict_objects(self, image_url, accuracy):
+        
+        result_df =  classify_image(image_url, accuracy)   
+        return result_df
+
+    def __call__(self, event):
+        if "inputs" not in event:
+            return {
+                "statusCode": 400,
+                "body": json.dumps("Error: Please provide an 'inputs' parameter."),
+            }
+        event = event["inputs"]
+        image_url = event["image_url"]
+        accuracy = event["accuracy"]
+        try:
+            predictions = self.predict_objects(image_url, accuracy)
+            predictions_json = predictions.to_json(orient='records')
+            
+            return {
+                "statusCode": 200,
+                "body": json.dumps(predictions_json),
+            }
+        except Exception as e:
+            return {
+                "statusCode": 500,
+                "body": json.dumps(f"Error: {str(e)}"),
+            }      

train_categories.py

@@ -0,0 +1,614 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import pandas as pd
+import numpy as np
+from PIL import Image, ImageOps
+import torchvision.transforms as transforms
+import os
+from transformers import ViTForImageClassification, ViTConfig
+from sklearn.metrics import accuracy_score, classification_report
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tqdm import tqdm
+from typing import List, Tuple, Dict, Optional
+import json
+import warnings
+warnings.filterwarnings('ignore')
+
+# ============================================================================
+# CONFIGURACIÓN PARA JUPYTER NOTEBOOK
+# ============================================================================
+
+# CONFIGURAR ESTOS PATHS SEGÚN TU ESTRUCTURA DE DATOS
+DATA_PATH = "datasets/peru_cencosud_categories-2"  # Cambiar por tu path de datos
+SAVE_PATH = "vit_multiclass_model"  # Donde guardar el modelo entrenado
+MODEL_NAME = "google/vit-base-patch16-224"  # Modelo ViT preentrenado
+
+# CONFIGURACIÓN DE IMAGEN
+IMAGE_SIZE = 800  # Resolución objetivo
+PADDING_COLOR = (128, 128, 128)  # Color de padding (gris medio)
+
+# HIPERPARÁMETROS OPTIMIZADOS PARA 26K IMÁGENES / 90 CLASES
+EPOCHS = 30  # Más épocas por la cantidad de datos y clases
+BATCH_SIZE = 8  # Aumentado para mejor estabilidad
+LEARNING_RATE = 1e-4  # Reducido para mejor convergencia
+WEIGHT_DECAY = 1e-4  # Regularización
+WARMUP_EPOCHS = 3  # Warmup para estabilidad inicial
+
+# ============================================================================
+# PROCESADOR DE IMÁGENES PERSONALIZADO
+# ============================================================================
+
+class PaddingImageProcessor:
+    """Procesador de imágenes personalizado que mantiene aspect ratio con padding"""
+    
+    def __init__(self, target_size: int = 1280, padding_color: tuple = (128, 128, 128)):
+        """
+        Args:
+            target_size: Tamaño objetivo (cuadrado)
+            padding_color: Color del padding en RGB
+        """
+        self.target_size = target_size
+        self.padding_color = padding_color
+        
+        # Transforms para normalización (valores estándar de ImageNet)
+        self.normalize = transforms.Normalize(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225]
+        )
+        
+    def pad_to_square(self, image: Image.Image) -> Image.Image:
+        """Aplica padding para hacer la imagen cuadrada manteniendo aspect ratio"""
+        width, height = image.size
+        
+        # Determinar el tamaño del cuadrado (el lado más largo)
+        max_size = max(width, height)
+        
+        # Crear imagen cuadrada con color de padding
+        padded_image = Image.new('RGB', (max_size, max_size), self.padding_color)
+        
+        # Calcular posición para centrar la imagen original
+        left = (max_size - width) // 2
+        top = (max_size - height) // 2
+        
+        # Pegar la imagen original en el centro
+        padded_image.paste(image, (left, top))
+        
+        return padded_image
+    
+    def __call__(self, image: Image.Image) -> torch.Tensor:
+        """
+        Procesa una imagen aplicando padding + resize
+        
+        Args:
+            image: Imagen PIL en formato RGB
+            
+        Returns:
+            Tensor procesado listo para el modelo
+        """
+        # 1. Aplicar padding para hacer cuadrada
+        padded_image = self.pad_to_square(image)
+        
+        # 2. Resize a la resolución objetivo manteniendo aspect ratio (ya es cuadrada)
+        resized_image = padded_image.resize((self.target_size, self.target_size), Image.Resampling.LANCZOS)
+        
+        # 3. Convertir a tensor y normalizar
+        # Convertir PIL a tensor [0, 1]
+        transform_to_tensor = transforms.ToTensor()
+        tensor_image = transform_to_tensor(resized_image)
+        
+        # 4. Normalizar con valores de ImageNet
+        normalized_image = self.normalize(tensor_image)
+        
+        return normalized_image
+
+# ============================================================================
+# DATASET PERSONALIZADO
+# ============================================================================
+
+class MultiClassImageDataset(Dataset):
+    """Dataset personalizado para clasificación multi-clase de imágenes"""
+    
+    def __init__(self, csv_path: str, images_dir: str, image_processor: PaddingImageProcessor, 
+                 class_columns: List[str], filename_column: str):
+        """
+        Args:
+            csv_path: Ruta al archivo CSV con las anotaciones
+            images_dir: Directorio que contiene las imágenes
+            image_processor: Procesador personalizado de imágenes
+            class_columns: Lista de nombres de columnas que representan las clases
+            filename_column: Nombre de la columna que contiene los nombres de archivos
+        """
+        self.df = pd.read_csv(csv_path)
+        self.images_dir = images_dir
+        self.image_processor = image_processor
+        self.class_columns = class_columns
+        self.filename_column = filename_column
+        
+        print(f"Dataset cargado desde {csv_path}: {len(self.df)} imágenes")
+        print(f"Columnas de clases: {class_columns}")
+        
+    def __len__(self):
+        return len(self.df)
+    
+    def __getitem__(self, idx):
+        row = self.df.iloc[idx]
+        
+        # Cargar imagen usando la columna de filename detectada
+        img_path = os.path.join(self.images_dir, row[self.filename_column])
+        try:
+            image = Image.open(img_path).convert('RGB')
+        except Exception as e:
+            print(f"Error cargando imagen {img_path}: {e}")
+            # Crear imagen dummy si hay error
+            image = Image.new('RGB', (224, 224), color='black')
+        
+        # Procesar imagen con padding + resize personalizado
+        processed_image = self.image_processor(image)
+        
+        # Crear tensor de etiquetas multi-clase
+        labels = torch.tensor([row[col] for col in self.class_columns], dtype=torch.float32)
+        
+        return processed_image, labels
+
+# ============================================================================
+# ENTRENADOR ViT
+# ============================================================================
+
+class ViTMultiClassTrainer:
+    """Entrenador para ViT con clasificación multi-clase"""
+    
+    def __init__(self, data_path: str, model_name: str = "google/vit-base-patch16-224"):
+        """
+        Args:
+            data_path: Ruta base donde están los directorios train/valid/test
+            model_name: Nombre del modelo ViT preentrenado
+        """
+        self.data_path = data_path
+        self.model_name = model_name
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Usando dispositivo: {self.device}")
+        
+        # Inicializar procesador personalizado
+        self.image_processor = PaddingImageProcessor(
+            target_size=IMAGE_SIZE,
+            padding_color=PADDING_COLOR
+        )
+        print(f"Procesador de imágenes configurado: {IMAGE_SIZE}px con padding {PADDING_COLOR}")
+        
+        # Detectar estructura de datos automáticamente
+        self._detect_data_structure()
+        
+    def _find_csv_in_folder(self, folder_path: str) -> Optional[str]:
+        """Busca el archivo CSV en una carpeta específica"""
+        if not os.path.exists(folder_path):
+            return None
+            
+        csv_files = [f for f in os.listdir(folder_path) if f.endswith('.csv')]
+        
+        if len(csv_files) == 0:
+            print(f"No se encontró CSV en {folder_path}")
+            return None
+        elif len(csv_files) == 1:
+            csv_path = os.path.join(folder_path, csv_files[0])
+            print(f"CSV encontrado: {csv_path}")
+            return csv_path
+        else:
+            # Si hay múltiples CSVs, tomar el primero
+            csv_path = os.path.join(folder_path, csv_files[0])
+            print(f"Múltiples CSVs en {folder_path}, usando: {csv_files[0]}")
+            return csv_path
+    
+    def _detect_filename_column(self, df: pd.DataFrame) -> str:
+        """Detecta la columna que contiene los nombres de archivos"""
+        possible_names = ['filename', 'image', 'image_name', 'file', 'name', 'img']
+        
+        for col in possible_names:
+            if col in df.columns:
+                return col
+        
+        # Si no encuentra ninguna, usar la primera columna
+        print(f"No se encontró columna de filename conocida. Usando: {df.columns[0]}")
+        return df.columns[0]
+    
+    def _detect_data_structure(self):
+        """Detecta automáticamente la estructura de datos y clases"""
+        print("Detectando estructura de datos...")
+        
+        # Buscar CSV en carpeta de entrenamiento
+        train_folder = os.path.join(self.data_path, 'train')
+        train_csv = self._find_csv_in_folder(train_folder)
+        
+        if train_csv is None:
+            raise FileNotFoundError(f"No se encontró CSV en {train_folder}")
+        
+        # Cargar CSV para detectar columnas
+        df = pd.read_csv(train_csv)
+        print(f"Columnas encontradas: {list(df.columns)}")
+        
+        # Detectar columna de filename
+        self.filename_column = self._detect_filename_column(df)
+        print(f"Columna de archivos detectada: {self.filename_column}")
+        
+        # Las demás columnas son las clases
+        self.class_columns = [col for col in df.columns if col != self.filename_column]
+        self.num_classes = len(self.class_columns)
+        
+        if self.num_classes == 0:
+            raise ValueError("No se encontraron columnas de clases")
+        
+        print(f"Clases detectadas ({self.num_classes}): {self.class_columns}")
+        
+        # Verificar otras carpetas
+        for split in ['valid', 'test']:
+            split_folder = os.path.join(self.data_path, split)
+            if os.path.exists(split_folder):
+                csv_path = self._find_csv_in_folder(split_folder)
+                if csv_path:
+                    print(f"Carpeta {split}: CSV encontrado")
+                else:
+                    print(f"Carpeta {split}: Sin CSV")
+            else:
+                print(f"Carpeta {split}: No existe")
+    
+    def _create_datasets(self) -> Tuple[Dataset, Optional[Dataset], Optional[Dataset]]:
+        """Crea los datasets de entrenamiento, validación y prueba"""
+        datasets = {}
+        
+        for split in ['train', 'valid', 'test']:
+            split_folder = os.path.join(self.data_path, split)
+            csv_path = self._find_csv_in_folder(split_folder)
+            
+            if csv_path is not None:
+                datasets[split] = MultiClassImageDataset(
+                    csv_path=csv_path,
+                    images_dir=split_folder,
+                    image_processor=self.image_processor,
+                    class_columns=self.class_columns,
+                    filename_column=self.filename_column
+                )
+            else:
+                datasets[split] = None
+        
+        return datasets.get('train'), datasets.get('valid'), datasets.get('test')
+    
+    def _create_model(self):
+        """Crea el modelo ViT para clasificación multi-clase con resolución personalizada"""
+        # Configurar el modelo para la nueva resolución
+        config = ViTConfig.from_pretrained(self.model_name)
+        
+        # Calcular el número de patches para la nueva resolución
+        patch_size = config.patch_size
+        num_patches = (IMAGE_SIZE // patch_size) ** 2
+        
+        # Actualizar configuración
+        config.image_size = IMAGE_SIZE
+        config.num_labels = self.num_classes
+        
+        print(f"Configuración del modelo:")
+        print(f"  - Resolución de imagen: {IMAGE_SIZE}x{IMAGE_SIZE}")
+        print(f"  - Tamaño de patch: {patch_size}x{patch_size}")
+        print(f"  - Número de patches: {num_patches}")
+        print(f"  - Número de clases: {self.num_classes}")
+        
+        # Cargar modelo preentrenado con nueva configuración
+        model = ViTForImageClassification.from_pretrained(
+            self.model_name,
+            config=config,
+            ignore_mismatched_sizes=True
+        )
+        
+        # Modificar la cabeza de clasificación para multi-clase
+        model.classifier = nn.Linear(model.config.hidden_size, self.num_classes)
+        
+        return model.to(self.device)
+    
+    def _calculate_multilabel_accuracy(self, labels, preds):
+        """Calcula la precisión para clasificación multi-etiqueta"""
+        labels = np.array(labels)
+        preds = np.array(preds)
+        
+        # Precisión exacta (todas las etiquetas deben coincidir)
+        exact_match = np.all(labels == preds, axis=1).mean()
+        return exact_match
+    
+    def _save_model(self, model, save_path):
+        """Guarda el modelo entrenado"""
+        os.makedirs(save_path, exist_ok=True)
+        
+        # Guardar modelo
+        model.save_pretrained(save_path)
+        
+        # Guardar configuración del procesador personalizado
+        processor_config = {
+            'target_size': IMAGE_SIZE,
+            'padding_color': PADDING_COLOR,
+            'mean': [0.485, 0.456, 0.406],
+            'std': [0.229, 0.224, 0.225]
+        }
+        
+        with open(f'{save_path}/processor_config.json', 'w') as f:
+            json.dump(processor_config, f, indent=2)
+        
+        # Guardar información de las clases
+        class_info = {
+            'class_columns': self.class_columns,
+            'filename_column': self.filename_column,
+            'num_classes': self.num_classes,
+            'image_size': IMAGE_SIZE
+        }
+        
+        with open(f'{save_path}/class_info.json', 'w') as f:
+            json.dump(class_info, f, indent=2)
+        
+        print(f"Modelo guardado en: {save_path}")
+    
+    def _plot_training_metrics(self, train_losses, valid_losses, train_accs, valid_accs, save_path):
+        """Plotea las métricas de entrenamiento"""
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
+        
+        # Pérdidas
+        epochs = range(1, len(train_losses) + 1)
+        ax1.plot(epochs, train_losses, 'b-', label='Train Loss')
+        if valid_losses:
+            ax1.plot(epochs, valid_losses, 'r-', label='Valid Loss')
+        ax1.set_title('Pérdida durante el entrenamiento')
+        ax1.set_xlabel('Época')
+        ax1.set_ylabel('Pérdida')
+        ax1.legend()
+        ax1.grid(True)
+        
+        # Precisión
+        ax2.plot(epochs, train_accs, 'b-', label='Train Accuracy')
+        if valid_accs:
+            ax2.plot(epochs, valid_accs, 'r-', label='Valid Accuracy')
+        ax2.set_title('Precisión durante el entrenamiento')
+        ax2.set_xlabel('Época')
+        ax2.set_ylabel('Precisión')
+        ax2.legend()
+        ax2.grid(True)
+        
+        plt.tight_layout()
+        plt.savefig(f'{save_path}/training_metrics.png', dpi=300, bbox_inches='tight')
+        plt.show()
+        
+        print(f"Gráficas guardadas en: {save_path}/training_metrics.png")
+    
+    def train(self, 
+              epochs: int = 30,
+              batch_size: int = 16,
+              learning_rate: float = 1e-4,
+              save_path: str = 'vit_multiclass_model'):
+        """
+        Entrena el modelo ViT
+        
+        Args:
+            epochs: Número de épocas
+            batch_size: Tamaño del lote
+            learning_rate: Tasa de aprendizaje
+            save_path: Ruta donde guardar el modelo entrenado
+        """
+        
+        # Crear datasets
+        train_dataset, valid_dataset, test_dataset = self._create_datasets()
+        
+        if train_dataset is None:
+            raise ValueError("No se pudo cargar el dataset de entrenamiento")
+        
+        # Crear data loaders
+        train_loader = DataLoader(
+            train_dataset, 
+            batch_size=batch_size, 
+            shuffle=True,
+            num_workers=2
+        )
+        
+        valid_loader = None
+        if valid_dataset is not None:
+            valid_loader = DataLoader(
+                valid_dataset, 
+                batch_size=batch_size, 
+                shuffle=False,
+                num_workers=2
+            )
+        
+        # Crear modelo
+        model = self._create_model()
+        
+        # Optimizador y función de pérdida
+        optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=WEIGHT_DECAY)
+        criterion = nn.BCEWithLogitsLoss()  # Para clasificación multi-clase
+        
+        # Scheduler mejorado para datasets grandes
+        total_steps = len(train_loader) * epochs
+        warmup_steps = len(train_loader) * WARMUP_EPOCHS
+        
+        scheduler = optim.lr_scheduler.OneCycleLR(
+            optimizer,
+            max_lr=learning_rate,
+            total_steps=total_steps,
+            pct_start=warmup_steps/total_steps,
+            anneal_strategy='cos'
+        )
+        
+        # Métricas de entrenamiento
+        train_losses = []
+        valid_losses = []
+        train_accuracies = []
+        valid_accuracies = []
+        
+        # Variables para guardar el mejor modelo
+        best_valid_acc = 0.0
+        best_epoch = 0
+        patience_counter = 0
+        patience = 5  # Épocas sin mejora antes de early stopping
+        
+        print(f"\nIniciando entrenamiento por {epochs} épocas...")
+        print(f"Clases: {self.class_columns}")
+        print(f"🎯 Guardado automático del mejor modelo activado")
+        print("=" * 60)
+        
+        for epoch in range(epochs):
+            # Entrenamiento
+            model.train()
+            train_loss = 0.0
+            train_preds = []
+            train_labels = []
+            
+            train_pbar = tqdm(train_loader, desc=f'Época {epoch+1}/{epochs} - Entrenamiento')
+            for batch_idx, (images, labels) in enumerate(train_pbar):
+                images, labels = images.to(self.device), labels.to(self.device)
+                
+                optimizer.zero_grad()
+                outputs = model(pixel_values=images).logits
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+                scheduler.step()  # Actualizar cada batch para OneCycleLR
+                
+                train_loss += loss.item()
+                
+                # Calcular predicciones (umbral 0.5 para multi-clase)
+                preds = torch.sigmoid(outputs) > 0.5
+                train_preds.extend(preds.cpu().numpy())
+                train_labels.extend(labels.cpu().numpy())
+                
+                train_pbar.set_postfix({'Loss': f'{loss.item():.4f}'})
+            
+            # Calcular métricas de entrenamiento
+            avg_train_loss = train_loss / len(train_loader)
+            train_acc = self._calculate_multilabel_accuracy(train_labels, train_preds)
+            
+            train_losses.append(avg_train_loss)
+            train_accuracies.append(train_acc)
+            
+            # Validación
+            if valid_loader is not None:
+                model.eval()
+                valid_loss = 0.0
+                valid_preds = []
+                valid_labels = []
+                
+                with torch.no_grad():
+                    valid_pbar = tqdm(valid_loader, desc=f'Época {epoch+1}/{epochs} - Validación')
+                    for images, labels in valid_pbar:
+                        images, labels = images.to(self.device), labels.to(self.device)
+                        
+                        outputs = model(pixel_values=images).logits
+                        loss = criterion(outputs, labels)
+                        
+                        valid_loss += loss.item()
+                        
+                        preds = torch.sigmoid(outputs) > 0.5
+                        valid_preds.extend(preds.cpu().numpy())
+                        valid_labels.extend(labels.cpu().numpy())
+                        
+                        valid_pbar.set_postfix({'Loss': f'{loss.item():.4f}'})
+                
+                avg_valid_loss = valid_loss / len(valid_loader)
+                valid_acc = self._calculate_multilabel_accuracy(valid_labels, valid_preds)
+                
+                valid_losses.append(avg_valid_loss)
+                valid_accuracies.append(valid_acc)
+                
+                print(f'Época {epoch+1}/{epochs}:')
+                print(f'  Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.4f}')
+                print(f'  Valid Loss: {avg_valid_loss:.4f}, Valid Acc: {valid_acc:.4f}')
+                
+                # Guardar mejor modelo automáticamente
+                if valid_acc > best_valid_acc:
+                    best_valid_acc = valid_acc
+                    best_epoch = epoch + 1
+                    patience_counter = 0
+                    
+                    # Guardar mejor modelo
+                    best_model_path = f"{save_path}_best"
+                    self._save_model(model, best_model_path)
+                    print(f'  🎯 ¡Nuevo mejor modelo guardado! Accuracy: {valid_acc:.4f}')
+                else:
+                    patience_counter += 1
+                    print(f'  📊 Mejor accuracy sigue siendo: {best_valid_acc:.4f} (época {best_epoch})')
+                    if patience_counter >= patience:
+                        print(f'  ⏹️  Early stopping: {patience} épocas sin mejora')
+                        break
+            else:
+                print(f'Época {epoch+1}/{epochs}:')
+                print(f'  Train Loss: {avg_train_loss:.4f}, Train Acc: {train_acc:.4f}')
+            
+            current_lr = scheduler.get_last_lr()[0]
+            print(f'  Learning Rate: {current_lr:.2e}')
+            print('-' * 60)
+        
+        # Guardar modelo final
+        final_model_path = f"{save_path}_final"
+        self._save_model(model, final_model_path)
+        
+        # Resumen de guardado
+        print(f"\n📁 Modelos guardados:")
+        if valid_loader is not None:
+            print(f"  🎯 Mejor modelo: {save_path}_best (época {best_epoch}, acc: {best_valid_acc:.4f})")
+        print(f"  📋 Modelo final: {final_model_path} (última época)")
+        
+        # Guardar métricas
+        metrics = {
+            'train_losses': train_losses,
+            'valid_losses': valid_losses,
+            'train_accuracies': train_accuracies,
+            'valid_accuracies': valid_accuracies,
+            'class_columns': self.class_columns,
+            'filename_column': self.filename_column,
+            'best_valid_acc': best_valid_acc,
+            'best_epoch': best_epoch
+        }
+        
+        with open(f'{final_model_path}/training_metrics.json', 'w') as f:
+            json.dump(metrics, f, indent=2)
+        
+        # Plotear métricas
+        self._plot_training_metrics(train_losses, valid_losses, train_accuracies, valid_accuracies, final_model_path)
+        
+        print("\n¡Entrenamiento completado!")
+        print(f"Modelo guardado con resolución {IMAGE_SIZE}x{IMAGE_SIZE}")
+        print(f"Uso de memoria optimizado con batch size {batch_size}")
+        return model
+
+# ============================================================================
+# FUNCIÓN PRINCIPAL PARA JUPYTER
+# ============================================================================
+
+def train_model():
+    """Función principal para entrenar el modelo en Jupyter"""
+    
+    print("=== Entrenamiento de ViT Multi-Clasificación ===")
+    print(f"Ruta de datos: {DATA_PATH}")
+    print(f"Épocas: {EPOCHS}")
+    print(f"Batch size: {BATCH_SIZE}")
+    print(f"Learning rate: {LEARNING_RATE}")
+    print(f"Modelo: {MODEL_NAME}")
+    print("=" * 50)
+    
+    # Crear entrenador
+    trainer = ViTMultiClassTrainer(
+        data_path=DATA_PATH,
+        model_name=MODEL_NAME
+    )
+    
+    # Entrenar modelo
+    model = trainer.train(
+        epochs=EPOCHS,
+        batch_size=BATCH_SIZE,
+        learning_rate=LEARNING_RATE,
+        save_path=SAVE_PATH
+    )
+    
+    return model
+
+# ============================================================================
+# EJECUCIÓN DIRECTA PARA JUPYTER
+# ============================================================================
+
+# Descomenta la siguiente línea para ejecutar directamente
+if __name__ == "__main__":
+    model = train_model()

vit_multiclass_model_best/class_info.json

@@ -0,0 +1,97 @@
+{
+  "class_columns": [
+    "Accesorios Aseo -ID- 203",
+    "Aceite Vinagre Limon -ID- 147",
+    "Aceitunas y Encurtidos Coctel -ID- 240",
+    "Aderezos -ID- 262",
+    "Afeitado -ID- 204",
+    "Aguas -ID- 158",
+    "Arroz -ID- 167",
+    "Azucar y Endulzantes -ID- 148",
+    "Bebe -ID- 225",
+    "Bebidas Energeticas Y Funcionales -ID- 170",
+    "Bebidas Gaseosas -ID- 166",
+    "Bebidas Vegetales -ID- 231",
+    "Bolsas Basura Reutilizables Y Alusas -ID- 155",
+    "Cafe -ID- 176",
+    "Caja -ID- 260",
+    "Cecinas Envasadas -ID- 161",
+    "Cecinas Granel -ID- 142",
+    "Cecinas Maduras -ID- 232",
+    "Cereales -ID- 171",
+    "Cervezas -ID- 192",
+    "Champagne Y Espumantes -ID- 233",
+    "Chocolates -ID- 163",
+    "Cloros -ID- 263",
+    "Coloracion y Tinturas -ID- 209",
+    "Condimentos -ID- 189",
+    "Confites -ID- 164",
+    "Conservas De Frutas -ID- 149",
+    "Conservas De Pescados -ID- 153",
+    "Conservas De Verduras -ID- 180",
+    "Cremas Manjar y Leche Cond -ID- 184",
+    "Cuidado Femenino -ID- 212",
+    "Desodorante Colonia y Talco -ID- 183",
+    "Desodorantes Ambientales -ID- 188",
+    "Detergentes y Suavizantes -ID- 182",
+    "Fideos Y Pastas -ID- 156",
+    "Fosforos Velas y Carbon -ID- 165",
+    "Fruta y Verdura Congelados -ID- 264",
+    "Frutas -ID- 145",
+    "Frutos Secos -ID- 227",
+    "Galletas -ID- 162",
+    "Harinas Y Polvos Hornear -ID- 150",
+    "Helados -ID- 193",
+    "Higiene bucal -ID- 206",
+    "Huevos -ID- 194",
+    "Insecticidas Y Antiplaga -ID- 216",
+    "Jabones y Cremas -ID- 172",
+    "Jugos en Polvo -ID- 173",
+    "Jugos y Nectares -ID- 199",
+    "Lavalozas y Esponjas -ID- 196",
+    "Leche En Polvo Y Suplementos -ID- 195",
+    "Leches Liquidas -ID- 157",
+    "Legumbres Y Pure -ID- 197",
+    "Licores -ID- 198",
+    "Limpiadores piso y Ceras -ID- 207",
+    "Limpiadores varios -ID- 217",
+    "Mantencion -ID- 247",
+    "Mantequilla Y Margarina -ID- 169",
+    "Masas Y Pastas Frescas -ID- 249",
+    "Mascota -ID- 175",
+    "Menaje -ID- 259",
+    "Mermeladas Y Dulces -ID- 187",
+    "Otras Carnes Envasadas -ID- 174",
+    "Otras Carnes Granel -ID- 141",
+    "Pan Envasado -ID- 179",
+    "Pan Granel -ID- 200",
+    "Panal Adulto -ID- 218",
+    "Panales Bebe -ID- 219",
+    "Panuelos Desechables -ID- 221",
+    "Papas Fritas y Snacks -ID- 154",
+    "Papel Higienicos -ID- 151",
+    "Pasteleria -ID- 144",
+    "Pescaderia -ID- 253",
+    "Platos Precocinados -ID- 201",
+    "Postres En Polvo -ID- 255",
+    "Postres Frescos -ID- 181",
+    "Productos Congelados -ID- 168",
+    "Productos Naturales -ID- 256",
+    "Queso Envasado -ID- 177",
+    "Quesos Granel -ID- 143",
+    "Quesos Rallados -ID- 185",
+    "Salsas De Tomates -ID- 178",
+    "Shampoo y Acondicionador -ID- 191",
+    "Sopas Y Caldos -ID- 186",
+    "Te Hierbas E Infusiones -ID- 190",
+    "Toalla De Papel Y Servilletas -ID- 152",
+    "Vacuno Envasado -ID- 160",
+    "Verdura -ID- 146",
+    "Vino caja y botellon -ID- 266",
+    "Vino tinto y blanco -ID- 202",
+    "Yoghurt -ID- 159"
+  ],
+  "filename_column": "filename",
+  "num_classes": 90,
+  "image_size": 800
+}

vit_multiclass_model_best/config.json

@@ -0,0 +1,208 @@
+{
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2",
+    "3": "LABEL_3",
+    "4": "LABEL_4",
+    "5": "LABEL_5",
+    "6": "LABEL_6",
+    "7": "LABEL_7",
+    "8": "LABEL_8",
+    "9": "LABEL_9",
+    "10": "LABEL_10",
+    "11": "LABEL_11",
+    "12": "LABEL_12",
+    "13": "LABEL_13",
+    "14": "LABEL_14",
+    "15": "LABEL_15",
+    "16": "LABEL_16",
+    "17": "LABEL_17",
+    "18": "LABEL_18",
+    "19": "LABEL_19",
+    "20": "LABEL_20",
+    "21": "LABEL_21",
+    "22": "LABEL_22",
+    "23": "LABEL_23",
+    "24": "LABEL_24",
+    "25": "LABEL_25",
+    "26": "LABEL_26",
+    "27": "LABEL_27",
+    "28": "LABEL_28",
+    "29": "LABEL_29",
+    "30": "LABEL_30",
+    "31": "LABEL_31",
+    "32": "LABEL_32",
+    "33": "LABEL_33",
+    "34": "LABEL_34",
+    "35": "LABEL_35",
+    "36": "LABEL_36",
+    "37": "LABEL_37",
+    "38": "LABEL_38",
+    "39": "LABEL_39",
+    "40": "LABEL_40",
+    "41": "LABEL_41",
+    "42": "LABEL_42",
+    "43": "LABEL_43",
+    "44": "LABEL_44",
+    "45": "LABEL_45",
+    "46": "LABEL_46",
+    "47": "LABEL_47",
+    "48": "LABEL_48",
+    "49": "LABEL_49",
+    "50": "LABEL_50",
+    "51": "LABEL_51",
+    "52": "LABEL_52",
+    "53": "LABEL_53",
+    "54": "LABEL_54",
+    "55": "LABEL_55",
+    "56": "LABEL_56",
+    "57": "LABEL_57",
+    "58": "LABEL_58",
+    "59": "LABEL_59",
+    "60": "LABEL_60",
+    "61": "LABEL_61",
+    "62": "LABEL_62",
+    "63": "LABEL_63",
+    "64": "LABEL_64",
+    "65": "LABEL_65",
+    "66": "LABEL_66",
+    "67": "LABEL_67",
+    "68": "LABEL_68",
+    "69": "LABEL_69",
+    "70": "LABEL_70",
+    "71": "LABEL_71",
+    "72": "LABEL_72",
+    "73": "LABEL_73",
+    "74": "LABEL_74",
+    "75": "LABEL_75",
+    "76": "LABEL_76",
+    "77": "LABEL_77",
+    "78": "LABEL_78",
+    "79": "LABEL_79",
+    "80": "LABEL_80",
+    "81": "LABEL_81",
+    "82": "LABEL_82",
+    "83": "LABEL_83",
+    "84": "LABEL_84",
+    "85": "LABEL_85",
+    "86": "LABEL_86",
+    "87": "LABEL_87",
+    "88": "LABEL_88",
+    "89": "LABEL_89"
+  },
+  "image_size": 800,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_10": 10,
+    "LABEL_11": 11,
+    "LABEL_12": 12,
+    "LABEL_13": 13,
+    "LABEL_14": 14,
+    "LABEL_15": 15,
+    "LABEL_16": 16,
+    "LABEL_17": 17,
+    "LABEL_18": 18,
+    "LABEL_19": 19,
+    "LABEL_2": 2,
+    "LABEL_20": 20,
+    "LABEL_21": 21,
+    "LABEL_22": 22,
+    "LABEL_23": 23,
+    "LABEL_24": 24,
+    "LABEL_25": 25,
+    "LABEL_26": 26,
+    "LABEL_27": 27,
+    "LABEL_28": 28,
+    "LABEL_29": 29,
+    "LABEL_3": 3,
+    "LABEL_30": 30,
+    "LABEL_31": 31,
+    "LABEL_32": 32,
+    "LABEL_33": 33,
+    "LABEL_34": 34,
+    "LABEL_35": 35,
+    "LABEL_36": 36,
+    "LABEL_37": 37,
+    "LABEL_38": 38,
+    "LABEL_39": 39,
+    "LABEL_4": 4,
+    "LABEL_40": 40,
+    "LABEL_41": 41,
+    "LABEL_42": 42,
+    "LABEL_43": 43,
+    "LABEL_44": 44,
+    "LABEL_45": 45,
+    "LABEL_46": 46,
+    "LABEL_47": 47,
+    "LABEL_48": 48,
+    "LABEL_49": 49,
+    "LABEL_5": 5,
+    "LABEL_50": 50,
+    "LABEL_51": 51,
+    "LABEL_52": 52,
+    "LABEL_53": 53,
+    "LABEL_54": 54,
+    "LABEL_55": 55,
+    "LABEL_56": 56,
+    "LABEL_57": 57,
+    "LABEL_58": 58,
+    "LABEL_59": 59,
+    "LABEL_6": 6,
+    "LABEL_60": 60,
+    "LABEL_61": 61,
+    "LABEL_62": 62,
+    "LABEL_63": 63,
+    "LABEL_64": 64,
+    "LABEL_65": 65,
+    "LABEL_66": 66,
+    "LABEL_67": 67,
+    "LABEL_68": 68,
+    "LABEL_69": 69,
+    "LABEL_7": 7,
+    "LABEL_70": 70,
+    "LABEL_71": 71,
+    "LABEL_72": 72,
+    "LABEL_73": 73,
+    "LABEL_74": 74,
+    "LABEL_75": 75,
+    "LABEL_76": 76,
+    "LABEL_77": 77,
+    "LABEL_78": 78,
+    "LABEL_79": 79,
+    "LABEL_8": 8,
+    "LABEL_80": 80,
+    "LABEL_81": 81,
+    "LABEL_82": 82,
+    "LABEL_83": 83,
+    "LABEL_84": 84,
+    "LABEL_85": 85,
+    "LABEL_86": 86,
+    "LABEL_87": 87,
+    "LABEL_88": 88,
+    "LABEL_89": 89,
+    "LABEL_9": 9
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "pooler_act": "tanh",
+  "pooler_output_size": 768,
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.53.2"
+}

vit_multiclass_model_best/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:629898a09e7594f8a4871f08454bd52051072bb1644fa63e09512489c7b5067b
+size 350572584

vit_multiclass_model_best/processor_config.json

@@ -0,0 +1,18 @@
+{
+  "target_size": 800,
+  "padding_color": [
+    128,
+    128,
+    128
+  ],
+  "mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "std": [
+    0.229,
+    0.224,
+    0.225
+  ]
+}