Update handler.py

handler.py

@@ -5,563 +5,273 @@ from PIL import Image
 import numpy as np
 import pandas as pd
 from pathlib import Path
-from collections import defaultdict
-import requests
 import json
 from io import BytesIO
-import os
-from redes_prototipicas_tvt5 import ConvEncoder, PrototypicalNetwork
 import boto3
 from botocore.exceptions import ClientError
 from huggingface_hub import hf_hub_download
 
-def load_image_from_s3_direct(bucket_name, s3_key, s3_client):
-	"""Cargar imagen directamente desde S3 usando boto3 (RECOMENDADO)"""
-	try:
-		print(f"🔄 Cargando imagen desde S3...")
-		print(f"📦 Bucket: {bucket_name}")
-		print(f"🗝️  Key: {s3_key}")
-		
-		# Descargar objeto desde S3
-		response = s3_client.get_object(Bucket=bucket_name, Key=s3_key)
-		
-		# Leer contenido y convertir a imagen
-		image_data = response['Body'].read()
-		bbox_image = Image.open(BytesIO(image_data)).convert('RGB')
-		
-		print("✅ Imagen cargada exitosamente")
-		return bbox_image
-		
-	except ClientError as e:
-		error_code = e.response['Error']['Code']
-		if error_code == 'NoSuchKey':
-			print(f"❌ La imagen no existe en S3: {s3_key}")
-		elif error_code == 'NoSuchBucket':
-			print(f"❌ El bucket no existe: {bucket_name}")
-		elif error_code == 'AccessDenied':
-			print(f"❌ Sin permisos para acceder a: {s3_key}")
-		else:
-			print(f"❌ Error de S3: {e}")
-		return None
-		
-	except Exception as e:
-		print(f"❌ Error cargando imagen: {e}")
-		return None
+# Imports desde el código de entrenamiento actualizado
+from redes_prototipicas_tvt5 import ConvEncoder, PrototypicalNetwork, SmartPadResize
 
 def load_image_from_s3_url(s3_url, s3_client):
-	"""Cargar imagen desde S3 extrayendo bucket y key de la URL"""
-	try:
-		# Extraer bucket y key de la URL
-		# URL formato: https://bucket-name.s3.amazonaws.com/path/to/file.jpg
-		url_parts = s3_url.replace('https://', '').split('/')
-		bucket = url_parts[0].split('.s3.amazonaws.com')[0]
-		key = '/'.join(url_parts[1:])
-		
-		return load_image_from_s3_direct(bucket, key, s3_client)
-		
-	except Exception as e:
-		print(f"❌ Error procesando URL: {e}")
-		return None
+    """Cargar imagen desde S3 extrayendo bucket y key de la URL"""
+    try:
+        url_parts = s3_url.replace('https://', '').split('/')
+        bucket = url_parts[0].split('.s3.amazonaws.com')[0]
+        key = '/'.join(url_parts[1:])
+        
+        response = s3_client.get_object(Bucket=bucket, Key=key)
+        image_data = response['Body'].read()
+        return Image.open(BytesIO(image_data)).convert('RGB')
+    except Exception as e:
+        print(f"❌ Error cargando imagen: {e}")
+        return None
 
 def model_selector(self, model_category):
-	if model_category == 182:
-		encoder, class_names, prototypes, eval_transform = self.encoder_detergentes, self.class_names_detergentes, self.prototypes_detergentes, self.eval_transform_detergentes
-	elif model_category == 175:
-		encoder, class_names, prototypes, eval_transform = self.encoder_mascotas, self.class_names_mascotas, self.prototypes_mascotas, self.eval_transform_mascotas
-	elif model_category == 202:
-		encoder, class_names, prototypes, eval_transform = self.encoder_vinos, self.class_names_vinos, self.prototypes_vinos, self.eval_transform_vinos
-	elif model_category == 161:
-		encoder, class_names, prototypes, eval_transform = self.encoder_cecinas, self.class_names_cecinas, self.prototypes_cecinas, self.eval_transform_cecinas
-	elif model_category == 198:
-		encoder, class_names, prototypes, eval_transform = self.encoder_licores, self.class_names_licores, self.prototypes_licores, self.eval_transform_licores
+    """Seleccionar modelo según categoría"""
+    models = {
+        182: (self.encoder_detergentes, self.class_names_detergentes, self.prototypes_detergentes, self.eval_transform_detergentes),
+        175: (self.encoder_mascotas, self.class_names_mascotas, self.prototypes_mascotas, self.eval_transform_mascotas),
+        202: (self.encoder_vinos, self.class_names_vinos, self.prototypes_vinos, self.eval_transform_vinos),
+        161: (self.encoder_cecinas, self.class_names_cecinas, self.prototypes_cecinas, self.eval_transform_cecinas),
+        198: (self.encoder_licores, self.class_names_licores, self.prototypes_licores, self.eval_transform_licores)
+    }
+    return models.get(model_category)
 
