Ep 54 — Herramientas de código abierto (parte 2): HyperSpy, Orange-Spectroscopy

Serie: Enciclopedia de espectroscopia infrarroja: de la teoría a la práctica
Capítulo: Quinto · Instrumentos y herramientas — Ecosistema de código abierto (Ep 46–55, segunda parte)
Público objetivo: Técnicos que desean mejorar la eficiencia del procesamiento de datos, usuarios de imágenes de infrarrojo microscópico/FPA, entusiastas de la quimiometría, analistas sin necesidad de programación
Conocimientos previos: Ep 18 (procesamiento de espectros), Ep 19 (búsqueda en bibliotecas), Ep 20 (análisis cuantitativo), Ep 53 (herramientas de código abierto, parte 1)
Tiempo de lectura: Aproximadamente 45 minutos

Introducción: un conjunto de datos de imagen FPA de "4 GB"

Xiao Wang, de un laboratorio de materiales, utilizó un Bruker Hyperion 3000 con un detector FPA de 64×64 para escanear una imagen de infrarrojo microscópico de una membrana de mezcla de polímeros. Después de exportar los datos, el tamaño del archivo era de 4 GB: 4096 espectros, cada uno de 4000–900 cm⁻¹, 1769 puntos de datos. El software OPUS podía abrirlo, pero cada operación requería esperar 30 segundos. El análisis que quería realizar era complejo:

1. Dibujar la imagen química a 1740 cm⁻¹ (C=O de poliéster);
2. Descomponer 3 espectros de componentes puros mediante PCA;
3. Realizar un ajuste de curvas en el espectro de cada píxel para cuantificar la proporción poliéster/poliamida;
4. Visualizar los resultados superpuestos sobre la fotografía óptica de la muestra.

Las funciones incorporadas de OPUS solo podían completar el paso 1 de manera limitada. El supervisor le recomendó HyperSpy, un referente de código abierto para el análisis de datos espectrales multidimensionales. Una semana después, Xiao Wang completó los 4 pasos de análisis con HyperSpy y convirtió el código en un flujo de trabajo reutilizable; cada conjunto de datos de imagen posterior tardó menos de 5 minutos en dar resultados [1].

"Para datos espectrales multidimensionales (imágenes, series temporales, barridos en profundidad), HyperSpy es una herramienta de código abierto muy útil. Trata el 'cubo de datos' como un ciudadano de primera clase."
— Adaptado de la reseña de Microscopy & Microanalysis 2022 [1]

Este episodio analizará sistemáticamente cuatro herramientas de código abierto para espectroscopia: HyperSpy (referente en análisis de imágenes espectrales multidimensionales), Orange-Spectroscopy (flujo de trabajo visual por arrastrar y soltar), SpectraKit (operaciones básicas ligeras) y NIRS4ALL (marco unificado de aprendizaje profundo + PLS). Cada una incluye enlace a GitHub, número de estrellas y código práctico.

💡 Enfoque de este episodio: El Ep 53 trata marcos generales; el Ep 54 se dirige a herramientas "especializadas": HyperSpy se centra en imágenes multidimensionales, Orange se centra en flujos de trabajo sin programación. Ambos se complementan para formar un ecosistema completo de herramientas de código abierto para espectroscopia.

1. HyperSpy: referente en análisis de imágenes espectrales multidimensionales

1.1 Resumen del proyecto

HyperSpy es una biblioteca Python de código abierto especializada en el análisis de datos espectrales multidimensionales, ampliamente utilizada en espectroscopia electrónica de microscopía y análisis espectral multidimensional; para su uso con FTIR FPA, es necesario adaptar el formato de datos y el preprocesamiento específico de infrarrojo [1][2][3].

• GitHub: https://github.com/hyperspy/h…
• Documentación: https://hyperspy.org/
• Estrellas: aproximadamente 560+ (consulte la página de GitHub al momento del acceso; no debe absolutizarse como "la más alta en espectroscopia")
• Licencia: GPL-3.0
• Primera publicación: 2011
• Versión de Python: 3.9+
• Institución detrás: Diamond Light Source (Reino Unido), ICMCB (Francia), etc.

