Siempre he sentido una profunda fascinación por las estrellas y las galaxias. De pequeño, con apenas 12 años, solía pasarme las noches observando el cielo desde mi habitación. Vivir en un pequeño pueblo tenía la ventaja de disfrutar de un firmamento despejado, libre de contaminación lumínica. Una noche, mientras intentaba identificar algunas constelaciones, vi un punto que se movía lentamente. Emocionado, corrí a despertar a mis padres (eran las 1:00 a.m.). “¡Papá, papá! ¡Algo se está moviendo en el cielo!”. Mi padre se levantó, miró con calma y, sin inmutarse, dijo: “Guille, gilipollas, eso es un satélite”. Acto seguido, se dio la vuelta y volvió a la cama.

Esa anécdota, aunque breve, me marcó profundamente. Tanto así, que mi proyecto de fin de carrera fue un “Simulador de Comunicaciones Digitales vía Satélite”. Siempre digo, medio en broma, que quería trabajar con satélites y explorar el espacio... y lo más lejos que llegué fue a trabajar en “la nube”.

Introducción

En el campo de la exploración espacial, los satélites desempeñan un papel fundamental. Para entender mejor este campo, hemos desarrollado una aplicación utilizando Streamlit, potenciada por la inteligencia artificial de Amazon Bedrock y las capacidades de Amazon Q Developer. La aplicación permite explorar una extensa base de datos de satélites, visualizar sus órbitas y obtener información detallada sobre cada uno de ellos.

A lo largo del desarrollo, nos hemos apoyado en Amazon Q Developer para optimizar la escritura del código y perfeccionar nuestra lógica. Aprovechamos tanto sus recomendaciones en tiempo real como el entorno de chat para resolver errores y ajustar funcionalidades. Esto nos ha permitido agilizar el proceso y poder centrarnos en la experiencia educativa.

Estructura del Proyecto y Configuración del Entorno

Estructura de Directorios

Para nuestro proyecto de visualización de satélites, hemos utilizado la siguiente estructura de directorios:

streamlit-project/
│
├── venv/                             # Entorno virtual de Python
├── data/                             # Carpeta de datos
│   ├── UCS-Satellite-Database-1-1-2023.csv  # Base de datos de satélites de la UCS
│   └── data.ipynb                    # Notebook para análisis de datos preliminares
├── configuration.ini                 # Archivo de configuración con rutas y parámetros
└── satellites.py                     # Contiene el código completo de la lógica de la aplicación
└── README.md                         # Contiene la documentación del proyecto

Descripción de los Archivos

venv/: Contiene el entorno virtual de Python, donde se instalan las dependencias necesarias para la ejecución del proyecto sin afectar otras configuraciones del sistema.

data/:

UCS-Satellite-Database-1-1-2023.csv: Archivo CSV con la base de datos de satélites proporcionada por la Union of Concerned Scientists (UCS), que es la fuente de datos principal para la aplicación.
data.ipynb: Jupyter Notebook con análisis preliminar del conjunto de datos, donde se visualizan las columnas, se realizan pruebas de limpieza y se genera un análisis exploratorio.

configuration.ini:

Archivo de configuración que permite especificar rutas y otros parámetros del proyecto, facilitando la modificación sin necesidad de alterar el código fuente. El contenido de configuration.ini podría ser similar a:

[input_data]
input_file = data/UCS-Satellite-Database-1-1-2023.csv

satellites.py:

Este archivo contiene el core de la aplicación: toda la lógica para la carga de datos, el procesamiento y la visualización con Streamlit. Además, integra la IA de Amazon Bedrock junto con algunas de las sugerencias generadas por Amazon Q Developer (que, aunque no siempre son perfectas, nos permiten ajustarlas y optimizar nuestro código).

Configuración del Entorno Virtual en VS Code

Para configurar y ejecutar nuestra aplicación Streamlit en VS Code usando un entorno virtual, sigue estos pasos:

1. Abre VS Code y navega hasta la carpeta de tu proyecto.
2. Abre una nueva terminal en VS Code (Terminal > New Terminal).
3. Crea un nuevo entorno virtual:

python3 -m venv venv

1. Activa el entorno virtual:

source venv/bin/activate

1. Configura VS Code para usar el entorno virtual:
2. Presiona Ctrl+Shift+P (o Cmd+Shift+P en macOS) para abrir la paleta de comandos.
3. Escribe "Python: Select Interpreter" y selecciona esta opción.

4. Elige el intérprete de Python en la carpeta venv de tu proyecto.

5. Ahora puedes abrir el archivo satellites.py en VS Code y editarlo según sea necesario.