-	return encoder, class_names, prototypes, eval_transform
-
-# 🆕 NUEVA FUNCIÓN: Configuración de umbrales OOD por categoría
 def get_ood_thresholds(model_category):
-	"""
-	Configuración de umbrales OOD específicos por categoría de modelo
-	Estos valores pueden ajustarse según la performance de cada modelo
-	"""
-	ood_config = {
-		182: {  # detergentes
-			'similarity_threshold': 0.65,
-			'distance_threshold': 0.85,
-			'confidence_penalty': 0.1
-		},
-		175: {  # mascotas
-			'similarity_threshold': 0.62,
-			'distance_threshold': 0.90,
-			'confidence_penalty': 0.1
-		},
-		202: {  # vinos
-			'similarity_threshold': 0.68,
-			'distance_threshold': 0.80,
-			'confidence_penalty': 0.1
-		},
-		161: {  # cecinas
-			'similarity_threshold': 0.64,
-			'distance_threshold': 0.88,
-			'confidence_penalty': 0.1
-		},
-		198: {  # licores
-			'similarity_threshold': 0.66,
-			'distance_threshold': 0.85,
-			'confidence_penalty': 0.1
-		}
-	}
-	
-	# Configuración por defecto si no se encuentra la categoría
-	default_config = {
-		'similarity_threshold': 0.65,
-		'distance_threshold': 0.85,
-		'confidence_penalty': 0.1
-	}
-	
-	return ood_config.get(model_category, default_config)
+    """Umbrales OOD para modelos 512px"""
+    config = {
+        182: {'similarity_threshold': 0.70, 'distance_threshold': 0.80},  # detergentes
+        175: {'similarity_threshold': 0.68, 'distance_threshold': 0.85},  # mascotas
+        202: {'similarity_threshold': 0.72, 'distance_threshold': 0.75},  # vinos
+        161: {'similarity_threshold': 0.69, 'distance_threshold': 0.82},  # cecinas
+        198: {'similarity_threshold': 0.71, 'distance_threshold': 0.78}   # licores
+    }
+    return config.get(model_category, {'similarity_threshold': 0.70, 'distance_threshold': 0.80})
 
