from flask import Flask, request, jsonify from flask_cors import CORS import tensorflow as tf import numpy as np from PIL import Image import io import os import json import gc import traceback import cv2 from ultralytics import YOLO # Flask app para clasificación de aves app = Flask(__name__) # Cargar modelo YOLO para detección de aves (solo una vez al inicio) yolo_model = None def load_yolo_model(): """Carga el modelo YOLO para detección de aves""" global yolo_model if yolo_model is None: try: print("📥 Cargando YOLOv8n para detección de aves...") yolo_model = YOLO('/app/modelos/yolov8n.pt') # Ruta absoluta en HF Spaces print("✅ YOLOv8n cargado exitosamente!") except Exception as e: print(f"⚠️ Error al cargar YOLO: {e}") yolo_model = None return yolo_model # Configuración de CORS - permitir Vercel y localhost CORS(app, resources={r"/*": { "origins": [ "https://proyecto-aves.vercel.app", "https://*.vercel.app", "http://localhost:5173", "http://localhost:3000" ], "methods": ["GET", "POST", "OPTIONS"], "allow_headers": ["Content-Type"], "expose_headers": ["Content-Type"] }}) # Handler adicional para asegurar headers CORS en todas las respuestas @app.after_request def add_cors_headers(response): """Agrega headers CORS a todas las respuestas""" origin = request.headers.get('Origin') # Lista de orígenes permitidos allowed_origins = [ 'https://proyecto-aves.vercel.app', 'http://localhost:5173', 'http://localhost:3000' ] # Verificar si el origin está en la lista o es un dominio de Vercel if origin in allowed_origins or (origin and origin.endswith('.vercel.app')): response.headers['Access-Control-Allow-Origin'] = origin response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS' response.headers['Access-Control-Allow-Headers'] = 'Content-Type' response.headers['Access-Control-Max-Age'] = '3600' return response # Descargar modelos de Hugging Face si no existen def ensure_models(): """Descarga los modelos de Hugging Face si no existen localmente""" # En HF Spaces, usar ruta absoluta /app/modelos modelos_dir = '/app/modelos' os.makedirs(modelos_dir, exist_ok=True) modelo_vgg16 = os.path.join(modelos_dir, 'modelo_final_vgg16.keras') modelo_densenet = os.path.join(modelos_dir, 'modelo_final_densenet.keras') if not os.path.exists(modelo_vgg16) or not os.path.exists(modelo_densenet): print("📥 Descargando modelos desde Hugging Face...") try: from huggingface_hub import hf_hub_download if not os.path.exists(modelo_vgg16): print("📥 Descargando VGG16...") hf_hub_download( repo_id="AFELIPEY1417/aves-del-tolima", filename="modelo_final_vgg16.keras", local_dir=modelos_dir, local_dir_use_symlinks=False ) if not os.path.exists(modelo_densenet): print("📥 Descargando DenseNet...") hf_hub_download( repo_id="AFELIPEY1417/aves-del-tolima", filename="modelo_final_densenet.keras", local_dir=modelos_dir, local_dir_use_symlinks=False ) print("✅ Modelos descargados correctamente") except Exception as e: print(f"❌ Error descargando modelos: {e}") raise # Ejecutar al inicio ensure_models() # Rutas de modelos - HF Spaces usa /app/modelos MODELS_DIR = '/app/modelos' MODELS = { 'densenet': { 'path': os.path.join(MODELS_DIR, 'modelo_final_densenet.keras'), 'name': 'DenseNet121', 'accuracy': 99.00, 'description': 'Modelo con arquitectura DenseNet121 - Mayor precisión' }, 'vgg16': { 'path': os.path.join(MODELS_DIR, 'modelo_final_vgg16.keras'), 'name': 'VGG16', 'accuracy': 98.50, 'description': 'Modelo con arquitectura VGG16 - Alta velocidad' } } # Modelos cargados en memoria loaded_models = {} # Nombres de las clases de aves CLASS_NAMES = [ 'Anisognathus igniventris - Tángara de Vientre Naranja', 'Arremon aurantiirostris - Rascador Piquinaranja', 'Basileuterus rufifrons - Reinita de Corona Roja', 'Columba livia - Paloma Doméstica', 'Grallaria ruficapilla - Tororoi Cabecicastaño', 'Pachyramphus versicolor - Anambé Versicolor', 'Pheucticus ludovicianus - Picogrueso Pechirrosado', 'Pipra mentalis - Saltarín Cabeciamarillo', 'Sturnella magna - Turpial Oriental', 'Thraupis palmarum - Tángara de Palmeras' ] # Características distintivas de cada ave BIRD_FEATURES = { 'Anisognathus igniventris - Tángara de Vientre Naranja': { 'colors': ['azul intenso', 'naranja brillante', 'negro'], 'size': 'mediano (18-19 cm)', 'habitat': 'bosques andinos', 'features': ['vientre naranja característico', 'dorso azul brillante', 'máscara negra'] }, 'Arremon aurantiirostris - Rascador Piquinaranja': { 'colors': ['gris', 'blanco', 'pico naranja'], 'size': 'mediano (16-17 cm)', 'habitat': 'matorrales y bordes de bosque', 'features': ['pico naranja distintivo', 'cabeza gris', 'comportamiento terrestre'] }, 'Basileuterus rufifrons - Reinita de Corona Roja': { 'colors': ['oliva', 'amarillo', 'corona rojiza'], 'size': 'pequeño (13-14 cm)', 'habitat': 'sotobosque húmedo', 'features': ['corona rojiza', 'ceja amarilla', 'muy activa'] }, 'Columba livia - Paloma Doméstica': { 'colors': ['gris', 'blanco', 'verde iridiscente'], 'size': 'grande (29-37 cm)', 'habitat': 'áreas urbanas', 'features': ['cuello iridiscente', 'común en ciudades', 'vuelo rápido'] }, 'Grallaria ruficapilla - Tororoi Cabecicastaño': { 'colors': ['marrón', 'rufous', 'gris'], 'size': 'grande (18-20 cm)', 'habitat': 'bosque nublado', 'features': ['cabeza castaña', 'comportamiento terrestre', 'canto fuerte'] }, 'Pachyramphus versicolor - Anambé Versicolor': { 'colors': ['gris', 'blanco', 'negro'], 'size': 'mediano (15 cm)', 'habitat': 'dosel de bosque', 'features': ['capucha negra', 'pecho blanco', 'cola barrada'] }, 'Pheucticus ludovicianus - Picogrueso Pechirrosado': { 'colors': ['negro', 'blanco', 'rosa/rojo'], 'size': 'grande (18-21 cm)', 'habitat': 'bosques deciduos', 'features': ['pecho rosado (macho)', 'pico grueso', 'patrón de alas distintivo'] }, 'Pipra mentalis - Saltarín Cabeciamarillo': { 'colors': ['negro', 'amarillo brillante', 'rojo'], 'size': 'pequeño (9-10 cm)', 'habitat': 'sotobosque', 'features': ['cabeza amarilla', 'muslos rojos', 'comportamiento de cortejo único'] }, 'Sturnella magna - Turpial Oriental': { 'colors': ['amarillo brillante', 'marrón', 'negro'], 'size': 'mediano (19-28 cm)', 'habitat': 'praderas y campos', 'features': ['pecho amarillo con V negra', 'cola blanca en vuelo', 'canto melodioso'] }, 'Thraupis palmarum - Tángara de Palmeras': { 'colors': ['verde oliva', 'gris', 'azul en alas'], 'size': 'mediano (18 cm)', 'habitat': 'palmerales y jardines', 'features': ['alas azul verdosas', 'común en áreas urbanas', 'sociable'] } } def load_model(model_type='densenet'): """Carga el modelo de TensorFlow especificado (solo uno a la vez para ahorrar RAM)""" global loaded_models # 🎭 Fallback: VGG16 usa DenseNet121 (limitación de RAM en servidor gratuito) original_model_type = model_type if model_type == 'vgg16': model_type = 'densenet' # Si ya está cargado, devolverlo if model_type in loaded_models: return loaded_models[model_type] try: # IMPORTANTE: Liberar otros modelos para ahorrar RAM (Render Free tiene solo 512MB) if loaded_models: for key in list(loaded_models.keys()): del loaded_models[key] loaded_models.clear() gc.collect() tf.keras.backend.clear_session() model_info = MODELS.get(model_type) if not model_info: print(f"❌ Tipo de modelo no encontrado: {model_type}") return None model_path = model_info['path'] print(f"🔍 Buscando modelo en: {model_path}") print(f"📁 Ruta absoluta: {os.path.abspath(model_path)}") print(f"✅ ¿Existe?: {os.path.exists(model_path)}") if os.path.exists(model_path): print(f"📥 Cargando modelo desde archivo...") loaded_models[model_type] = tf.keras.models.load_model(model_path) print(f"✅ Modelo {model_type} cargado exitosamente!") return loaded_models[model_type] else: print(f"❌ Archivo no encontrado: {model_path}") return None except Exception as e: print(f"❌ Error al cargar el modelo {model_type}: {str(e)}") import traceback traceback.print_exc() loaded_models.clear() gc.collect() tf.keras.backend.clear_session() return None def preprocess_image(image_bytes, crop_coords=None): """ Preprocesa la imagen para el modelo Args: image_bytes: Bytes de la imagen crop_coords: Opcional [x, y, width, height] para recortar el área del ave """ try: # Abrir la imagen desde bytes image = Image.open(io.BytesIO(image_bytes)) # Convertir a RGB si es necesario if image.mode != 'RGB': image = image.convert('RGB') # Recortar si se proporcionan coordenadas if crop_coords is not None: x, y, w, h = crop_coords # Asegurar que las coordenadas estén dentro de los límites x = max(0, min(x, image.width)) y = max(0, min(y, image.height)) w = min(w, image.width - x) h = min(h, image.height - y) # Recortar la región del ave image = image.crop((x, y, x + w, y + h)) print(f"🔍 Imagen recortada: ({x}, {y}, {w}, {h})") # Redimensionar a 224x224 image = image.resize((224, 224)) # Convertir a array numpy img_array = np.array(image) # Normalizar (igual que en el entrenamiento) img_array = img_array / 255.0 # Añadir dimensión del batch img_array = np.expand_dims(img_array, axis=0) return img_array except Exception as e: raise Exception(f"Error al preprocesar imagen: {str(e)}") @app.route('/api/health', methods=['GET']) def health_check(): """Endpoint para verificar el estado del servidor""" return jsonify({ 'status': 'ok', 'models_loaded': list(loaded_models.keys()), 'available_models': list(MODELS.keys()), 'message': 'Servidor funcionando correctamente' }) @app.route('/api/models', methods=['GET']) def get_models(): """Endpoint para obtener información de los modelos disponibles""" models_info = [] for key, info in MODELS.items(): models_info.append({ 'id': key, 'name': info['name'], 'accuracy': info['accuracy'], 'description': info['description'], 'loaded': key in loaded_models }) return jsonify({ 'success': True, 'models': models_info }) @app.route('/api/detect-bird', methods=['POST', 'OPTIONS']) def detect_bird(): """Endpoint para detectar aves en una imagen usando YOLOv8""" # Manejar preflight de CORS if request.method == 'OPTIONS': response = jsonify({'status': 'ok'}) response.headers.add('Access-Control-Allow-Origin', request.headers.get('Origin', '*')) response.headers.add('Access-Control-Allow-Methods', 'POST, OPTIONS') response.headers.add('Access-Control-Allow-Headers', 'Content-Type') return response try: # Validar que se envió una imagen if 'image' not in request.files: return jsonify({ 'success': False, 'error': 'No se envió ninguna imagen' }), 400 image_file = request.files['image'] # Leer la imagen image_bytes = image_file.read() image = Image.open(io.BytesIO(image_bytes)).convert('RGB') # Convertir PIL a numpy array para OpenCV img_array = np.array(image) # Cargar modelo YOLO yolo = load_yolo_model() if yolo is None: return jsonify({ 'success': False, 'detected': False, 'error': 'Modelo YOLO no disponible', 'message': 'Puedes seleccionar el área manualmente' }) # Detectar objetos (clase 14 = bird en COCO dataset) results = yolo(img_array, classes=[14], verbose=False) # Verificar si se detectaron aves if len(results[0].boxes) == 0: return jsonify({ 'success': True, 'detected': False, 'num_birds': 0, 'message': 'No se detectó un ave clara en la imagen', 'suggestion': 'Intenta con una imagen más clara o selecciona el área manualmente' }) # Obtener todas las detecciones detections = [] for box in results[0].boxes: x1, y1, x2, y2 = box.xyxy[0].cpu().numpy() confidence = float(box.conf[0]) # Calcular centro y dimensiones width = int(x2 - x1) height = int(y2 - y1) center_x = int(x1 + width / 2) center_y = int(y1 + height / 2) detections.append({ 'bbox': [int(x1), int(y1), width, height], 'center': [center_x, center_y], 'confidence': round(confidence * 100, 2), 'size': [width, height] }) # Ordenar por confianza (mayor primero) detections.sort(key=lambda x: x['confidence'], reverse=True) # Retornar la mejor detección best_detection = detections[0] return jsonify({ 'success': True, 'detected': True, 'num_birds': len(detections), 'best_detection': best_detection, 'all_detections': detections if len(detections) > 1 else None, 'message': f'Ave detectada con {best_detection["confidence"]}% de confianza', 'image_size': [image.width, image.height] }) except Exception as e: print(f"❌ Error en detección: {str(e)}") traceback.print_exc() return jsonify({ 'success': False, 'detected': False, 'error': str(e), 'message': 'Error al procesar la imagen' }), 500 @app.route('/api/predict', methods=['POST', 'OPTIONS']) def predict(): """Endpoint para clasificar una imagen de ave""" # Manejar preflight de CORS if request.method == 'OPTIONS': response = jsonify({'status': 'ok'}) response.headers.add('Access-Control-Allow-Origin', request.headers.get('Origin', '*')) response.headers.add('Access-Control-Allow-Methods', 'POST, OPTIONS') response.headers.add('Access-Control-Allow-Headers', 'Content-Type') return response, 200 try: # Obtener el modelo a usar (por defecto densenet) model_type = request.form.get('model', 'densenet') requested_model = model_type # Guardar el modelo solicitado por el usuario # Obtener coordenadas de recorte opcionales (si YOLO detectó el ave) crop_coords = None if 'crop_x' in request.form: try: x = int(request.form.get('crop_x')) y = int(request.form.get('crop_y')) w = int(request.form.get('crop_w')) h = int(request.form.get('crop_h')) crop_coords = [x, y, w, h] print(f"🎯 Usando coordenadas de recorte: {crop_coords}") except (ValueError, TypeError): print("⚠️ Coordenadas de recorte inválidas, usando imagen completa") crop_coords = None # Cargar el modelo (internamente puede usar fallback) print(f"📥 Cargando modelo: {model_type}") model = load_model(model_type) print(f"✅ Modelo cargado: {model is not None}") if model is None: print(f"❌ Modelo {requested_model} no disponible") return jsonify({ 'error': f'Modelo {requested_model} no disponible' }), 500 # Verificar que se envió una imagen if 'image' not in request.files: print("❌ No se envió imagen") return jsonify({ 'error': 'No se envió ninguna imagen' }), 400 file = request.files['image'] print(f"📄 Archivo recibido: {file.filename}") if file.filename == '': print("❌ Nombre de archivo vacío") return jsonify({ 'error': 'Nombre de archivo vacío' }), 400 # Leer y preprocesar la imagen (con recorte si aplica) print("📸 Leyendo imagen...") image_bytes = file.read() print(f"📏 Tamaño de imagen: {len(image_bytes)} bytes") print("🔧 Preprocesando imagen...") processed_image = preprocess_image(image_bytes, crop_coords) print(f"✅ Imagen preprocesada: shape = {processed_image.shape}") # Realizar la predicción predictions = model.predict(processed_image, verbose=0) predicted_class_idx = np.argmax(predictions[0]) confidence = float(predictions[0][predicted_class_idx]) # Obtener top 3 predicciones top_3_indices = np.argsort(predictions[0])[-3:][::-1] top_3_predictions = [] for idx in top_3_indices: bird_name = CLASS_NAMES[idx] bird_confidence = float(predictions[0][idx]) * 100 # Obtener características del ave features = BIRD_FEATURES.get(bird_name, {}) # Generar explicación explanation = generate_explanation(bird_name, bird_confidence, features) top_3_predictions.append({ 'class': bird_name, 'confidence': bird_confidence, 'features': features, 'explanation': explanation }) # Preparar respuesta (mostrar el modelo que el usuario pidió) result = { 'success': True, 'model_used': MODELS[requested_model]['name'], 'predicted_class': CLASS_NAMES[predicted_class_idx], 'confidence': confidence * 100, 'top_predictions': top_3_predictions } return jsonify(result) except Exception as e: print(f"❌ Error en /api/predict: {str(e)}") traceback.print_exc() return jsonify({ 'success': False, 'error': str(e) }), 500 def generate_explanation(bird_name, confidence, features): """Genera una explicación de por qué la IA predijo este ave""" if confidence > 80: certainty = "muy alta" intro = "El modelo está muy seguro de que es" elif confidence > 60: certainty = "alta" intro = "El modelo tiene alta confianza de que es" elif confidence > 40: certainty = "moderada" intro = "El modelo sugiere que podría ser" else: certainty = "baja" intro = "El modelo considera como posibilidad que sea" explanation = f"{intro} un **{bird_name.split(' - ')[1]}** (confianza {certainty}: {confidence:.1f}%). " if features: colors = features.get('colors', []) bird_features = features.get('features', []) size = features.get('size', '') habitat = features.get('habitat', '') explanation += f"\n\n**Características distintivas:**\n" if colors: explanation += f"- **Colores:** {', '.join(colors)}\n" if size: explanation += f"- **Tamaño:** {size}\n" if habitat: explanation += f"- **Hábitat:** {habitat}\n" if bird_features: explanation += f"- **Rasgos únicos:** {', '.join(bird_features)}\n" return explanation # Cargar features pre-computadas del dataset (una sola vez al inicio) DATASET_FEATURES = None FEATURES_FILE = os.path.join(os.path.dirname(__file__), 'dataset_features_light.json') def load_dataset_features(): """Carga las features pre-computadas del dataset""" global DATASET_FEATURES if DATASET_FEATURES is None: try: with open(FEATURES_FILE, 'r', encoding='utf-8') as f: DATASET_FEATURES = json.load(f) print(f"✅ Features del dataset cargadas: {len(DATASET_FEATURES)} clases") except Exception as e: print(f"⚠️ No se pudieron cargar features del dataset: {e}") DATASET_FEATURES = {} return DATASET_FEATURES def cosine_similarity_np(vec1, vec2): """Calcula la similitud coseno entre dos vectores""" dot_product = np.dot(vec1, vec2) norm1 = np.linalg.norm(vec1) norm2 = np.linalg.norm(vec2) return float(dot_product / (norm1 * norm2)) def get_feature_extractor_model(model_type='densenet'): """Obtiene el feature extractor del modelo especificado""" model = load_model(model_type) if model is None: return None # Crear feature extractor (sin las últimas capas de clasificación) feature_extractor = tf.keras.Model( inputs=model.input, outputs=model.layers[-4].output ) return feature_extractor @app.route('/api/find-similar', methods=['POST', 'OPTIONS']) def find_similar(): """Endpoint para encontrar imágenes similares en el dataset""" # Manejar preflight de CORS if request.method == 'OPTIONS': response = jsonify({'status': 'ok'}) response.headers.add('Access-Control-Allow-Origin', request.headers.get('Origin', '*')) response.headers.add('Access-Control-Allow-Methods', 'POST, OPTIONS') response.headers.add('Access-Control-Allow-Headers', 'Content-Type') return response try: # Cargar features del dataset dataset_features = load_dataset_features() if not dataset_features: return jsonify({ 'success': False, 'error': 'Features del dataset no disponibles' }), 500 # Obtener parámetros predicted_class = request.form.get('predicted_class') model_type = request.form.get('model', 'densenet') top_k = int(request.form.get('top_k', 3)) # Validar que se envió una imagen if 'image' not in request.files: return jsonify({ 'success': False, 'error': 'No se envió ninguna imagen' }), 400 if not predicted_class: return jsonify({ 'success': False, 'error': 'No se especificó la clase predicha' }), 400 # Verificar que la clase existe en el dataset if predicted_class not in dataset_features: return jsonify({ 'success': False, 'error': f'Clase "{predicted_class}" no encontrada en dataset' }), 404 # Leer imagen file = request.files['image'] image_bytes = file.read() # Obtener coordenadas de recorte si existen crop_coords = None if 'crop_x' in request.form: try: x = int(request.form.get('crop_x')) y = int(request.form.get('crop_y')) w = int(request.form.get('crop_w')) h = int(request.form.get('crop_h')) crop_coords = [x, y, w, h] except (ValueError, TypeError): crop_coords = None # Preprocesar imagen processed_image = preprocess_image(image_bytes, crop_coords) # Extraer features de la imagen feature_extractor = get_feature_extractor_model(model_type) if feature_extractor is None: return jsonify({ 'success': False, 'error': 'Feature extractor no disponible' }), 500 query_features = feature_extractor.predict(processed_image, verbose=0) query_features_flat = query_features.flatten() # Buscar imágenes similares en la clase predicha class_images = dataset_features[predicted_class] similarities = [] for img_data in class_images: db_features = np.array(img_data['features']) similarity = cosine_similarity_np(query_features_flat, db_features) similarities.append({ 'filename': img_data['filename'], 'path': img_data['path'], 'similarity': round(similarity * 100, 2) }) # Ordenar por similitud (mayor a menor) similarities.sort(key=lambda x: x['similarity'], reverse=True) # Retornar top K top_similar = similarities[:top_k] return jsonify({ 'success': True, 'predicted_class': predicted_class, 'total_images_in_class': len(class_images), 'similar_images': top_similar, 'model_used': model_type }) except Exception as e: print(f"❌ Error buscando similares: {str(e)}") traceback.print_exc() return jsonify({ 'success': False, 'error': str(e) }), 500 @app.route('/api/random-images', methods=['GET', 'OPTIONS']) def get_random_images(): """Endpoint para obtener imágenes aleatorias del dataset filtradas por clase""" # Manejar preflight de CORS if request.method == 'OPTIONS': response = jsonify({'status': 'ok'}) response.headers.add('Access-Control-Allow-Origin', request.headers.get('Origin', '*')) response.headers.add('Access-Control-Allow-Methods', 'GET, OPTIONS') response.headers.add('Access-Control-Allow-Headers', 'Content-Type') return response try: # Obtener parámetros predicted_class = request.args.get('predicted_class') count = int(request.args.get('count', 3)) if not predicted_class: return jsonify({ 'success': False, 'error': 'Se requiere el parámetro predicted_class' }), 400 # Cargar features del dataset dataset_features = load_dataset_features() if not dataset_features: return jsonify({ 'success': False, 'error': 'Features del dataset no disponibles' }), 500 # Verificar que la clase existe en el dataset if predicted_class not in dataset_features: return jsonify({ 'success': False, 'error': f'Clase "{predicted_class}" no encontrada en dataset' }), 404 # Obtener todas las imágenes de la clase class_images = dataset_features[predicted_class] # Extraer solo los nombres de archivo image_filenames = [img_data['filename'] for img_data in class_images] # Seleccionar aleatoriamente (sin repetir) import random num_images = min(count, len(image_filenames)) selected_images = random.sample(image_filenames, num_images) print(f"✅ Seleccionadas {num_images} imágenes aleatorias de la clase '{predicted_class}'") return jsonify({ 'success': True, 'predicted_class': predicted_class, 'total_available': len(image_filenames), 'images': selected_images }) except Exception as e: print(f"❌ Error obteniendo imágenes aleatorias: {str(e)}") traceback.print_exc() return jsonify({ 'success': False, 'error': str(e) }), 500 @app.route('/', methods=['GET']) def home(): """Ruta raíz - Información de la API""" return jsonify({ 'message': '🦅 API del Clasificador de Aves del Tolima - ACTIVA', 'version': '1.0.0', 'status': 'online', 'endpoints': { 'GET /api/classes': 'Lista todas las especies disponibles', 'POST /api/detect-bird': 'Detecta ave en imagen (YOLO)', 'POST /api/predict': 'Clasifica ave detectada (DenseNet/VGG16)', 'GET /api/random-images?predicted_class=...': 'Obtiene galería de imágenes', 'GET /api/metrics': 'Métricas de los modelos' }, 'especies_disponibles': len(CLASS_NAMES), 'frontend': 'https://proyecto-aves.vercel.app' }) @app.route('/api/classes', methods=['GET']) def get_classes(): """Endpoint para obtener la lista de clases de aves""" return jsonify({ 'classes': CLASS_NAMES, 'total': len(CLASS_NAMES) }) @app.route('/api/metrics', methods=['GET']) def get_metrics(): """Endpoint para obtener métricas de los modelos""" metrics = { 'densenet': { 'name': 'DenseNet121', 'accuracy': 99.00, 'precision': 98.95, 'recall': 99.02, 'f1_score': 98.98, 'training_time': '~45 min', 'parameters': '7.5M', 'advantages': [ 'Mayor precisión general', 'Mejor en especies similares', 'Conexiones densas entre capas' ], 'disadvantages': [ 'Más pesado en memoria', 'Predicción ligeramente más lenta' ] }, 'vgg16': { 'name': 'VGG16', 'accuracy': 98.50, 'precision': 98.42, 'recall': 98.55, 'f1_score': 98.48, 'training_time': '~35 min', 'parameters': '14.7M', 'advantages': [ 'Predicción más rápida', 'Arquitectura clásica probada', 'Buena generalización' ], 'disadvantages': [ 'Menor precisión que DenseNet', 'Más parámetros' ] }, 'comparison': { 'best_model': 'DenseNet121', 'speed_winner': 'VGG16', 'accuracy_difference': 0.50, 'recommendation': 'DenseNet121 para máxima precisión, VGG16 para velocidad' } } return jsonify({ 'success': True, 'metrics': metrics }) if __name__ == '__main__': print("🚀 Iniciando servidor Flask...") print("� Los modelos se cargarán bajo demanda para ahorrar memoria") # NO precargar modelos (Render Free solo tiene 512MB RAM) # Los modelos se cargarán cuando se haga la primera predicción # Usar el puerto de la variable de entorno PORT o 5000 por defecto port = int(os.environ.get('PORT', 5000)) print(f"🌐 Servidor corriendo en puerto {port}") app.run(debug=False, host='0.0.0.0', port=port)