Update handler.py

handler.py

@@ -77,6 +77,113 @@ def model_selector(self, 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)
+
+# 🆕 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
+
 # ✅ 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"""
@@ -174,8 +281,10 @@ def load_json_from_s3(json_s3_url):
 		print(f"❌ Error cargando JSON: {e}")
 		return None
 
-def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_transform, device, minimal_accuracy, s3_client):
-	"""Clasificar las imágenes de bounding boxes guardadas"""
+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")
@@ -184,8 +293,16 @@ def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_t
 	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:
@@ -204,7 +321,39 @@ def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_t
 				# Normalizar
 				query_features = F.normalize(query_features, p=2, dim=1)
 				
-				# Calcular similitud coseno con prototipos guardados
+				# 🆕 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]
 				
@@ -227,9 +376,16 @@ def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_t
 					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 = top3_similarities
+				similarities_list = adjusted_similarities  # 🆕 Usar similarities ajustadas
 				
 				# La predicción principal es la primera de la lista filtrada
 				predicted_class = predictions_list[0]
@@ -240,7 +396,7 @@ def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_t
 				# Formatear bbox_confidence con 4 decimales
 				bbox_confidence_formatted = round(float(img_info['confidence']), 4)
 				
-				# Agregar resultado
+				# 🆕 Agregar resultado con información OOD
 				result = {
 					'sku_bb_id': str(img_info['bbox_id']),
 					'predictions': predictions_list,
@@ -248,6 +404,8 @@ def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_t
 					'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'],
@@ -266,17 +424,25 @@ def classify_saved_bboxes(saved_images, encoder, class_names, prototypes, eval_t
 					'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']
 				})
 	
-	if filtered_count > 0:
+	# 🆕 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: {filtered_count}")
+		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)
 
@@ -284,7 +450,7 @@ def process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_acc
 	"""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")
+	print("PROCESAMIENTO DE IMAGEN CON BOUNDING BOXES - MODELO OPTIMIZADO V5 + OOD")
 	print("="*80)
 	print(f"📸 Imagen: {image_url}")
 	print(f"🆔 Picture ID: {picture_id}")
@@ -292,6 +458,7 @@ def process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_acc
 	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)
@@ -309,11 +476,11 @@ def process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_acc
 		print(f"❌ Error cargando modelo: {e}")
 		return pd.DataFrame()
 	
-	# 4. Clasificar imágenes guardadas
-	print("\n🔬 PASO 4: Clasificando imágenes guardadas...")
+	# 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
+		minimal_accuracy, s3_client, model_category  # 🆕 Pasar model_category
 	)
 	
 	# 5. Mostrar resumen
@@ -323,6 +490,16 @@ def process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_acc
 		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)
@@ -339,7 +516,7 @@ def process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_acc
 			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")
+		print("❌ No hay detecciones que cumplan con el filtro de accuracy o todas fueron detectadas como OOD")
 	
 	return results_df
 
@@ -353,7 +530,7 @@ class EndpointHandler():
 
 	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...")
+		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