-# 🆕 NUEVA FUNCIÓN: Detección OOD
-def detect_out_of_distribution(query_features, prototypes, ood_config, class_names):
-	"""
-	Detecta si una muestra está fuera de distribución usando múltiples métricas
-	
-	Args:
-		query_features: Features de la imagen query (tensor)
-		prototypes: Prototipos del modelo (tensor)
-		ood_config: Configuración de umbrales
-		class_names: Nombres de las clases
-	
-	Returns:
-		is_ood: bool - True si es OOD
-		ood_score: float - Puntuación de confianza (0=muy OOD, 1=muy in-distribution)
-		ood_reason: str - Razón de la decisión
-	"""
-	
-	# 1. Calcular similitud coseno con todos los prototipos
-	similarities = torch.mm(query_features, prototypes.t()).squeeze(0)
-	max_similarity = similarities.max().item()
-	
-	# 2. Calcular distancia euclidiana al prototipo más cercano
-	distances = torch.cdist(query_features, prototypes).squeeze(0)
-	min_distance = distances.min().item()
-	
-	# 3. Aplicar umbrales
-	similarity_threshold = ood_config['similarity_threshold']
-	distance_threshold = ood_config['distance_threshold']
-	confidence_penalty = ood_config['confidence_penalty']
-	
-	# 4. Decisión OOD basada en múltiples criterios
-	is_ood = False
-	ood_reasons = []
-	
-	# Criterio 1: Similitud muy baja
-	if max_similarity < similarity_threshold:
-		is_ood = True
-		ood_reasons.append(f"similitud_baja({max_similarity:.3f}<{similarity_threshold})")
-	
-	# Criterio 2: Distancia muy alta
-	if min_distance > distance_threshold:
-		is_ood = True
-		ood_reasons.append(f"distancia_alta({min_distance:.3f}>{distance_threshold})")
-	
-	# 5. Calcular puntuación de confianza OOD
-	# Combinamos similitud y distancia en una métrica unificada
-	similarity_score = max_similarity  # 0-1, más alto = mejor
-	distance_score = max(0, (distance_threshold - min_distance) / distance_threshold)  # 0-1, más alto = mejor
-	
-	# Promedio ponderado (puedes ajustar los pesos)
-	ood_score = (0.7 * similarity_score + 0.3 * distance_score)
-	
-	# Aplicar penalización si es OOD
-	if is_ood:
-		ood_score = max(0, ood_score - confidence_penalty)
-	
-	# 6. Crear razón legible
-	if is_ood:
-		ood_reason = f"OOD_DETECTED: {', '.join(ood_reasons)}"
-	else:
-		ood_reason = f"IN_DISTRIBUTION: sim={max_similarity:.3f}, dist={min_distance:.3f}"
-	
-	return is_ood, ood_score, ood_reason
+def detect_out_of_distribution(query_features, prototypes, ood_config):
+    """Detección OOD simplificada"""
+    similarities = torch.mm(query_features, prototypes.t()).squeeze(0)
+    max_similarity = similarities.max().item()
+    
+    distances = torch.cdist(query_features, prototypes).squeeze(0)
+    min_distance = distances.min().item()
+    
+    # Criterios OOD
+    is_ood = (max_similarity < ood_config['similarity_threshold'] or 
+              min_distance > ood_config['distance_threshold'])
+    
+    # Score combinado
+    similarity_score = max_similarity
+    distance_score = max(0, (ood_config['distance_threshold'] - min_distance) / ood_config['distance_threshold'])
+    ood_score = (0.7 * similarity_score + 0.3 * distance_score)
+    
+    if is_ood:
+        ood_score = max(0, ood_score - 0.05)
+    
+    return is_ood, ood_score
 
-# ✅ NUEVA FUNCIÓN OPTIMIZADA: Cargar modelo sin necesidad de dataset
 def load_classification_model_optimized(model_path, device):
