Project New Horizon

Resumen

Servicio web para la predicción de exoplanetas basado en aprendizaje automático. Un clasificador XGBoost, entrenado con datos astrofísicos, clasifica objetos celestes como exoplanetas o no. Incluye un backend en Flask que expone el modelo vía una API ligera y un frontend HTML/JavaScript interactivo para introducir características y obtener predicciones en tiempo real.

---

Demo

Video: https://drive.google.com/file/d/1Mx_sn9l8d8qKxDeVmHakhRk5n4SKhv-O/view?usp=sharing

---

Detalles del proyecto

• Modelo: Clasificador XGBoost entrenado en Python.
• Preprocesado: scikit-learn para escalado y transformaciones; modelo y scaler persistidos con joblib.
• Backend: Flask + Flask-CORS con endpoint POST /predict que:
  • recibe JSON,
  • calcula características derivadas cuando corresponde,
  • aplica el escalado de características,
  • devuelve probabilidad y clasificación categórica.
• Frontend: HTML + JavaScript que consulta la API via AJAX y muestra resultados en tiempo real.

---

API (ejemplo)

POST /predict
Headers:

• Content-Type: application/json

Body (ejemplo): { "feature_1": valor, "feature_2": valor, ... }

Respuesta (ejemplo): { "probability": 0.87, "prediction": "exoplanet" }

---

Tecnologías

• Python (XGBoost, scikit-learn, pandas)
• Flask, Flask-CORS
• HTML5, CSS3, JavaScript
• joblib para persistencia del modelo

---

Conjuntos de datos

• Kepler Objects of Interest (KOI)
• TESS Objects of Interest (TOI)
• K2 planets and candidates

---

Uso de IA

Herramientas utilizadas durante el desarrollo: GitHub Copilot y Perplexity (para productividad y sugerencias).

---

Notas

El repositorio contiene una versión seleccionada y limpia de un cuaderno Jupyter original de más de 2000 líneas, reorganizada para despliegue y demostración.

---

Instrucciones para ejecutar y compilar localmente

Estas instrucciones asumen que tienes Python 3.10+ instalado y que trabajas en macOS/Linux. Los comandos están en español y son los mínimos necesarios para ejecutar la API de Flask y probar el frontend localmente.

1) Crear y activar un entorno virtual (recomendado)

Desde la raíz del proyecto:

# crear el entorno virtual
python3 -m venv .venv

# activar (macOS / Linux, zsh/bash)
source .venv/bin/activate

2) Instalar dependencias

Con el entorno activado instala las dependencias del archivo requirements.txt:

pip install --upgrade pip
pip install -r requirements.txt

Nota: requirements.txt incluye Flask y dependencias; el proyecto también contiene fastapi y uvicorn por compatibilidad en otros despliegues, pero el backend principal aquí es Flask (archivo backend/app.py).

3) Preparar archivos del modelo

En la carpeta backend/ están los artefactos serializados modelV1.joblib y modelV1_scaler.joblib. Asegúrate de que ambos existan en backend/ (ya están en el repo). Si trabajas desde la raíz del proyecto, el backend asume los archivos en la misma carpeta que app.py.

4) Ejecutar el backend (modo desarrollo)

Ir a la carpeta backend y lanzar la app Flask:

cd backend
export FLASK_APP=app.py
# Opcional: activar debug localmente mientras desarrollas
# export FLASK_ENV=development
flask run --host=0.0.0.0 --port=5000

La API quedará disponible en http://localhost:5000/ y el endpoint de predicción en http://localhost:5000/predict.

5) Ejecutar el backend con Gunicorn (producción simple)

Para un despliegue local más parecido a producción, desde backend/ (y con el entorno activado):

cd backend
gunicorn -w 4 -b 0.0.0.0:5000 app:app

6) Probar la API

Puedes usar curl, Postman o el frontend incluido. Ejemplo con curl (reemplaza los valores de las features por números reales):

curl -X POST http://localhost:5000/predict \
	-H "Content-Type: application/json" \
	-d '{"orbper":10.5, "trandur":5.3, "trandep":0.002, "rade":1.0, "insol":1.2, "eqt":500, "teff":5800, "rad":1.0, "logg":4.3, "depth_per_duration":0.0004, "insol_per_radius2":1.2, "radius_teff_ratio":0.0002, "insol_orbper_ratio":0.12, "logg_teff_product":24940}'

La respuesta será un JSON con prediction y probability.

7) Ejecutar el frontend localmente

El frontend está implementado como archivos estáticos (index.html, js/, css/). Puedes abrir index.html directamente en el navegador si tus llamadas al backend apuntan a http://localhost:5000. Si el navegador bloquea solicitudes CORS al abrir el archivo localmente, sirve los archivos estáticos con un servidor simple:

# desde la raíz del proyecto
python3 -m http.server 8000
# luego abre http://localhost:8000/index.html

Si el frontend y backend están en orígenes distintos, el backend ya tiene habilitado CORS en app.py.

8) Variables de entorno útiles

• PORT: puerto para la app Flask cuando se lanza con python app.py o mediante el bloque if __name__ == '__main__'.

9) Errores comunes

• Si recibes errores tipo joblib.load file not found: verifica que estés en backend/ o usa rutas absolutas para los artefactos.
• Errores de versión: si scikit-learn o numpy difieren, recrea el entorno con las versiones en requirements.txt.

---

Mantenimiento y notas para desarrolladores

• Punto de entrada backend: backend/app.py.
• Archivos de modelo: backend/modelV1.joblib, backend/modelV1_scaler.joblib.
• Si quieres reentrenar el modelo, revisa la carpeta training/ donde están los notebooks y scripts originales.