Para ver cómo está quedando nuestra aplicación, simplemente necesitamos ejecutar la aplicación en streamlit:

Integración de Amazon Q Developer

Durante el desarrollo, implementamos dos formas de aprovechar las capacidades de Amazon Q Developer:

Recomendaciones de Código en Tiempo Real: Al escribir el código en el editor, Q Developer ofreció sugerencias basadas en patrones de código comunes y buenas prácticas. Esto nos permitió corregir errores y optimizar funciones sin tener que salir del entorno de desarrollo.

Interacción a través de un Chat IA: Si no te gustan las recomendaciones en el editor, puedes usar el entorno de chat de Q Developer. Haciendo preguntas específicas, obtuvimos ayuda en la resolución de problemas, como la codificación del fichero utilizado.

Otro uso destacado de Q Developer fue la optimización del prompt que utilizamos. Partíamos del siguiente código:

Nos encontramos con un problema, nuestra función permitía que el asistente respondiera sobre temas no relacionados con el espacio y los satélites. Para solucionarlo, decidimos implementar restricciones más estrictas. Con las recomendaciones de Q Developer, refinamos el prompt estableciendo guardrails, asegurando que las respuestas se mantuvieran siempre dentro del contexto deseado.

En el apartado Integración con Amazon Bedrock tienes la versión mejorada basada en sus sugerencias.

Si realizamos una pregunta fuera del ámbito espacial, el modelo nos indica que no está diseñado para responder ese tipo de consultas.

Si queréis integrar Amazon Q en vuestro editor VS Code, mi compañero Denis Traub os lo explica paso a paso en 1 minuto 👉 Cómo integrar Amazon Q Developer en VS Code.

La Base: Streamlit y Pandas

Nuestra aplicación se construye sobre Streamlit, un framework de Python que facilita la creación de aplicaciones web interactivas. Utilizamos Pandas para manejar y analizar los datos de la base de datos de satélites de UCS.

import streamlit as st
import pandas as pd

@st.cache_data
def load_data():
    file_path = 'UCS-Satellite-Database-1-1-2023.csv'
    df = pd.read_csv(file_path, encoding='latin1')
    df['Date of Launch'] = pd.to_datetime(df['Date of Launch'], format='%m/%d/%Y', errors='coerce')
    return df

df = load_data()

Este código carga los datos y los prepara para su uso en la aplicación. La función @st.cache_data asegura que los datos se carguen una sola vez y se almacenen en caché para un acceso más rápido.

Visualización de Datos con Plotly

Para crear visualizaciones interactivas, utilizamos Plotly. Esto nos permite generar gráficos dinámicos que muestran información como la distribución de satélites por país o tipo de órbita.

import plotly.express as px

st.subheader('Top 10 Countries by Number of Satellites')
top_countries = df['Country of Operator/Owner'].value_counts().nlargest(10)
fig = px.bar(top_countries, title='Top 10 Countries by Number of Satellites')
st.plotly_chart(fig)

Visualización de Órbitas en 3D

Uno de los aspectos más complicados fue la creación de una visualización 3D de las órbitas de los satélites. Utilizamos Plotly para crear un globo terráqueo interactivo con la órbita del satélite superpuesta.

import plotly.graph_objects as go
import numpy as np

# Cálculo de la órbita
t = np.linspace(0, 2*np.pi, 100)
r = (perigee + apogee) / 2 + 6371  # Radio promedio de la órbita
x = r * np.cos(t)
y = r * np.sin(t) * np.cos(np.radians(inclination))
z = r * np.sin(t) * np.sin(np.radians(inclination))

# Conversión a latitud/longitud
orbit_lon = np.degrees(np.arctan2(y, x))
orbit_lat = np.degrees(np.arcsin(z/r))

fig = go.Figure()

# Añadir la órbita
fig.add_trace(go.Scattergeo(
    lon = orbit_lon,
    lat = orbit_lat,
    mode = 'lines',
    line = dict(width = 2, color = 'yellow'),
    name = 'Orbit'
))

# Añadir la posición del satélite
fig.add_trace(go.Scattergeo(
    lon = [lon],
    lat = [lat],
    mode = 'markers',
    marker = dict(size = 15, color = 'red', symbol = 'star'),
    name = 'Satellite'
))

fig.update_geos(
    projection_type = "orthographic",
    landcolor = "lightgreen",
    oceancolor = "lightblue",
    showocean = True,
    showland = True,
    showcoastlines = True,
    coastlinecolor = "black",
    showlakes = True,
    lakecolor = "blue",
    showcountries = True,
    countrycolor = "black",
    center = dict(lon = lon, lat = lat),
    projection_rotation = dict(lon = lon, lat = lat, roll = 0)
)