-	"""Versión optimizada que carga prototipos directamente del modelo guardado"""
-	
-	if not Path(model_path).exists():
-		raise FileNotFoundError(f"❌ No se encontró el modelo: {model_path}")
-	
-	print(f"✅ Cargando modelo optimizado: {model_path}")
-	
-	# Cargar checkpoint
-	checkpoint = torch.load(model_path, map_location=device, weights_only=False)
-	
-	# Verificar que el modelo tiene prototipos guardados
-	if 'prototypes' not in checkpoint or 'class_names' not in checkpoint:
-		raise ValueError("❌ El modelo no contiene prototipos guardados. Necesitas re-entrenar con la versión actualizada del código.")
-	
-	# Cargar configuración del modelo
-	model_config = checkpoint.get('model_config', {})
-	hidden_dim = model_config.get('hidden_dim', 64)
-	output_dim = model_config.get('output_dim', 256)
-	
-	# Cargar arquitectura del modelo
-	encoder = ConvEncoder(hidden_dim=hidden_dim, output_dim=output_dim).to(device)
-	model = PrototypicalNetwork(encoder).to(device)
-	
-	# Cargar pesos
-	encoder.load_state_dict(checkpoint['encoder_state_dict'])
-	model.load_state_dict(checkpoint['model_state_dict'])
-	encoder.eval()
-	model.eval()
-	
-	# ✅ Cargar prototipos y clases guardados
-	prototypes = checkpoint['prototypes'].to(device)
-	class_names = checkpoint['class_names']
-	
-	print(f"✅ Modelo cargado correctamente:")
-	print(f"   - Prototipos: {len(class_names)} clases")
-	print(f"   - Dimensión: {prototypes.shape}")
-	print(f"   - Clases: {', '.join(class_names[:5])}{'...' if len(class_names) > 5 else ''}")
-	
-	# Transformaciones para evaluación (mismas que en entrenamiento)
-	eval_transform = transforms.Compose([
-		transforms.Resize((224, 224)),
-		transforms.ToTensor(),
-		transforms.Normalize(mean=[0.485, 0.456, 0.406], 
-						   std=[0.229, 0.224, 0.225])
-	])
-	
-	return encoder, class_names, prototypes, eval_transform
+    """Cargar modelo 512px únicamente"""
+    checkpoint = torch.load(model_path, map_location=device, weights_only=False)
+    
+    if 'prototypes' not in checkpoint or 'class_names' not in checkpoint:
+        raise ValueError("❌ Modelo sin prototipos. Re-entrena con código actualizado.")
+    
+    # Configuración del modelo
+    model_config = checkpoint.get('model_config', {})
+    hidden_dim = model_config.get('hidden_dim', 64)
+    output_dim = model_config.get('output_dim', 256)
+    image_size = model_config.get('image_size', 512)
+    
+    print(f"📊 Cargando modelo {image_size}px: {len(checkpoint['class_names'])} clases")
+    
+    # Cargar arquitectura y pesos
+    encoder = ConvEncoder(hidden_dim=hidden_dim, output_dim=output_dim).to(device)
+    model = PrototypicalNetwork(encoder).to(device)
+    
+    encoder.load_state_dict(checkpoint['encoder_state_dict'])
+    model.load_state_dict(checkpoint['model_state_dict'])
+    encoder.eval()
+    model.eval()
+    
+    # Prototipos y clases
+    prototypes = checkpoint['prototypes'].to(device)
+    class_names = checkpoint['class_names']
+    
+    # Transformaciones 512px con SmartPadResize
+    eval_transform = transforms.Compose([
+        SmartPadResize(target_size=image_size, fill_value=128),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+    
+    return encoder, class_names, prototypes, eval_transform
 
 def load_json_from_s3(json_s3_url):
-	# Configuración S3
-	aws_access_key = 'AKIA6BH4GPXQCUZ3PAX5'  # Cambiar por tu access key
-	aws_secret_key = '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'  # Cambiar por tu secret key
-	region_name = 'us-east-1'  # Cambiar por tu región
-	S3_BUCKET_NAME = 'rocketpin-ml-data'  # Cambiar por tu bucket
-
-	# Crear sesión y cliente S3
-	session = boto3.Session(
-		aws_access_key_id=aws_access_key,
-		aws_secret_access_key=aws_secret_key,
-		region_name=region_name
-	)
-	s3_client = session.client('s3')
+    """Cargar JSON desde S3"""
+    session = boto3.Session(
+        aws_access_key_id='AKIA6BH4GPXQCUZ3PAX5',
+        aws_secret_access_key='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',
+        region_name='us-east-1'
+    )
+    s3_client = session.client('s3')
 
-	"""Cargar JSON desde S3 usando la URL completa"""
-	try:
-		# Extraer bucket y key de la URL
-		# URL formato: https://bucket-name.s3.amazonaws.com/path/to/file.json
-		url_parts = json_s3_url.replace('https://', '').split('/')
-		bucket = url_parts[0].split('.s3.amazonaws.com')[0]
-		key = '/'.join(url_parts[1:])
-		
-		# Descargar objeto desde S3
-		response = s3_client.get_object(Bucket=bucket, Key=key)
-		
-		# Leer contenido y convertir a JSON
-		json_content = response['Body'].read().decode('utf-8')
-		json_data = json.loads(json_content)
-		
-		print("✅ JSON cargado exitosamente")
-		return json_data, s3_client
-		
-	except ClientError as e:
-		error_code = e.response['Error']['Code']
-		if error_code == 'NoSuchKey':
-			print(f"❌ El archivo no existe en S3: {key}")
-		elif error_code == 'NoSuchBucket':
-			print(f"❌ El bucket no existe: {bucket}")
-		else:
-			print(f"❌ Error de S3: {e}")
-		return None
-		
-	except Exception as e:
-		print(f"❌ Error cargando JSON: {e}")
-		return None
+    try:
+        url_parts = json_s3_url.replace('https://', '').split('/')
+        bucket = url_parts[0].split('.s3.amazonaws.com')[0]
+        key = '/'.join(url_parts[1:])
+        
+        response = s3_client.get_object(Bucket=bucket, Key=key)
+        json_content = response['Body'].read().decode('utf-8')
+        return json.loads(json_content), s3_client
+    except Exception as e:
+        print(f"❌ Error cargando JSON: {e}")
+        return None, None
 
 def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_transform, device, minimal_accuracy, s3_client, model_category):
-	"""
-	🆕 MEJORADO: Clasificar las imágenes de bounding boxes guardadas CON DETECCIÓN OOD
-	"""
-	
-	if not saved_images:
-		print("❌ No hay imágenes guardadas para clasificar")
-		return pd.DataFrame()
-	
-	print(f"🔄 Clasificando {len(saved_images)} imágenes guardadas...")
-	print(f"🎯 Filtro minimal_accuracy: {minimal_accuracy}")
-	
-	# 🆕 Obtener configuración OOD para esta categoría
-	ood_config = get_ood_thresholds(model_category)
-	print(f"🛡️  Detección OOD activada:")
-	print(f"   - Umbral similitud: {ood_config['similarity_threshold']}")
-	print(f"   - Umbral distancia: {ood_config['distance_threshold']}")
-	
-	results = []
-	filtered_count = 0
-	ood_detected_count = 0
-	
-	with torch.no_grad():
-		for img_info in saved_images:
-			try:
-				# Cargar imagen guardada
-				bbox_image = load_image_from_s3_url(img_info['bbox_path'], s3_client)
-				
-				if bbox_image is None:
-					print(f"❌ No se pudo cargar imagen: {img_info['bbox_path']}")
-					continue
-				
-				# Transformar para el modelo
-				query_tensor = eval_transform(bbox_image).unsqueeze(0).to(device)
-				
-				# Extraer características
-				query_features = encoder(query_tensor)
-				# Normalizar
-				query_features = F.normalize(query_features, p=2, dim=1)
-				
-				# 🆕 DETECCIÓN OOD
-				is_ood, ood_score, ood_reason = detect_out_of_distribution(
-					query_features, prototypes, ood_config, class_names
-				)
-				
-				# 🆕 Si es OOD, manejar de forma especial
-				if is_ood:
-					ood_detected_count += 1
-					print(f"🚨 OOD detectado en bbox {img_info['bbox_id']}: {ood_reason}")
-					
-					# Opción 1: Filtrar completamente (recomendado)
-					filtered_count += 1
-					continue
-					
-					# Opción 2: Marcar como "PRODUCTO_DESCONOCIDO" (opcional - descomenta si prefieres esto)
-					# result = {
-					# 	'sku_bb_id': str(img_info['bbox_id']),
-					# 	'predictions': ['PRODUCTO_DESCONOCIDO'],
-					# 	'accuracy': [round(ood_score, 4)],
-					# 	'prediccion_principal': 'PRODUCTO_DESCONOCIDO',
-					# 	'similarity_principal': f"{ood_score*100:.2f}%",
-					# 	'bbox_confidence': round(float(img_info['confidence']), 4),
-					# 	'ood_detected': True,
-					# 	'ood_reason': ood_reason,
-					# 	'xmin': img_info['x_min'],
-					# 	'ymin': img_info['y_min'],
-					# 	'xmax': img_info['x_max'],
-					# 	'ymax': img_info['y_max']
-					# }
-					# results.append(result)
-					# continue
-				
-				# Calcular similitud coseno con prototipos guardados (solo si no es OOD)
-				similarities = torch.mm(query_features, prototypes.t())
-				similarities_numpy = similarities.cpu().numpy()[0]
-				
-				# Obtener top 3 predicciones
-				top3_indices = np.argsort(similarities_numpy)[::-1]
-				top3_predictions = []
-				top3_similarities = []
-				
-				for idx_pred in top3_indices:
-					prediction = class_names[idx_pred]
-					similarity = similarities_numpy[idx_pred]
-					# Solo agregar si cumple con minimal_accuracy
-					if similarity >= minimal_accuracy:
-						top3_predictions.append(prediction)
-						top3_similarities.append(round(similarity, 4))
-				
-				# Si no hay predicciones que cumplan con minimal_accuracy, saltar
-				if len(top3_predictions) == 0:
-					filtered_count += 1
-					print(f"🔽 Bbox {img_info['bbox_id']} filtrado: ninguna predicción cumple minimal_accuracy {minimal_accuracy}")
-					continue
-				
-				# 🆕 Aplicar ajuste de confianza basado en OOD score
-				adjusted_similarities = []
-				for sim in top3_similarities:
-					# Combinar similarity original con OOD confidence
-					adjusted_sim = (sim * 0.8) + (ood_score * 0.2)  # Peso 80-20
-					adjusted_similarities.append(round(adjusted_sim, 4))
-				
-				# Guardar predictions y accuracy como listas (solo las que cumplen el filtro)
-				predictions_list = top3_predictions
-				similarities_list = adjusted_similarities  # 🆕 Usar similarities ajustadas
-				
-				# La predicción principal es la primera de la lista filtrada
-				predicted_class = predictions_list[0]
-				
-				# Formatear similarity_principal como porcentaje
-				similarity_principal_formatted = f"{similarities_list[0]*100:.2f}%"
-				
-				# Formatear bbox_confidence con 4 decimales
-				bbox_confidence_formatted = round(float(img_info['confidence']), 4)
-				
-				# 🆕 Agregar resultado con información OOD
-				result = {
-					'sku_bb_id': str(img_info['bbox_id']),
-					'predictions': predictions_list,
-					'accuracy': similarities_list,
-					'prediccion_principal': predicted_class,
-					'similarity_principal': similarity_principal_formatted,
-					'bbox_confidence': bbox_confidence_formatted,
-					'ood_detected': False,  # 🆕 No es OOD
-					'ood_score': round(ood_score, 4),  # 🆕 Puntuación OOD
-					'xmin': img_info['x_min'],
-					'ymin': img_info['y_min'],
-					'xmax': img_info['x_max'],
-					'ymax': img_info['y_max']
-				}
-				
-				results.append(result)
-				
-			except Exception as e:
-				print(f"❌ Error clasificando bbox {str(img_info['bbox_id'])}: {e}")
-				# Agregar entrada de error
-				results.append({
-					'sku_bb_id': str(img_info['bbox_id']),
-					'predictions': ['ERROR'],
-					'accuracy': [0.0000],
-					'prediccion_principal': 'ERROR',
-					'similarity_principal': 'ERROR',
-					'bbox_confidence': round(float(img_info['confidence']), 4),
-					'ood_detected': False,
-					'ood_score': 0.0000,
-					'xmin': img_info['x_min'],
-					'ymin': img_info['y_min'],
-					'xmax': img_info['x_max'],
-					'ymax': img_info['y_max']
-				})
-	
-	# 🆕 Resumen mejorado con estadísticas OOD
-	if filtered_count > 0 or ood_detected_count > 0:
-		print(f"📊 Resumen de filtrado:")
-		print(f"   - Detecciones procesadas: {len(results)}")
-		print(f"   - Detecciones filtradas por accuracy: {filtered_count - ood_detected_count}")
-		print(f"   - 🆕 Detecciones OOD filtradas: {ood_detected_count}")
-		print(f"   - Total filtrado: {filtered_count}")
-		print(f"   - Total original: {len(saved_images)}")
-		if ood_detected_count > 0:
-			ood_percentage = (ood_detected_count / len(saved_images)) * 100
-			print(f"   - 🆕 Porcentaje OOD: {ood_percentage:.1f}%")
-	
-	return pd.DataFrame(results)
+    """Clasificación con detección OOD"""
+    if not saved_images:
+        return pd.DataFrame()
+    
+    print(f"🔄 Clasificando {len(saved_images)} imágenes...")
+    
+    ood_config = get_ood_thresholds(model_category)
+    results = []
+    filtered_count = 0
+    ood_count = 0
+    
+    with torch.no_grad():
+        for img_info in saved_images:
+            try:
+                # Cargar y transformar imagen
+                bbox_image = load_image_from_s3_url(img_info['bbox_path'], s3_client)
+                if bbox_image is None:
+                    continue
+                
+                query_tensor = eval_transform(bbox_image).unsqueeze(0).to(device)
+                query_features = F.normalize(encoder(query_tensor), p=2, dim=1)
+                
+                # Detección OOD
+                is_ood, ood_score = detect_out_of_distribution(query_features, prototypes, ood_config)
+                
+                if is_ood:
+                    ood_count += 1
+                    filtered_count += 1
+                    continue
+                
+                # Calcular similitudes
+                similarities = torch.mm(query_features, prototypes.t()).cpu().numpy()[0]
+                top3_indices = np.argsort(similarities)[::-1]
+                
+                # Filtrar por minimal_accuracy
+                predictions = []
+                accuracies = []
+                
+                for idx in top3_indices:
+                    if similarities[idx] >= minimal_accuracy:
+                        predictions.append(class_names[idx])
+                        accuracies.append(round(similarities[idx], 4))
+                
+                if not predictions:
+                    filtered_count += 1
+                    continue
+                
+                # Ajustar con OOD score
+                adjusted_accuracies = [round((acc * 0.9) + (ood_score * 0.1), 4) for acc in accuracies]
+                
+                result = {
+                    'sku_bb_id': str(img_info['bbox_id']),
+                    'predictions': predictions,
+                    'accuracy': adjusted_accuracies,
+                    'prediccion_principal': predictions[0],
+                    'similarity_principal': f"{adjusted_accuracies[0]*100:.2f}%",
+                    'bbox_confidence': round(float(img_info['confidence']), 4),
+                    'ood_score': round(ood_score, 4),
+                    'xmin': img_info['x_min'],
+                    'ymin': img_info['y_min'],
+                    'xmax': img_info['x_max'],
+                    'ymax': img_info['y_max']
+                }
+                results.append(result)
+                
+            except Exception as e:
+                print(f"❌ Error en bbox {img_info['bbox_id']}: {e}")
+                continue
+    
+    print(f"📊 Procesadas: {len(results)}, Filtradas: {filtered_count}, OOD: {ood_count}")
+    return pd.DataFrame(results)
 
 def process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_accuracy, model_path, train_path, model_category, json_s3_url):
