Update handler.py

handler.py

@@ -1,435 +1,436 @@
-import torch
-import torch.nn.functional as F
-import torchvision.transforms as transforms
-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
-
-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
-
-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
-
-def model_selector(self, model_category):
-	if model_category == "bebidas_gas":
-		encoder, class_names, prototypes, eval_transform = self.encoder_bebidas_gas, self.class_names_bebidas_gas, self.prototypes_bebidas_gas, self.eval_transform_bebidas_gas
-	elif model_category == "detergentes":
-		encoder, class_names, prototypes, eval_transform = self.encoder_detergentes, self.class_names_detergentes, self.prototypes_detergentes, self.eval_transform_detergentes
-
-	return encoder, class_names, prototypes, eval_transform
-
-def load_classification_model(model_path, train_path, device):
-	
-	if Path(model_path).exists():
-		actual_model_path = model_path
-		model_name = "MODELO_ESPECIFICADO"
-		print(f"✅ Usando modelo especificado: {model_path}")
-	else:
-		raise FileNotFoundError(f"❌ No se encontró ningún modelo en las rutas esperadas")
-	
-	# Cargar modelo con la arquitectura correcta (256 dims)
-	encoder = ConvEncoder(hidden_dim=64, output_dim=256).to(device)
-	model = PrototypicalNetwork(encoder).to(device)
-	
-	# Cargar pesos con weights_only=False para compatibilidad
-	checkpoint = torch.load(actual_model_path, map_location=device, weights_only=False)
-	encoder.load_state_dict(checkpoint['encoder_state_dict'])
-	model.load_state_dict(checkpoint['model_state_dict'])
-	model.eval()
-	
-	print(f"✅ Modelo de clasificación cargado correctamente ({model_name})")
-	
-	# Transformaciones para evaluación
-	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])
-	])
-	
-	# Crear prototipos robustos usando múltiples shots del dataset de entrenamiento
-	print("🔄 Creando prototipos de clases...")
-	class_images = defaultdict(list)
-	
-	# Cargar imágenes del train para crear prototipos
-	for img_path in Path(train_path).glob('*'):
-		if img_path.suffix.lower() in {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'}:
-			parts = img_path.stem.split('_')[:-1]
-			class_name = '_'.join(parts) if parts else img_path.stem
-			
-			# Usar hasta 5 imágenes por clase para prototipos robustos
-			if len(class_images[class_name]) < 5:
-				try:
-					image = Image.open(img_path).convert('RGB')
-					image_tensor = eval_transform(image).unsqueeze(0).to(device)
-					class_images[class_name].append(image_tensor)
-				except Exception as e:
-					pass
-	
-	# Crear prototipos con normalización
-	class_names = sorted(class_images.keys())
-	prototypes = []
-	
-	with torch.no_grad():
-		for class_name in class_names:
-			if class_images[class_name]:
-				# Concatenar imágenes de la clase
-				class_tensors = torch.cat(class_images[class_name], dim=0)
-				# Extraer características
-				class_features = encoder(class_tensors)
-				# Normalizar (como hace el modelo)
-				class_features = F.normalize(class_features, p=2, dim=1)
-				# Promediar para obtener prototipo
-				prototype = class_features.mean(dim=0, keepdim=True)
-				# Normalizar el prototipo también
-				prototype = F.normalize(prototype, p=2, dim=1)
-				prototypes.append(prototype)
-	
-	prototypes = torch.cat(prototypes, dim=0)
-	print(f"✅ Prototipos creados para {len(class_names)} clases")
-	
-	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 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:])
-		
-		#print(f"🔄 Cargando JSON desde S3...")
-		#print(f"📦 Bucket: {bucket}")
-		#print(f"🗝️  Key: {key}")
-		
-		# 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
-
-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"""
-	
-	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}")
-	
-	results = []
-	filtered_count = 0
-	with torch.no_grad():
-		for img_info in saved_images:
-			try:
-			#if True:
-				# Cargar imagen guardada
-				#response = requests.get(img_info['bbox_path'])
-				#bbox_image = Image.open(img_info['bbox_path']).convert('RGB')
-				bbox_image = load_image_from_s3_url(img_info['bbox_path'], s3_client)
-				
-				# 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)
-				
-				# Calcular similitud coseno
-				similarities = torch.mm(query_features, prototypes.t())
-				similarities_numpy = similarities.cpu().numpy()[0]
-				
-				# Obtener top 3 predicciones
-				#top3_indices = np.argsort(similarities_numpy)[::-1][:3]
-				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
-				
-				# Guardar predictions y accuracy como listas (solo las que cumplen el filtro)
-				predictions_list = top3_predictions
-				similarities_list = top3_similarities
-				
-				# 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
-				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,
-					'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),
-					'xmin': img_info['x_min'],
-					'ymin': img_info['y_min'],
-					'xmax': img_info['x_max'],
-					'ymax': img_info['y_max']
-				})
-			#"""	
-	
-	if filtered_count > 0:
-		print(f"📊 Resumen de filtrado:")
-		print(f"   - Detecciones procesadas: {len(results)}")
-		print(f"   - Detecciones filtradas: {filtered_count}")
-		print(f"   - Total original: {len(saved_images)}")
-	
-	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 V4")
-	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}")
-	
-	#logica de carga de bbs con 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 guardar las imágenes recortadas")
-		return pd.DataFrame()
-	
-	# 3. Cargar modelo de clasificación
-	print("\n🤖 PASO 3: Cargando modelo de clasificación...")
-	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
-	print("\n🔬 PASO 4: Clasificando imágenes guardadas...")
-	results_df = classify_saved_bboxes(
-		saved_images, encoder, class_names, prototypes, eval_transform, device,
-		minimal_accuracy, s3_client
-	)
-	
-	# 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())}")
-		
-		# 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")
-	
-	return results_df
-
-class EndpointHandler():
-	def __init__(self):
-		device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-		model_path_detergentes = "model_curriculum4/prototypical_model_best_detergentes.pth"
-		train_path_detergentes = "datasets/detergentes/train"
-		#hf_hub_download(repo_id="Drazcat-AI/redes_prototipicas", filename=model_path_detergentes)
-		self.encoder_detergentes, self.class_names_detergentes, self.prototypes_detergentes, self.eval_transform_detergentes = load_classification_model(model_path_detergentes, train_path_detergentes, device)
-		#model_path_bebidas_gas = "model_curriculum4/prototypical_model_best_bebidas_gas.pth"
-		#train_path_bebidas_gas = "datasets/bebidas_gas/train"
-		#hf_hub_download(repo_id="Drazcat-AI/redes_prototipicas", filename="model_curriculum4/prototypical_model_best_bebidas_gas.pth")
-		#self.encoder_bebidas_gas, self.class_names_bebidas_gas, self.prototypes_bebidas_gas, self.eval_transform_bebidas_gas = load_classification_model(model_path_bebidas_gas, train_path_bebidas_gas, device)
-
-	def predict_objects(self, image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url):
-
-		model_path="model_curriculum4/prototypical_model_best_" + model_category + ".pth"
-		train_path ="datasets/" + model_category + "/train"
-
-		print("Ejecutando test con una imagen...")
-		result_df = process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_accuracy, model_path, train_path, model_category, json_s3_url)	
-		return result_df
-
-	def __call__(self, event):
-
-		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"]
-		client = event["client"]
-		json_s3_url = event["json_s3_url"]
-		
-		try:
-		#if True:
-			
-			predictions = self.predict_objects(image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url)
-			predictions_json = predictions.to_json(orient='records')
-			#print(predictions)
-			return {
-				"statusCode": 200,
-				"body": json.dumps(predictions_json),
-			}
-		except Exception as e:
-			return {
-				"statusCode": 500,
-				"body": json.dumps(f"Error: {str(e)}"),
-			}    
-
-"""
-# Instanciar la clase
-handler = EndpointHandler()
-
-# Preparar el evento con los datos necesarios
-event_data = {
-	"image_url": "https://dmnoqeddtk0uw.cloudfront.net/peru_cencosud/visits/34/pi/upload_image385772781681046090.jpg",
-	"picture_id": 11025,
-	"visit_id": 34,
-	"minimal_accuracy": 0.0,
-	"model_category": "detergentes",
-	"json_s3_url": "https://rocketpin-ml-data.s3.amazonaws.com/redes_prototipicas/bounding_boxes_images/results/visit_34/bboxes_results_picture_11025_visit_34.json"
-}
-
-# Ejecutar la predicción
-response = handler(event_data)
-
-# Verificar el resultado
-print(f"Status Code: {response['statusCode']}")
-print(f"Body: {response['body']}")
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+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
+
+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
+
+def model_selector(self, model_category):
+	if model_category == "bebidas_gas":
+		encoder, class_names, prototypes, eval_transform = self.encoder_bebidas_gas, self.class_names_bebidas_gas, self.prototypes_bebidas_gas, self.eval_transform_bebidas_gas
+	elif model_category == "detergentes":
+		encoder, class_names, prototypes, eval_transform = self.encoder_detergentes, self.class_names_detergentes, self.prototypes_detergentes, self.eval_transform_detergentes
+
+	return encoder, class_names, prototypes, eval_transform
+
+def load_classification_model(model_path, train_path, device):
+	
+	if Path(model_path).exists():
+		actual_model_path = model_path
+		model_name = "MODELO_ESPECIFICADO"
+		print(f"✅ Usando modelo especificado: {model_path}")
+	else:
+		raise FileNotFoundError(f"❌ No se encontró ningún modelo en las rutas esperadas")
+	
+	# Cargar modelo con la arquitectura correcta (256 dims)
+	encoder = ConvEncoder(hidden_dim=64, output_dim=256).to(device)
+	model = PrototypicalNetwork(encoder).to(device)
+	
+	# Cargar pesos con weights_only=False para compatibilidad
+	checkpoint = torch.load(actual_model_path, map_location=device, weights_only=False)
+	encoder.load_state_dict(checkpoint['encoder_state_dict'])
+	model.load_state_dict(checkpoint['model_state_dict'])
+	model.eval()
+	
+	print(f"✅ Modelo de clasificación cargado correctamente ({model_name})")
+	
+	# Transformaciones para evaluación
+	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])
+	])
+	
+	# Crear prototipos robustos usando múltiples shots del dataset de entrenamiento
+	print("🔄 Creando prototipos de clases...")
+	class_images = defaultdict(list)
+	
+	# Cargar imágenes del train para crear prototipos
+	for img_path in Path(train_path).glob('*'):
+		if img_path.suffix.lower() in {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'}:
+			parts = img_path.stem.split('_')[:-1]
+			class_name = '_'.join(parts) if parts else img_path.stem
+			
+			# Usar hasta 5 imágenes por clase para prototipos robustos
+			if len(class_images[class_name]) < 5:
+				try:
+					image = Image.open(img_path).convert('RGB')
+					image_tensor = eval_transform(image).unsqueeze(0).to(device)
+					class_images[class_name].append(image_tensor)
+				except Exception as e:
+					pass
+	
+	# Crear prototipos con normalización
+	class_names = sorted(class_images.keys())
+	prototypes = []
+	
+	with torch.no_grad():
+		for class_name in class_names:
+			if class_images[class_name]:
+				# Concatenar imágenes de la clase
+				class_tensors = torch.cat(class_images[class_name], dim=0)
+				# Extraer características
+				class_features = encoder(class_tensors)
+				# Normalizar (como hace el modelo)
+				class_features = F.normalize(class_features, p=2, dim=1)
+				# Promediar para obtener prototipo
+				prototype = class_features.mean(dim=0, keepdim=True)
+				# Normalizar el prototipo también
+				prototype = F.normalize(prototype, p=2, dim=1)
+				prototypes.append(prototype)
+	
+	prototypes = torch.cat(prototypes, dim=0)
+	print(f"✅ Prototipos creados para {len(class_names)} clases")
+	
+	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 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:])
+		
+		#print(f"🔄 Cargando JSON desde S3...")
+		#print(f"📦 Bucket: {bucket}")
+		#print(f"🗝️  Key: {key}")
+		
+		# 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
+
+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"""
+	
+	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}")
+	
+	results = []
+	filtered_count = 0
+	with torch.no_grad():
+		for img_info in saved_images:
+			try:
+			#if True:
+				# Cargar imagen guardada
+				#response = requests.get(img_info['bbox_path'])
+				#bbox_image = Image.open(img_info['bbox_path']).convert('RGB')
+				bbox_image = load_image_from_s3_url(img_info['bbox_path'], s3_client)
+				
+				# 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)
+				
+				# Calcular similitud coseno
+				similarities = torch.mm(query_features, prototypes.t())
+				similarities_numpy = similarities.cpu().numpy()[0]
+				
+				# Obtener top 3 predicciones
+				#top3_indices = np.argsort(similarities_numpy)[::-1][:3]
+				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
+				
+				# Guardar predictions y accuracy como listas (solo las que cumplen el filtro)
+				predictions_list = top3_predictions
+				similarities_list = top3_similarities
+				
+				# 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
+				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,
+					'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),
+					'xmin': img_info['x_min'],
+					'ymin': img_info['y_min'],
+					'xmax': img_info['x_max'],
+					'ymax': img_info['y_max']
+				})
+			#"""	
+	
+	if filtered_count > 0:
+		print(f"📊 Resumen de filtrado:")
+		print(f"   - Detecciones procesadas: {len(results)}")
+		print(f"   - Detecciones filtradas: {filtered_count}")
+		print(f"   - Total original: {len(saved_images)}")
+	
+	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 V4")
+	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}")
+	
+	#logica de carga de bbs con 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 guardar las imágenes recortadas")
+		return pd.DataFrame()
+	
+	# 3. Cargar modelo de clasificación
+	print("\n🤖 PASO 3: Cargando modelo de clasificación...")
+	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
+	print("\n🔬 PASO 4: Clasificando imágenes guardadas...")
+	results_df = classify_saved_bboxes(
+		saved_images, encoder, class_names, prototypes, eval_transform, device,
+		minimal_accuracy, s3_client
+	)
+	
+	# 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())}")
+		
+		# 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")
+	
+	return results_df
+
+class EndpointHandler():
+	def __init__(self):
+		device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+		model_path_detergentes = "model_curriculum4/prototypical_model_best_detergentes.pth"
+		train_path_detergentes = "datasets/detergentes/train"
+		hf_hub_download(repo_id="Drazcat-AI/redes_prototipicas", filename=model_path_detergentes)
+		self.encoder_detergentes, self.class_names_detergentes, self.prototypes_detergentes, self.eval_transform_detergentes = load_classification_model(model_path_detergentes, train_path_detergentes, device)
+		#model_path_bebidas_gas = "model_curriculum4/prototypical_model_best_bebidas_gas.pth"
+		#train_path_bebidas_gas = "datasets/bebidas_gas/train"
+		#hf_hub_download(repo_id="Drazcat-AI/redes_prototipicas", filename="model_curriculum4/prototypical_model_best_bebidas_gas.pth")
+		#self.encoder_bebidas_gas, self.class_names_bebidas_gas, self.prototypes_bebidas_gas, self.eval_transform_bebidas_gas = load_classification_model(model_path_bebidas_gas, train_path_bebidas_gas, device)
+
+	def predict_objects(self, image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url):
+
+		model_path="model_curriculum4/prototypical_model_best_" + model_category + ".pth"
+		train_path ="datasets/" + model_category + "/train"
+
+		print("Ejecutando test con una imagen...")
+		result_df = process_image_with_bboxes(self, image_url, picture_id, visit_id, minimal_accuracy, model_path, train_path, model_category, json_s3_url)	
+		return result_df
+
+	def __call__(self, event):
+
+		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"]
+		client = event["client"]
+		json_s3_url = event["json_s3_url"]
+		
+		try:
+		#if True:
+			
+			predictions = self.predict_objects(image_url, picture_id, visit_id, minimal_accuracy, model_category, json_s3_url)
+			predictions_json = predictions.to_json(orient='records')
+			#print(predictions)
+			return {
+				"statusCode": 200,
+				"body": json.dumps(predictions_json),
+			}
+		except Exception as e:
+			return {
+				"statusCode": 500,
+				"body": json.dumps(f"Error: {str(e)}"),
+			}    
+
+"""
+# Instanciar la clase
+handler = EndpointHandler()
+
+# Preparar el evento con los datos necesarios
+event_data = {
+	"image_url": "https://dmnoqeddtk0uw.cloudfront.net/peru_cencosud/visits/34/pi/upload_image385772781681046090.jpg",
+	"picture_id": 11025,
+	"visit_id": 34,
+	"minimal_accuracy": 0.0,
+	"model_category": "detergentes",
+	"json_s3_url": "https://rocketpin-ml-data.s3.amazonaws.com/redes_prototipicas/bounding_boxes_images/results/visit_34/bboxes_results_picture_11025_visit_34.json"
+}
+
+# Ejecutar la predicción
+response = handler(event_data)
+
+# Verificar el resultado
+print(f"Status Code: {response['statusCode']}")
+print(f"Body: {response['body']}")
 """