st.plotly_chart(fig)

Integración de Amazon Bedrock

La magia de nuestra aplicación, o al menos lo más interesante, radica en la integración de Amazon Bedrock, que nos permite incorporar capacidades de inteligencia artificial para responder preguntas de los usuarios sobre satélites.

# Bedrock response function
def get_bedrock_response(prompt, model_id="anthropic.claude-v2"):
    bedrock = boto3.client(service_name='bedrock-runtime', region_name='us-east-1')

        # Define the allowed topics
    allowed_topics = ["space", "astronomy", "NASA", "ISS", "ESA", "satellites"]

    # Create a guardrail instruction
    guardrail_instruction = (
        "You are an AI assistant specialized in space-related topics. "
        "Your responses must be strictly related to space, astronomy, NASA, ISS, ESA, or satellites. "
        "If the query is not related to these topics, politely inform the user that you can only "
        "discuss space-related subjects and suggest they rephrase their question to be about space."
    )

    # Combine the guardrail instruction with the user's prompt
    full_prompt = f"{guardrail_instruction}\n\nHuman: {prompt}\n\nAssistant:"

    body = json.dumps({
        "prompt": full_prompt,
        "max_tokens_to_sample": 500,
        "temperature": 0.5,
        "top_p": 1,
        "stop_sequences": ["\n\nHuman:"]
    })

    response = bedrock.invoke_model(
        body=body,
        modelId=model_id,
        accept='application/json',
        contentType='application/json'
    )

    response_body = json.loads(response.get('body').read())
    raw_response = response_body.get('completion', '')

    # Additional check to ensure the response is on-topic
    if not any(topic.lower() in raw_response.lower() for topic in allowed_topics):
        return ("I apologize, but I can only provide information about space, astronomy, "
                "NASA, ISS, ESA, or satellites. Could you please ask a question related to these topics?")

    return raw_response.strip()

Esta función utiliza el cliente de Boto3 para interactuar con Amazon Bedrock. Enviamos una pregunta (prompt) al modelo de IA, y este genera una respuesta. Si la respuesta está dentro de los límites de seguridad (guardrails) establecidos, nos proporcionará la información solicitada. De lo contrario, indicará que no está entrenado para responder a ese tipo de consultas.

Implementación del Chat IA

Implementamos dos secciones de chat en nuestra aplicación: una para preguntas generales sobre satélites y otra para preguntas específicas sobre un satélite seleccionado.

st.subheader('Ask Questions About Satellites')
question = st.text_input('Enter your question about satellites:')
if question:
    with st.spinner('Generating response...'):
        prompt = f"Human: Answer this question about satellites: {question}\nOnly provide information related to satellites, space technology, and Earth observation. Do not discuss politics, military details, or any sensitive topics.\n\nAssistant:"
        response = get_bedrock_response(prompt)
        st.write(response)

La función interactúa con Amazon Bedrock, permitiendo a los usuarios realizar consultas específicas sobre los satélites seleccionados.

Quizás os preguntéis, ¿por qué dos funciones de IA si parecen iguales?

Aunque la implementación del Chat IA también utiliza la misma función de get_bedrock_response, su enfoque es diferente: este chat está específicamente diseñado para preguntas sobre satélites individuales. Es importante ajustar el prompt para que cada respuesta se centre en la información específica del satélite seleccionado. Podemos añadir instrucciones adicionales para mantener la coherencia si fuese necesario.

Nuestra Aplicación

A continuación os mostramos cómo queda la aplicación, destacando las dos principales opciones de navegación: "Overview" y "Satellite Search".

En la vista "Overview", podéis explorar rápidamente las estadísticas y visualizaciones de los satélites, como el número total por país o tipo de órbita.

En la opción "Satellite Search", es posible buscar información detallada de un satélite específico, incluyendo su nombre, órbita, velocidad y trayectoria.

Código Completo

Si queréis replicar (y mejorar la aplicación) os dejamos el código en el siguiente repositorio.

Link: https://github.com/iaasgeek/satellites-AI/tree/main

Conclusión

Esta aplicación combina el potencial de Streamlit para interfaces de usuario, Plotly para visualizaciones interactivas y Amazon Bedrock para capacidades de IA, creando una forma distinta de explorar satélites.

En el futuro, planeamos incorporar visualizaciones 3D más avanzadas y aprovechar aún más la IA para ofrecer análisis predictivos y recomendaciones basadas en los datos espaciales.

Como veis, este proyecto muestra cómo la integración de diferentes tecnologías puede dar lugar a herramientas educativas que pueden ser entretenidas, en nuestro caso, en el ámbito de la exploración espacial.