-	"""Función principal para procesar una imagen: detectar BB, guardar recortes y clasificar"""
-	
-	print("="*80)
-	print("PROCESAMIENTO DE IMAGEN CON BOUNDING BOXES - MODELO OPTIMIZADO V5 + OOD")
-	print("="*80)
-	print(f"📸 Imagen: {image_url}")
-	print(f"🆔 Picture ID: {picture_id}")
-	
-	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-	print(f"💻 Dispositivo: {device}")
-	print(f"🎯 Filtro minimal_accuracy: {minimal_accuracy}")
-	print(f"🛡️  Detección OOD activada para categoría: {model_category}")  # 🆕
-	
-	# Cargar bounding boxes desde S3
-	saved_images, s3_client = load_json_from_s3(json_s3_url)
-	saved_images = saved_images['bounding_boxes']
-
-	if not saved_images:
-		print("❌ No se pudieron cargar las imágenes desde S3")
-		return pd.DataFrame()
-	
-	# 3. Cargar modelo de clasificación (OPTIMIZADO)
-	print("\n🤖 PASO 3: Cargando modelo de clasificación optimizado...")
-	try:
-		encoder, class_names, prototypes, eval_transform = model_selector(self, model_category)
-	except Exception as e:
-		print(f"❌ Error cargando modelo: {e}")
-		return pd.DataFrame()
-	
-	# 4. Clasificar imágenes guardadas CON DETECCIÓN OOD
-	print("\n🔬 PASO 4: Clasificando imágenes guardadas con detección OOD...")
-	results_df = classify_saved_bboxes(
-		saved_images, encoder, class_names, prototypes, eval_transform, device,
-		minimal_accuracy, s3_client, model_category  # 🆕 Pasar model_category
-	)
-	
-	# 5. Mostrar resumen
-	if not results_df.empty:
-		print(f"\n✅ Procesamiento completado:")
-		print(f"   - Total de detecciones procesadas: {len(results_df)}")
-		print(f"   - Clases detectadas: {results_df['prediccion_principal'].nunique()}")
-		print(f"   - Clases únicas encontradas: {', '.join(results_df['prediccion_principal'].unique())}")
-		
-		# 🆕 Estadísticas OOD
-		if 'ood_score' in results_df.columns:
-			avg_ood_score = results_df['ood_score'].mean()
-			min_ood_score = results_df['ood_score'].min()
-			max_ood_score = results_df['ood_score'].max()
-			print(f"\n🛡️  Estadísticas OOD:")
-			print(f"   - OOD Score promedio: {avg_ood_score:.4f}")
-			print(f"   - OOD Score mínimo: {min_ood_score:.4f}")
-			print(f"   - OOD Score máximo: {max_ood_score:.4f}")
-		
-		# Top predicciones
-		print(f"\n📊 Top predicciones:")
-		top_predictions = results_df['prediccion_principal'].value_counts().head(5)
-		for clase, count in top_predictions.items():
-			print(f"   - {clase}: {count} detecciones")
-			
-		# Estadísticas de accuracy
-		if len(results_df) > 0:
-			avg_accuracy = results_df['accuracy'].apply(lambda x: x[0] if isinstance(x, list) and len(x) > 0 else 0).mean()
-			min_accuracy = results_df['accuracy'].apply(lambda x: x[0] if isinstance(x, list) and len(x) > 0 else 0).min()
-			max_accuracy = results_df['accuracy'].apply(lambda x: x[0] if isinstance(x, list) and len(x) > 0 else 0).max()
-			print(f"\n📈 Estadísticas de accuracy:")
-			print(f"   - Promedio: {avg_accuracy:.4f}")
-			print(f"   - Mínimo: {min_accuracy:.4f}")
-			print(f"   - Máximo: {max_accuracy:.4f}")
-	else:
-		print("❌ No hay detecciones que cumplan con el filtro de accuracy o todas fueron detectadas como OOD")
-	
-	return results_df
+    """Función principal de procesamiento"""
+    print(f"🚀 Procesando imagen con modelo 512px - Categoría: {model_category}")
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    # Cargar bounding boxes
+    saved_images, s3_client = load_json_from_s3(json_s3_url)
+    if not saved_images:
+        return pd.DataFrame()
+    
+    saved_images = saved_images['bounding_boxes']
+    
+    # Seleccionar modelo
+    try:
+        encoder, class_names, prototypes, eval_transform = model_selector(self, model_category)
+    except Exception as e:
+        print(f"❌ Error cargando modelo: {e}")
+        return pd.DataFrame()
+    
+    # Clasificar
+    results_df = classify_saved_bboxes(
+        saved_images, encoder, class_names, prototypes, eval_transform, 
+        device, minimal_accuracy, s3_client, model_category
+    )
+    
+    if not results_df.empty:
+        print(f"✅ {len(results_df)} detecciones procesadas")
+        print(f"📊 Clases detectadas: {', '.join(results_df['prediccion_principal'].unique())}")
+    
+    return results_df
 
 class EndpointHandler():
