Detección remota multiespectral con Gemini
Copyright 2026 Google LLC.
#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
En este notebook, aprenderás a usar las capacidades de comprensión de imágenes de Gemini para el análisis multiespectral y la detección remota.
¿Qué es la detección remota?
La detección remota es el proceso de adquirir información sobre un objeto o área sin hacer contacto físico con él. Es, esencialmente, "ver" y medir algo a distancia.
La forma más común de detección remota implica el uso de sensores en satélites para recopilar datos sobre la superficie de la Tierra. Tener un registro de imágenes de la superficie de la Tierra a lo largo del tiempo nos permite rastrear cambios como: ¿Dónde están desapareciendo los bosques? ¿Dónde están ocurriendo incendios? Y responder preguntas como: ¿Están sanos los cultivos en este campo? ¿Cuál es el potencial solar de este techo? Todas estas preguntas (¡y más!) pueden responderse con la ayuda de datos satelitales.
Gran parte del poder de estas imágenes satelitales reside en su capacidad para capturar datos multiespectrales. En lugar de las 3 bandas RGB a las que estás acostumbrado, estos satélites pueden capturar datos en muchas bandas diferentes del espectro electromagnético, incluidas aquellas que los humanos no pueden ver, como el infrarrojo cercano (NIR) y el infrarrojo de onda corta (SWIR). Ciertas longitudes de onda son beneficiosas para ciertos casos de uso, por ejemplo:
- Salud de la vegetación: Las plantas sanas reflejan mucha luz NIR. Al observar la banda NIR, puedes evaluar la salud de los cultivos o monitorear la deforestación con mucha más precisión que con una simple foto verde.
- Detección de agua: El agua absorbe la luz infrarroja, lo que facilita distinguirla de la tierra, mapear llanuras aluviales o incluso analizar la calidad del agua.
- Cicatrices de quemaduras: Las bandas SWIR son excelentes para penetrar el humo e identificar áreas recientemente quemadas después de un incendio forestal.
- Identificación de materiales: Diferentes minerales y materiales hechos por el hombre tienen "huellas dactilares" espectrales únicas, lo que te permite identificarlos desde el espacio.
Los modelos fundacionales multimodales como Gemini están entrenados para comprender imágenes RGB y no todas estas otras posibles bandas espectrales. Sin embargo, al mapear otras partes del espectro electromagnético al espacio RGB y proporcionar instrucciones específicas del dominio, puedes aprovechar la comprensión de Gemini del espacio visual para el prompting zero-shot de imágenes multiespectrales.
En este notebook aprenderás a aprovechar estos modelos multimodales generalistas para tareas especializadas sin entrenamiento adicional ni fine-tuning.
Este notebook se basa en el artículo de Google DeepMind y Google Research, Zero-Shot Multi-Spectral Learning: Reimagining a Generalist Multimodal Gemini 2.5 Model for Remote Sensing Applications
Configuración
Instalar el SDK
%pip install -U -q "google-genai>=2.9.0" # Install the Python SDK
# Always set at least 1.0.0 as the minimal version as there were breaking
# changes through the previous versions
# Of course, if your notebook uses a new feature and needs a more recent
# version, set the right minimum version to indicate when the feature was
# introduced.
# Always test your notebook with that fixed version (eg. '==1.0.0') to make.
# sure it's really the minimum version.
Configurar tu clave de API
Para ejecutar la siguiente celda, tu clave de API debe estar almacenada en un Secreto de Colab llamado GEMINI_API_KEY. Si aún no tienes una clave de API, o no estás seguro de cómo crear un Secreto de Colab, consulta el inicio rápido de Autenticación 
para ver un ejemplo.
from google.colab import userdata
from google import genai
GEMINI_API_KEY = userdata.get('GEMINI_API_KEY')
client = genai.Client(api_key=GEMINI_API_KEY)Para este notebook, usa Gemini 2.5 Pro.
MODEL_ID = "gemini-3.7-flash" # @param ["gemini-3.1-pro-preview", "gemini-3.7-flash", "gemini-3.5-flash-lite", "gemini-2.5-pro"] {"allow-input":true, isTemplate: true}Detección remota con imágenes RGB
Primero, prueba la capacidad de Gemini para interpretar datos satelitales con una imagen solo RGB.
Aquí tienes una imagen de un bosque tomada con el satélite Sentinel 2.
from IPython.display import display, Markdown, Image!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest.png -O forest.pngdisplay(Image('forest.png', width=200))<IPython.core.display.Image object>A continuación, pide a Gemini que clasifique esta imagen.
prompt = """
Classify this image as one of the following categories:
AnnualCrop, Forest, HerbaceousVegetation, Highway, Industrial, Pasture, PermanentCrop, Residential, River, SeaLake.
"""from google.genai import types
with open('forest.png', 'rb') as f:
image_bytes = f.read()
response = client.models.generate_content(
model=MODEL_ID,
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/png',
),
prompt
]
)
Markdown(response.text)<IPython.core.display.Markdown object>Gemini predice incorrectamente que esta imagen es un SeaLake, razonando sobre las áreas azules/verdes. Al modelo le faltan los datos multiespectrales críticos necesarios para hacer una predicción precisa.
Detección remota con imágenes multiespectrales
Para realizar la detección remota multiespectral zero-shot con Gemini, necesitas:
- Transformar las entradas multiespectrales al espacio de pseudoimagen.
- Crear un prompt que describa científicamente lo que representan las nuevas entradas.
Para ver este proceso en acción, añadirás cinco imágenes adicionales al prompt. Estas imágenes incluyen información sobre las otras bandas espectrales de Sentinel 2.
Descargar imágenes
Descarga las imágenes de un bucket público de Cloud Storage para verlas.
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest_0.jpeg -O forest_0.jpeg
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest_1.jpeg -O forest_1.jpeg
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest_2.jpeg -O forest_2.jpeg
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest_3.jpeg -O forest_3.jpeg
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest_4.jpeg -O forest_4.jpeg
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/forest_5.jpeg -O forest_5.jpegimage_0 es la imagen RGB de la sección anterior.
display(Image('forest_0.jpeg', width=200))<IPython.core.display.Image object>Las imágenes 1-5 representan combinaciones de diferentes bandas espectrales. Puedes ver que estas combinaciones de bandas revelan nuevas características que no eran visibles en la imagen RGB.
print('multi-spectral images')
display(Image('forest_1.jpeg', width=200))
display(Image('forest_2.jpeg', width=200))
display(Image('forest_4.jpeg', width=200))multi-spectral images<IPython.core.display.Image object><IPython.core.display.Image object><IPython.core.display.Image object>Crear un prompt multiespectral
Además de las imágenes multiespectrales, proporcionarás a Gemini información específica del dominio sobre cómo se creó cada una de estas nuevas imágenes.
multispectral_prompt = """
Instructions: Answer the question asked after the given 6 images of the same scene.
The images are generated by selecting different bands of the Sentinel-2 satellite.
The band information is as follows:
1. B02: Blue band at 10-meter resolution
2. B03: Green band at 10-meter resolution
3. B04: Red band at 10-meter resolution
4. B05: Red edge band (Central wavelength of 704.1 nm) at 20-meter resolution
5. B06: Red edge band (Central wavelength of 740.5 nm) at 20-meter resolution
6. B07: Red edge band (Central wavelength of 782.8 nm) at 20-meter resolution
7. B08: NIR band at 10-meter resolution
8. B8A: Narrow NIR band at 20-meter resolution
9. B01: Costal Aerosol band at 60-meter resolution
10. B09: Water vapor band at 60-meter resolution
11. B11: SWIR band (Central wavelength 1613.7 nm) at 20-meter resolution
12. B12: SWIR band (Central wavelength 2202.4 nm) at 20-meter resolution.
The first image is the RGB image generated using B04, B03 and B02 bands.
The second image is the False Color Composite image generated using B08, B04 and B03 bands.
The third image is the NDVI image which is a colormap with values Red, Yellow and Green
generated using B08 and B04 bands.
The fourth image is NDWI image whose values are in the range of -0.8 to 0.8 and using
a color map varying linearly as [(1, 1, 1), (1, 1, 1), (0, 0, 1)].
The fifth and sixth images are the NDMI images generated using B8A and B11 or B12 bands
with the colormap varying linearly as [(1, 0, 0), (0, 1, 0), (0, 0, 1)].
Output format: Output the option numbers corresponding to the correct answer in the format
"(X)" where X is the correct number choice. In case of multiple correct
answers, output the answer choices in the same format separated by commas. For example,
if the correct answers are choices 1 and 3, output "(1),(3)". Only output the option
numbers in the above format and DO NOT OUTPUT the full answer text or any other extra words.
Question: To which of the following classes do the given images belong to? Select all that apply. Possible answer choices:
(1) AnnualCrop, (2) Forest, (3) HerbaceousVegetation, (4) Highway, (5) Industrial, (6) Pasture, (7) PermanentCrop, (8) Residential, (9) River, (10) SeaLake.
"""
Sube las imágenes con la API de Archivos para que Gemini pueda procesarlas.
image_0 = client.files.upload(file="forest_0.jpeg")
image_1 = client.files.upload(file="forest_1.jpeg")
image_2 = client.files.upload(file="forest_2.jpeg")
image_3 = client.files.upload(file="forest_3.jpeg")
image_4 = client.files.upload(file="forest_4.jpeg")
image_5 = client.files.upload(file="forest_5.jpeg")response = client.models.generate_content(
model=MODEL_ID,
contents=[image_0, image_1, image_2, image_3, image_4, image_5, multispectral_prompt])
print(response.text)(2)El modelo responde con (2), que corresponde a "Bosque" en nuestro prompt.
Equipado con la información multiespectral, Gemini clasifica correctamente la imagen.
Creación de imágenes compuestas multiespectrales
En la sección anterior viste que añadir datos multiespectrales a tu prompt puede ayudar a Gemini a clasificar correctamente las imágenes satelitales.
En esta sección aprenderás a crear estas imágenes multiespectrales, y cómo puedes crear tus propias imágenes basadas en las bandas relevantes para tu dominio, en dos pasos:
Selecciona tres bandas espectrales que sean importantes para tu problema específico.
Escala los datos de cada banda a un rango entero estándar de 0-255 y asígnalos a los canales Rojo, Verde y Azul de una nueva imagen.
Primero, descarga los datos multiespectrales de la imagen del bosque.
!wget -q https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/images/remote-sensing/download_fo_multi_spectral_bands.npy -O download_fo_multi_spectral_bands.npyimport numpy as np
s2_image = np.load('download_fo_multi_spectral_bands.npy')print(s2_image.shape)(64, 64, 13)Esta imagen satelital del bosque se representa como un array numpy con forma (64,64,13), lo que significa que hay 13 bandas espectrales diferentes capturadas por el satélite. R, G y B son 3 de estas 13 bandas. Cada banda está representada por una matriz de 64x64.
Si quisieras recrear la imagen RGB que trazaste anteriormente, apilarías los canales RGB y terminarías con un array de tamaño 64x64x3.
Ejemplo de imagen multiespectral: NDVI
Vas a recrear la imagen_2 que representa el Índice de Vegetación de Diferencia Normalizada (NDVI).
El NDVI es una métrica comúnmente utilizada en la detección remota para cuantificar la cantidad, densidad y salud de la vegetación en un área determinada. Funciona midiendo la forma única en que las plantas interactúan con longitudes de onda de luz específicas.
Para calcular el NDVI, se utilizan las bandas de Luz Roja (Red) y Luz Infrarroja Cercana (NIR). La fórmula es:
(nir_band - red_band) / (nir_band + red_band)
Para hacer este cálculo, necesitas conocer el mapeo de los nombres de las bandas a los índices en el array numpy. Luego puedes extraer las bandas Roja y NIR. Para ver una descripción completa de los nombres y atributos de las bandas Sentinel, consulta la documentación de Sentinel 2 Earth Engine.
band_name_to_index={
"B01": 0,
"B02": 1,
"B03": 2,
"B04": 3,
"B05": 4,
"B06": 5,
"B07": 6,
"B08": 7,
"B8A": 8,
"B09": 9,
"B10": 10,
"B11": 11,
"B12": 12,
}
red_band = s2_image[:, :, band_name_to_index['B04']]
nir_band = s2_image[:, :, band_name_to_index['B08']]Puedes ver que las bandas Roja y NIR tienen forma (64x64)
print(red_band.shape)
print(nir_band.shape)(64, 64)
(64, 64)La función a continuación toma las bandas Roja y NIR y calcula el NDVI.
import matplotlib.pyplot as plt
def generate_ndvi_image(
red_band: np.ndarray, nir_band: np.ndarray
) -> np.ndarray:
"""Generate an NDVI image from red and nir bands."""
# calculate ndvi
ndvi_image = (nir_band - red_band) / (nir_band + red_band)
# map to rgb
ndvi_image = plt.get_cmap('RdYlGn')(ndvi_image)
# scale to 0-255
ndvi_image = np.uint8(ndvi_image * 255)
return ndvi_imageRepasemos los pasos de esta función.
Primero, realiza el cálculo del NDVI
ndvi_image = (nir_band - red_band) / (nir_band + red_band)
El ndvi_image en este punto es un array similar a una escala de grises donde cada valor de píxel es un número de punto flotante que representa la puntuación NDVI. Aunque tiene un significado numérico, aún no se puede ver como una imagen en color estándar.
Para que esta información sea comprensible por Gemini, necesitas escalar los datos a un rango entero estándar de 0-255 y asignarlos a los canales Rojo, Verde y Azul de una nueva imagen. Esto se conoce como mapeo de color.
ndvi_image = plt.get_cmap('RdYlGn')(ndvi_image)
El mapeo de color utilizado aquí define un espectro donde un extremo (Rojo) corresponde a los valores más bajos (por ejemplo, -1.0), y el otro extremo (Verde) corresponde a los valores más altos (por ejemplo, +1.0). Cuando se llama a la función de mapa de color con el array ndvi_image (...('RdYlGn')(ndvi_image)), realiza una búsqueda y conversión elemento por elemento.
Las puntuaciones NDVI más bajas (agua, roca o plantas poco saludables) se asignan a un color Rojo o naranja oscuro.
Las puntuaciones de rango medio se asignan a Amarillo.
Las puntuaciones NDVI más altas (vegetación densa y saludable) se asignan a un color Verde.
En la siguiente celda, trazarás la imagen con el mapa de color y verás que es mayormente verde (¡lo cual tiene sentido ya que es una imagen de un bosque!).
Por último, para preparar la imagen para su visualización o guardado en formatos de imagen estándar (como PNG o JPEG), los valores de punto flotante (0.0 a 1.0) se convierten al rango entero de 0 a 255.
ndvi_image = np.uint8(ndvi_image * 255)
Ahora puedes ejecutar la función NDVI para crear la nueva imagen compuesta
ndvi_image = generate_ndvi_image(red_band, nir_band)plt.imshow(ndvi_image)<matplotlib.image.AxesImage at 0x7e7ff09b1370><Figure size 640x480 with 1 Axes>Siguiendo este proceso de selección de bandas relevantes y luego mapeándolas por color, puedes inyectar información multiespectral en tu prompt y usar Gemini para la detección remota zero-shot.
Qué sigue
Para obtener más información sobre cómo usar Gemini para la detección remota, consulta el artículo original.