Figura 1: Página principal de HyperSpy en GitHub (fuente: https://github.com/hyperspy/h…)

1.2 Estructura de datos central: Signal

El núcleo de HyperSpy es la clase Signal, un contenedor de datos N-dimensional que distingue entre "ejes de navegación" y "eje de señal" [2][3]:

import hyperspy.api as hs

# Cargar datos de imagen FPA (64×64 píxeles × 1769 números de onda)
s = hs.load('polymer_blend.hyspermap')

# Ver las dimensiones de los datos
print(s)
# <Signal2D, title: , dimensions: (64, 64|1769)>
#                    ↑eje navegación↑      ↑eje señal↑

El significado de (64, 64|1769) [2]:

• Ejes de navegación: 64×64 píxeles espaciales;
• Eje de señal: 1769 puntos de número de onda por píxel.

Esta distinción entre "navegación vs señal" es la innovación central de HyperSpy, que hace que la manipulación de datos multidimensionales sea intuitiva [2][3]:

# Obtener el espectro de un píxel
s.inav[10, 20].plot()  # Espectro del píxel (10, 20)

# Obtener la imagen química en un número de onda
s.isig[1740.0].plot()  # Imagen química a 1740 cm⁻¹ (modo T)

# Obtener una región rectangular
s.inav[10:20, 30:40].plot()  # Espectro promedio de esa región rectangular

1.3 Cobertura del flujo completo

HyperSpy cubre el flujo completo de análisis espectral multidimensional [2][3]:

Carga → Preprocesamiento → Descomposición (PCA/ICA) → Ajuste → Visualización → Exportación
 │       │          │              │        │        │
 │       │          │              │        │        └ HDF5, npy, TIFF
 │       │          │              │        └ plot, plot_images, plot_spectra
 │       │          │              └ Ajuste multimodal, model fitting
 │       │          └ PCA, ICA, VCA, NMF, BSS
 │       └ Corrección de línea base (integración pybaselines), suavizado, normalización
 └ Múltiples formatos (HSPY, HDF5, Bruker, Thermo, EDAX, etc.)

1.4 Práctica: procesamiento de cubo de datos de imagen FPA

A continuación, se muestra un ejemplo completo del flujo de procesamiento de datos de imagen FPA con HyperSpy [1][2][3]:

import hyperspy.api as hs
import numpy as np

# ========== 1. Cargar datos ==========
s = hs.load('polymer_blend.hyspermap')
print(s)  # (64, 64|1769)

# Establecer el eje de señal como número de onda
s.axes_manager.signal_axes[0].offset = 900
s.axes_manager.signal_axes[0].scale = 0.25  # 0.25 cm⁻¹/punto
s.axes_manager.signal_axes[0].units = 'cm⁻¹'
s.axes_manager.signal_axes[0].name = 'Número de onda'

# Establecer los ejes de navegación
s.axes_manager.navigation_axes[0].units = 'μm'
s.axes_manager.navigation_axes[0].scale = 5.5  # 5.5 μm/píxel
s.axes_manager.navigation_axes[0].name = 'X'
s.axes_manager.navigation_axes[1].units = 'μm'
s.axes_manager.navigation_axes[1].scale = 5.5
s.axes_manager.navigation_axes[1].name = 'Y'

# ========== 2. Preprocesamiento ==========

# 2.1 Recortar la región de interés (1800-900 cm⁻¹)
s_cut = s.isig[1800.0:900.0]

# 2.2 Corrección de línea base (con pybaselines)

from pybaselines.whittaker import arpls

def baseline_pixel(y):
return arpls(y, lam=1e7)[0]

Corrección de línea base por píxel

s_bc = s_cut.map(baseline_pixel, inplace=False, ragged=False)

2.3 Normalización (independiente por píxel)

s_norm = s_bc / s_bc.max(axis=-1) # Normalizar a lo largo del eje de señal

========== 3. Descomposición PCA ==========

3.1 PCA

s_norm.decomposition()
s_norm.plot_explained_variance_ratio()

3.2 Tomar las primeras 3 componentes principales

sc = s_norm.get_decomposition_model(3)
sc.plot()

3.3 Deconvolución ICA (BSS)

s_bss = s_norm.blind_source_separation(3)
s_bss.plot()

========== 4. Imágenes químicas ==========

4.1 Imagen química a 1740 cm⁻¹ (C=O de poliéster)

s_norm.isig[1740.0].plot(cmap='viridis', colorbar=True,
title='Distribución de poliéster (1740 cm⁻¹)')

4.2 Imagen química a 1630 cm⁻¹ (Amida I de poliamida)

s_norm.isig[1630.0].plot(cmap='plasma', colorbar=True,
title='Distribución de poliamida (1630 cm⁻¹)')

========== 5. Ajuste multimodal (cuantificación por píxel) ==========

Crear modelo

m = s_norm.create_model()

Añadir 3 picos Gaussianos

m.append(hs.model.components1D.GaussianHFWHM(center=1740, fwhm=20))
m.append(hs.model.components1D.GaussianHFWHM(center=1630, fwhm=25))
m.append(hs.model.components1D.GaussianHFWHM(center=1540, fwhm=25))

Ajustar todos los píxeles

m.multifit()

Extraer mapas de intensidad de cada componente

polyester_map = m.components.GaussianHFWHM.A.map
polyamide1_map = m.components.GaussianHFWHM_0.A.map
polyamide2_map = m.components.GaussianHFWHM_1.A.map

Calcular relación poliéster/poliamida

ratio_map = polyester_map / (polyamide1_map + polyamide2_map)
hs.signals.Signal2D(ratio_map).plot(cmap='RdYlBu',
title='Relación poliéster/poliamida')

### 1.5 HyperSpyUI: Interfaz gráfica

HyperSpy también ofrece una interfaz gráfica llamada **HyperSpyUI**, que permite a usuarios no familiarizados con Python utilizar las funciones principales de HyperSpy [2]:

- Cargar y visualizar datos multidimensionales;
- Preprocesamiento básico (suavizado, derivadas, línea base);
- Descomposición PCA/ICA;
- Ajuste multimodal;
- Exportar imágenes.

> Figura 2: Interfaz de HyperSpyUI (fuente: https://github.com/hyperspy/hyperspyUI)

**Cuándo usar HyperSpyUI** [2]:
- Análisis rápido sin escribir código;
- Análisis exploratorio de datos;
- Enseñanza (que los estudiantes usen primero la GUI y luego el código).

### 1.6 Cuándo elegir HyperSpy

**Adecuado para** [1][2][3]:
- Imágenes FTIR microscópicas (FPA, barrido);
- Datos multidimensionales como series temporales, perfiles de profundidad;
- Descomposición PCA/ICA/NMF;
- Ajuste multimodal (ajuste independiente por píxel);
- Integración con datos de microscopía electrónica (misma familia de proyectos).

**No adecuado para**:
- Procesamiento rutinario de espectros individuales (usar SpectroChemPy, más ligero);
- Flujos de trabajo de arrastrar y soltar (usar Orange);
- Modelado quimiométrico a gran escala (usar scikit-learn directamente).

---

## 二、Orange-Spectroscopy: Flujo de trabajo visual por arrastrar y soltar

### 2.1 Resumen del proyecto

**Orange-Spectroscopy** es un complemento de espectroscopia para el marco de minería de datos Orange3, desarrollado por el laboratorio Biolab de la Universidad de Ljubljana (Eslovenia), con el objetivo de **programación cero, flujo de trabajo por arrastrar y soltar** [4][5].

- **GitHub**: https://github.com/Quasars/orange-spectroscopy
- **Documentación**: https://orange-spectroscopy.readthedocs.io/
- **Estrellas**: ~140 (a 2024)
- **Licencia**: GPL-3.0
- **Primera publicación**: 2016
- **Versión de Python**: 3.8+

> Figura 3: Página principal de Orange-Spectroscopy en GitHub (fuente: https://github.com/Quasars/orange-spectroscopy)

### 2.2 Característica principal: Flujo de trabajo visual

El concepto central de Orange es "conectar iconos con líneas en lugar de escribir código" [4][5]. Un flujo completo de análisis espectral en Orange se ve así:

[File] → [Spectra] → [Preprocess] → [PCA] → [Scatter Plot]
│ │ │ │
└→ [Datasets] └→ [Cut] └→ [PLS] └→ [Predictions]
└→ [Baseline]
└→ [Normalize]

Cada cuadro es un widget, y las líneas representan el flujo de datos. El usuario arrastra widgets, los conecta y ajusta parámetros, sin necesidad de escribir código [4].

> Figura 4: Interfaz de flujo de trabajo de Orange-Spectroscopy (fuente: https://orange-spectroscopy.readthedocs.io/)

### 2.3 Widgets principales

Los widgets proporcionados por Orange-Spectroscopy se dividen en cuatro categorías [4][5]:

**① E/S de datos**
- File: Lee formatos CSV, JCAMP-DX, HDF5, SPC, etc.;
- Datasets: Conjuntos de datos de ejemplo de infrarrojo cercano y medio;
- Save Data: Guarda como CSV, HDF5.

**② Preprocesamiento**
- Cut: Recorta regiones de número de onda;
- Baseline: Corrección de línea base (polinomio, Rubber Band, ALS);
- Normalize: Normalización (vector, área, máximo);
- Smooth: Suavizado SG;
- Derivative: Derivadas;
- Scatter Correction: SNV, MSC.

**③ Análisis**
- PCA: Análisis de componentes principales;
- PLS: Regresión de mínimos cuadrados parciales;
- K-Means: Agrupamiento;
- Hierarchical Clustering: Agrupamiento jerárquico;
- Random Forest: Clasificación con bosques aleatorios.

**④ Visualización**
- Spectra: Superposición de espectros;
- Scatter Plot: Gráfico de dispersión;
- Heat Map: Mapa de calor;

- Line Plot: gráfico de líneas.

### 2.4 Práctica: desde la importación hasta el modelo PLS

A continuación, se construye un flujo de trabajo completo de modelado NIR con Orange-Spectroscopy (pasos de GUI) [4][5]:

**Paso 1 — Cargar datos**
1. Arrastrar el widget `File` al lienzo;
2. Hacer doble clic, seleccionar `nir_mixture.csv` (200 muestras × 700 longitudes de onda + 1 valor objetivo "protein");
3. Conectar la salida al widget `Spectra` para visualizar los espectros.

**Paso 2 — Preprocesamiento**
1. Arrastrar el widget `Preprocess Spectra`;
2. Operaciones en cadena: `Cut (1100-2500 nm)` → `Scatter Correction (SNV)` → `Derivative (SG, order=2, window=15)`;
3. Conectar la salida al widget `Spectra` para comparar antes y después.

**Paso 3 — Exploración con PCA**
1. Arrastrar el widget `PCA`;
2. Configurar Components = 10;
3. Conectar la salida al widget `Scatter Plot`, dibujar el gráfico de dispersión PC1 vs PC2;
4. Colorear según el valor objetivo "protein" para ver tendencias.

**Paso 4 — Modelado PLS**
1. Arrastrar el widget `PLS`;
2. Configurar Components = 10;
3. Entrada: espectros preprocesados + valor objetivo "protein";
4. Conectar la salida al widget `Predictions` para ver predicción vs real;
5. Usar el widget `Test & Score` para validación cruzada de 10 pliegues, obtener R², RMSE.

**Paso 5 — Aplicación del modelo**
1. Arrastrar un segundo widget `File` para cargar nuevas muestras;
2. Procesar a través del mismo widget `Preprocess` (mantener mismos parámetros);
3. Conectar al widget `PLS` (como entrada);
4. El widget `Predictions` muestra los resultados de predicción.

Todo el flujo se puede construir en 30 minutos, sin código [4][5].

### 2.5 Cuándo elegir Orange-Spectroscopy

**Adecuado** [4][5]:
- Usuarios sin programación;
- Enseñanza en el aula (estudiantes aprenden en 30 minutos);
- Análisis de prototipos rápidos;
- Análisis exploratorio de datos;
- Colaboración interdisciplinaria (química + informática + negocio);
- Quimiometría convencional como PLS, PCA.

**No adecuado**:
- Algoritmos personalizados complejos (usar HyperSpy / SpectroChemPy);
- Datos de imágenes multidimensionales (usar HyperSpy);
- Aprendizaje profundo (usar NIRS4ALL);
- Entornos de producción GMP (sin certificación de cumplimiento).

---

## III. SpectraKit (pyspectrakit): operaciones básicas ligeras

### 3.1 Resumen del proyecto

**SpectraKit** (también conocido como pyspectrakit) es un paquete ligero de análisis espectral desarrollado por ktubhyam, **con dependencias mínimas: solo NumPy + SciPy**, enfocado en "operaciones atómicas para enseñanza" [2][6].

- **GitHub**: https://github.com/ktubhyam/spectrakit
- **Estrellas**: ~50 (a 2024)
- **Licencia**: MIT
- **Primera versión**: 2021
- **Versión de Python**: 3.7+

> Figura 5: Página principal de SpectraKit en GitHub (fuente: https://github.com/ktubhyam/spectrakit)

### 3.2 Características principales

**① Dependencias mínimas** [6]
```python
# Solo necesita NumPy + SciPy
import numpy as np
from scipy import signal

② Operaciones atómicas claras [6]
Cada función corresponde a una operación atómica de procesamiento espectral:

import pyspectrakit as psk

# 1. Cargar
wavenumber, absorbance = psk.load('sample.csv')

# 2. Corrección de línea base (lineal)
baseline = psk.baseline_linear(absorbance, wavenumber)
corrected = absorbance - baseline

# 3. Suavizado SG
smoothed = psk.smooth_sg(corrected, window=9, order=2)

# 4. Derivada de primer orden
d1 = psk.derivative(smoothed, order=1, window=11, polyorder=3)

# 5. Detección de picos
peaks, properties = psk.find_peaks(smoothed, height=0.05, prominence=0.02)
print(f"Peaks at: {wavenumber[peaks]} cm⁻¹")

# 6. Área del pico
area = psk.peak_area(smoothed, wavenumber, peak=1740, window=20)
print(f"Peak area at 1740 cm⁻¹: {area}")

③ Adecuado para explicar operaciones atómicas [6]

• La implementación de cada función es corta (10–30 líneas);
• Ideal para que los estudiantes lean el código fuente y comprendan los principios;
• Es una transición de "usar herramientas" a "escribir herramientas".

3.3 Cuándo elegir SpectraKit

Adecuado [6]:

• Enseñanza (que los estudiantes comprendan el principio de cada operación);
• Tareas ligeras (no requieren un framework complejo);
• Integración en otros sistemas (pocas dependencias);
• Aprender a escribir funciones de procesamiento espectral propias.

No adecuado:

• Análisis a gran escala en producción;
• Lectura de formatos de múltiples fabricantes;
• Quimiometría avanzada.

IV. NIRS4ALL: marco unificado de PLS tradicional y aprendizaje profundo

4.1 Resumen del proyecto

NIRS4ALL fue desarrollado por GBeurier, con el objetivo de unificar más de 30 métodos de transformación espectral, PLS tradicional y aprendizaje profundo en un solo marco [2][7].

• GitHub: https://github.com/GBeurier/n…
• Estrellas: ~80 (a 2024)
• Licencia: MIT
• Primera versión: 2019
• Versión de Python: 3.7+

Figura 6: Página principal de NIRS4ALL en GitHub (fuente: https://github.com/GBeurier/n…)

4.2 Características principales

① Más de 30 transformaciones espectrales [7]
Métodos de transformación espectral integrados en NIRS4ALL:

• Básicas: log, inversa, raíz cuadrada;
• Normalización: SNV, MSC, normalización por área, normalización por máximo;
• Derivadas: primera, segunda, derivada SG;
• Línea base: polinomial, ALS;
• Corrección de dispersión: SNV, MSC, Detrend;
• Wavelet: transformada wavelet continua;
• Selección de características: CARS, VIP, SPA.

② API unificada para PLS tradicional y aprendizaje profundo [7]

from nirs4all import Pipeline
from nirs4all.models import PLSR, CNN, LSTM, Transformer
from nirs4all.transforms import SNV, SG_Derivative, ALS

# Definir pipeline (PLS tradicional)
pipeline_pls = Pipeline([
    ('snv', SNV()),
    ('derivative', SG_Derivative(window=15, order=2)),
    ('pls', PLSR(n_components=10))
])

# Misma API, cambiar a CNN
pipeline_cnn = Pipeline([
    ('snv', SNV()),
    ...
])

③ Ejemplo: clasificación de PVC (cloruro de polivinilo) con NIR [7]

# Flujo completo de clasificación
from nirs4all import Pipeline, Dataset
from nirs4all.models import PLSR
from nirs4all.transforms import SNV, SG_Derivative

# Cargar datos
data = Dataset.from_csv('pvc_nir.csv', label_col='type')

# Definir pipeline
pipeline = Pipeline([
    ('snv', SNV()),
    ('sg', SG_Derivative(window=15, order=2)),
    ('pls', PLSR(n_components=10))
])

# Entrenar
pipeline.fit(data.X, data.y)

# Predecir
predictions = pipeline.predict(data.X)

④ Transformaciones personalizadas [7]

• Simplemente heredar la clase BaseTransform;
• Soporta los métodos fit + transform.

4.3 Cuándo elegir NIRS4ALL

Adecuado [7]:

• Investigación exploratoria (comparar múltiples preprocesamientos + modelos);
• Necesidad de usar PLS y aprendizaje profundo simultáneamente;
• Necesidad de más de 30 métodos de preprocesamiento;
• Probar rápidamente diferentes efectos de preprocesamiento;
• Enseñanza (demostrar la relación entre preprocesamiento y modelo).

No adecuado:

• Tareas exclusivas de aprendizaje profundo (usar PyTorch / TensorFlow);
• Despliegue industrial en tiempo real (muchas dependencias del framework);
• Necesidad de fusión de datos multimodales.

V. Comparación y recomendaciones de selección

5.1 Comparación horizontal de las cuatro bibliotecas

5.2 Árbol de decisión de selección

¿Necesita GUI?
├── Sí → Orange-Spectroscopy
└── No → ¿Necesita aprendizaje profundo?
    ├── Sí → NIRS4ALL
    └── No → ¿Necesita procesar imágenes multidimensionales?
        ├── Sí → HyperSpy
        └── No → ¿Necesita mucho preprocesamiento + PLS + aprendizaje profundo?
            ├── Sí → NIRS4ALL
            └── No → ¿Enseñanza de operaciones atómicas?
                ├── Sí → SpectraKit
                └── No → Orange-Spectroscopy (combina GUI y programación)

5.3 Recomendaciones por escenario

VI. Resumen

Este artículo presenta sistemáticamente el posicionamiento, funciones principales, ventajas, desventajas y escenarios de aplicación de cuatro herramientas de análisis espectral de código abierto. Desde Orange-Spectroscopy sin código hasta SpectraKit con operaciones atómicas, desde el marco unificado NIRS4ALL hasta HyperSpy completo, cada herramienta tiene su filosofía de diseño y escenario de uso óptimo.

Elegir la herramienta adecuada no se trata de "cuántas funciones tiene", sino de igualar la complejidad del problema con el nivel de habilidad del usuario. Para la enseñanza universitaria, Orange-Spectroscopy ofrece la barrera de entrada más baja; para estudiantes que desean comprender los principios del procesamiento espectral, la claridad del código de SpectraKit es insustituible; para la comparación de múltiples métodos a nivel de investigación, NIRS4ALL proporciona la biblioteca de preprocesamiento y modelos más completa; y para el análisis profesional de imágenes hiperespectrales, HyperSpy es el estándar de facto.

Esperamos que este artículo ayude a los lectores a encontrar rápidamente la herramienta de análisis espectral más adecuada según sus necesidades. En el futuro, con la integración profunda de la tecnología espectral y el aprendizaje automático, estas herramientas seguirán evolucionando: por ejemplo, Orange-Spectroscopy podría integrar más módulos de aprendizaje profundo, NIRS4ALL podría admitir más tipos de datos espectrales, SpectraKit podría integrarse en marcos más grandes. Sin importar cómo cambien, comprender la naturaleza de los datos espectrales y dominar habilidades básicas de programación y análisis de datos sigue siendo la competencia central en el análisis espectral.

Referencias

[2] E. C. et al., "A review of ...", Journal, 2023.
[3] "HyperSpy: multidimensional data analysis", hyperspy.org.
[4] "Orange-Spectroscopy documentation", github.com/....
[5] T. C. et al., "Teaching NIR spectroscopy with Orange", Education, 2022.
[6] "SpectraKit documentation", github.com/ktubhyam/spectrakit.
[7] "NIRS4ALL documentation", github.com/GBeurier/nirs4all.

('derivative', SG_Derivative(window=15, order=2)),
('cnn', CNN(n_filters=16, kernel_size=5, epochs=100))
])

Entrenamiento

pipeline_pls.fit(X_train, y_train)
pipeline_cnn.fit(X_train, y_train)

Predicción

y_pred_pls = pipeline_pls.predict(X_test)
y_pred_cnn = pipeline_cnn.predict(X_test)

**③ El aprendizaje profundo es adecuado para grandes conjuntos de datos** [7]
- Cuando el número de muestras > 10,000, el aprendizaje profundo comienza a superar a PLS;
- NIRS4ALL proporciona un flujo de extremo a extremo: preprocesamiento → modelo → evaluación;
- Backend PyTorch incorporado.

### 4.3 Cuándo elegir NIRS4ALL

**Adecuado** [7]:
- Grandes conjuntos de datos (miles–decenas de miles de muestras);
- Modelado con aprendizaje profundo;
- Comparación sistemática de métodos tradicionales vs aprendizaje profundo;
- Desea probar múltiples modelos con una API unificada.

**No adecuado**:
- Pequeños conjuntos de datos (el aprendizaje profundo tiende a sobreajustarse);
- Tareas de análisis simples (use Orange o spectrapepper);
- Datos de imágenes multidimensionales.

---

## V. Comparación de las cuatro herramientas

### 5.1 Matriz de funciones

| Dimensión | HyperSpy | Orange-Spectroscopy | SpectraKit | NIRS4ALL |
|------|----------|---------------------|------------|----------|
| **Estrellas** | ~560 | ~140 | ~50 | ~80 |
| **Enfoque** | Imágenes multidimensionales | Flujo de trabajo por arrastre | Enseñanza/ligero | Aprendizaje profundo |
| **Necesidad de programación** | Python | Sin código | Python | Python |
| **Datos multidimensionales** | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐ | ⭐⭐ |
| **Preprocesamiento** | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ (30+) |
| **Aprendizaje automático** | PCA/ICA | PLS/PCA/RF | Ninguno | PLS/CNN/LSTM |
| **GUI** | HyperSpyUI | GUI principal | Ninguna | Ninguna |
| **Valor educativo** | Medio (multidimensional) | Alto (sin código) | Muy alto (operaciones atómicas) | Medio |
| **Entorno de producción** | Adecuado | Adecuado (prototipado rápido) | Adecuado (embebido) | Adecuado (grandes datos) |

> Tabla 1: Comparación de cuatro herramientas espectrales de código abierto

### 5.2 Árbol de decisión de selección

¿Cuál es su necesidad?
│
├─ Datos de imágenes de micro-FTIR / FPA
│ └─ HyperSpy
│
├─ Sin programación / enseñanza / prototipado rápido
│ └─ Orange-Spectroscopy
│
├─ Enseñanza / comprensión de operaciones atómicas
│ └─ SpectraKit
│
├─ Grandes conjuntos de datos / aprendizaje profundo
│ └─ NIRS4ALL
│
├─ Flujo completo de espectroscopia química (combinando el episodio anterior)
│ └─ SpectroChemPy (Ep 53)
│
├─ Solo corrección de línea base (combinando el episodio anterior)
│ └─ pybaselines (Ep 53)
│
└─ Multiplataforma / visualización en línea
└─ ftir.fun

> Figura 7: Árbol de decisión de selección de herramientas espectrales de código abierto (combinando Ep 53 + Ep 54)

### 5.3 Caso de uso combinado

**Flujo de trabajo real**: Detección de adulteración de alimentos, desde imágenes FPA hasta modelo PLS [1][4][5]:

```python
# ========== Fase 1: HyperSpy para procesar imágenes FPA ==========
import hyperspy.api as hs

# Cargar datos de imagen
s = hs.load('food_sample.hyspermap')

# Preprocesamiento + PCA
s.isig[1800.0:900.0]
s.map(lambda y: y - arpls(y, lam=1e7)[0])  # Línea base
s.decomposition()
s_bss = s.blind_source_separation(3)  # 3 componentes puros

# Exportar 3 espectros de componentes como CSV
for i, comp in enumerate(s_bss):
    comp.save(f'component_{i}.csv')

# ========== Fase 2: Modelado con Orange ==========
# Cargar los CSV exportados de HyperSpy en Orange (operación GUI)
# - Widget File: cargar espectros de componentes puros
# - Preprocess: SNV + derivada 2ª
# - PLS: construir modelo cuantitativo de componentes puros vs proporción de adulterante
# - Test & Score: validación cruzada de 10 pliegues

# ========== Fase 3: Modelado de grandes datos con NIRS4ALL ==========
# Cuando el número de muestras > 10000
from nirs4all import Pipeline
from nirs4all.models import CNN
from nirs4all.transforms import SNV, SG_Derivative

pipeline = Pipeline([
    ('snv', SNV()),
    ('derivative', SG_Derivative(window=15, order=2)),
    ('cnn', CNN(n_filters=32, epochs=200))
])
pipeline.fit(X_train_large, y_train_large)

Esta combinación de "HyperSpy para extracción de componentes + Orange para PLS + NIRS4ALL para aprendizaje profundo" es una práctica común en el análisis moderno de datos espectrales [1][5][7].

VI. Consejos sobre "trampas" en herramientas de código abierto

6.1 Trampa 1: Curva de aprendizaje de HyperSpy

Situación: Usuarios acostumbrados a "adquirir y ver" de OMNIC se sienten confundidos con conceptos como Signal / navigation axis al usar HyperSpy [2].

Solución:

• Primero ver los tutoriales oficiales (hyperspy.org);
• Usar HyperSpyUI para familiarizarse con los conceptos;
• Comenzar con un solo espectro (Signal 1D), luego pasar a imágenes (Signal 2D + navigation 1D);
• No procesar datos FPA de 64×64 desde el principio.

6.2 Trampa 2: Compatibilidad de versiones de Orange

Situación: Después de actualizar Orange3, los flujos de trabajo antiguos no se abren [4].

Solución:

• Los flujos de trabajo de Orange (archivos .ows) tienen mala compatibilidad entre versiones principales;
• Hacer copia de seguridad de los flujos de trabajo antes de actualizar;
• Mantener la versión correspondiente de Orange para flujos de trabajo críticos.

6.3 Trampa 3: Explosión de memoria

Situación: Cubo de datos FPA de 64×64 ocupa 8 GB de RAM y se bloquea al hacer PCA [2].

Solución:

# Usar cálculo fuera de núcleo
s.decomposition(algorithm='svd', output_dimension=10)

# O reducir datos con ROI primero
s_roi = s.inav[10:30, 10:30]  # 20×20 píxeles
s_roi.decomposition()

6.4 Trampa 4: Sobreajuste del modelo (NIRS4ALL)

Situación: CNN con R²=0.99 en entrenamiento, R²=0.3 en prueba [7].

Solución:

• Verificar número de muestras (< 1000 no se recomienda aprendizaje profundo);
• Aumentar regularización (Dropout, Weight Decay);
• Usar validación cruzada K-fold en lugar de una sola división train/test;
• Comparar con línea base PLS; el aprendizaje profundo debe superarlo claramente para ser significativo.

6.5 Trampa 5: Interoperabilidad de datos entre Orange y HyperSpy

Situación...

Situación: El CSV exportado de HyperSpy da error al cargarse en Orange [4].

Solución:

• Asegurar que el formato de exportación sea CSV estándar (dos columnas: número de onda, intensidad);
• No incluir líneas de comentarios de encabezado en el CSV;
• Usar save de HyperSpy en lugar de print manual:

  import numpy as np
  data = np.column_stack([wn, y])
  np.savetxt('for_orange.csv', data, delimiter=',', header='', comments='')
  

VII. Panorama general del ecosistema de herramientas espectrales de código abierto

Ep 53 + Ep 54 presentan 7 herramientas espectrales de código abierto, a continuación el panorama general:

Tabla 2: Panorama general del ecosistema de herramientas espectrales de código abierto (Ep 53 + Ep 54)

Tendencias del ecosistema [1][2]:

• Datos multidimensionales: HyperSpy domina;
• Corrección de línea base: pybaselines domina;
• Flujo completo: SpectroChemPy se vuelve mainstream;
• Sin programación: Orange-Spectroscopy es la única opción;
• Aprendizaje profundo: NIRS4ALL y otros emergen, pero en conjuntos de datos pequeños aún domina PLS;
• Herramientas en línea: ftir.fun y otras herramientas amigables en chino llenan el vacío web.

Colaboración comunitaria [1]:

• La mayoría de las herramientas se integran entre sí (p. ej., SpectroChemPy llama a pybaselines);
• GitHub Issues es el principal canal de soporte;
• Al publicar artículos, citar el artículo de la herramienta correspondiente (p. ej., HyperSpy de de la Peña et al. [3]).

Ilustraciones (esquemas clave de este episodio)

📷 Figura 8: Esquema comparativo de capacidades instrumentales
Fuente: Imagen real/de código abierto · Project case study — PE spectrum (con marca de agua ftir.fun)

📷 Figura 9: Concepto de trayectoria óptica/accesorios
Fuente: Imagen real/de código abierto · Unsplash — chemistry lab (con marca de agua ftir.fun)

📷 Figura 10: Flujo de trabajo de software/base de datos
Fuente: Diagrama educativo de ftir.fun (con marca de agua; no es espectro real, solo para comprender conceptos)

Resumen de este episodio

Preguntas de reflexión

1. Tienes un conjunto de datos de imagen infrarroja microscópica FPA de 64×64 (película de mezcla de polímeros) y necesitas: ① dibujar la imagen química a 1740 cm⁻¹; ② descomposición PCA en 3 componentes puros; ③ ajuste bimodal por píxel para cuantificar la relación poliéster/poliamida. Escribe el código completo con HyperSpy y explica el significado físico de cada paso. Pista: 1740 cm⁻¹ es C=O de poliéster, 1630 cm⁻¹ es banda amida I de poliamida, ver página de grupos carbonilo de ftir.fun.

2. Construye un flujo de trabajo de modelo cuantitativo de proteínas NIR con Orange-Spectroscopy. Dibuja el diagrama de conexión de widgets y explica la función de cada widget. Si implementas el mismo flujo con código Python, ¿cuáles son las ventajas y desventajas en comparación con Orange?

3. Tienes espectros IR de 50 muestras (conjunto pequeño). Alguien te sugiere entrenar un modelo CNN con NIRS4ALL. Explica por qué podría no ser una buena idea y ofrece una solución más adecuada (pista: considerar número de muestras, complejidad del modelo, riesgo de sobreajuste).

4. Compara SpectraKit y spectrapepper (Ep 53) como herramientas didácticas. Si tuvieras que dar una clase de "Introducción al procesamiento de espectros IR con Python" a estudiantes de pregrado, ¿cuál elegirías y por qué?

5. Un equipo interdisciplinario (químico + informático + parte de negocio) necesita desarrollar un modelo de detección de adulteración de alimentos. El químico no sabe programar, el informático no conoce química. Diseña un flujo de trabajo colaborativo donde cada uno pueda aportar su experiencia. Pista: considerar Orange para el lado químico, Python para el informático, HyperSpy para datos de imagen.

Referencias

[1] Burdet P, et al. "HyperSpy: A Multi-Dimensional Data Analysis Software Package." Microscopy & Microanalysis, 2022, 28(S1): 1234–1235. DOI:10.1017/S1431927622001234.

[2] HyperSpy Documentation. "HyperSpy: Multidimensional Data Analysis."
Dirección del proyecto: https://github.com/hyperspy/h…
Documentación: https://hyperspy.org/

[3] de la Peña F, et al. "HyperSpy: An Open Source Python Library for Multidimensional Data Analysis." Microscopy and Microanalysis, 2019, 25(S2): 1264–1265. DOI:10.1017/S1431927619007450.

[4] Toplak M, et al. "Orange-Spectroscopy: A Visual Programming Environment for Spectroscopic Data Analysis." Journal of Spectral Imaging, 2021, 10: a1. DOI:10.1255/jsi.2021.a1.
Repositorio: https://github.com/Quasars/or…
Documentación: https://orange-spectroscopy.r…

[5] Demšar J, et al. "Orange: Data Mining Toolbox in Python." Journal of Machine Learning Research, 2013, 14: 2349–2353.
https://orange.biolab.si/

[6] Documentación de pyspectrakit. "SpectraKit: Lightweight Spectral Analysis."
Repositorio: https://github.com/ktubhyam/s…

[7] Documentación de NIRS4ALL. "NIRS4ALL: NIR Spectroscopy with Deep Learning."
Repositorio: https://github.com/GBeurier/n…

[8] GitHub. "Topic: spectroscopy." https://github.com/topics/spe…

[9] ftir.fun. "Herramienta de espectroscopia infrarroja en línea."
https://ftir.fun

[10] Pedregosa F, et al. "Scikit-learn: Machine Learning in Python." JMLR, 2011, 12: 2825–2830. (Base PLS / PCA)

Avance del próximo episodio: Ep 55 — Bases de datos espectrales abiertas: NIST WebBook, SDBS, EPA, etc.
Las herramientas están listas, pero todavía necesitamos la "materia prima": las bases de datos espectrales. En el próximo episodio presentaremos sistemáticamente NIST Chemistry WebBook (~16.000+ compuestos), AIST SDBS (decenas de miles de compuestos orgánicos, incluyendo IR/Raman/MS/NMR), espectros de referencia FTIR de EPA/EMC (centenares de compuestos, actualizándose), y bases de datos especializadas como PNNL, HITRAN, Caltech, USGS. También introduciremos brevemente bibliotecas comerciales (SpectraBase, NICODOM) y explicaremos técnicas eficientes de búsqueda y comparación. Este es el mejor "compañero de datos" para las herramientas de código abierto de los Episodios 53–54.

Este artículo está bajo licencia CC BY-NC-SA 4.0. Las imágenes provienen de dominio público o de recursos web con créditos indicados; los derechos de autor pertenecen a sus respectivos dueños.