-	def __init__(self, path=""):
-		device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-		model_filename_licores = "model_curriculum4/prototypical_model_best_licores.pth"
-		local_model_path_licores = hf_hub_download(repo_id="Drazcat-AI/redes_prototipicas", filename=model_filename_licores)
-		self.encoder_licores, self.class_names_licores, self.prototypes_licores, self.eval_transform_licores = load_classification_model_optimized(
-			local_model_path_licores, device)
+    def __init__(self, path=""):
+        """Inicialización con modelos 512px únicamente"""
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"🚀 Inicializando handler con device: {device}")
+        
+        # Cargar modelo de licores
+        model_filename = "model_curriculum4/prototypical_model_best_licores.pth"
+        local_model_path = hf_hub_download(repo_id="Drazcat-AI/redes_prototipicas", filename=model_filename)
+        
+        self.encoder_licores, self.class_names_licores, self.prototypes_licores, self.eval_transform_licores = load_classification_model_optimized(local_model_path, device)
+        
+        print("✅ Handler inicializado")
 
-	def predict_objects(self, image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url):
-		
-		print("Ejecutando clasificación optimizada con prototipos pre-cargados y detección OOD...")
-		result_df = process_image_with_bboxes(
-			self, image_url, picture_id, visit_id, minimal_accuracy, 
-			None, None,  # model_path y train_path ya no son necesarios
-			model_category, json_s3_url
-		)	
-		return result_df
+    def predict_objects(self, image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url):
+        """Predicción con modelos 512px"""
+        return process_image_with_bboxes(
+            self, image_url, picture_id, visit_id, minimal_accuracy, 
+            None, None, model_category, json_s3_url
+        )
 
-	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"] 
-		picture_id = event["picture_id"]
-		visit_id = event["visit_id"]
-		minimal_accuracy = event["minimal_accuracy"]
-		model_category = event["model_category"]
-		json_s3_url = event["json_s3_url"]
-		
-		try:
-			predictions = self.predict_objects(image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url)
-			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)}"),
-			}
+    def __call__(self, event):
+        """Método de llamada principal"""
+        if "inputs" not in event:
+            return {"statusCode": 400, "body": json.dumps("Error: No 'inputs' parameter.")}
+        
+        event = event["inputs"]
+        
+        try:
+            predictions = self.predict_objects(
+                event["image_url"], event["picture_id"], event["visit_id"],
+                event["minimal_accuracy"], event["model_category"], event["json_s3_url"]
+            )
+            
+            return {
+                "statusCode": 200,
+                "body": json.dumps(predictions.to_json(orient='records'))
+            }
+        except Exception as e:
+            return {"statusCode": 500, "body": json.dumps(f"Error: {str(e)}")}