Streamlit: Ciencia de datos

La integración de herramientas de ciencia de datos con Streamlit permite transformar análisis complejos en aplicaciones web interactivas. Este módulo se centra en cómo implementar gráficos avanzados con matplotlib y seaborn, así como modelos de machine learning con scikit-learn, todo ello aprovechando las capacidades de Python 3.13.

La principal ventaja de Streamlit en este contexto es la posibilidad de crear dashboards interactivos sin necesidad de conocimientos profundos en desarrollo web. Esto permite a científicos de datos y analistas compartir sus hallazgos de forma visual y accesible.

Integración de Matplotlib en Streamlit

Matplotlib es una biblioteca de visualización fundamental en el ecosistema Python. Su integración con Streamlit es directa y potente, permitiendo generar gráficos estáticos que pueden actualizarse dinámicamente según la interacción del usuario.

Para mostrar un gráfico de matplotlib en Streamlit, podemos utilizar la función st.pyplot():

import streamlit as st
import matplotlib.pyplot as plt
import numpy as np

# Generamos datos de ejemplo
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Creamos la figura con matplotlib
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('Función Seno')
ax.set_xlabel('X')
ax.set_ylabel('sin(x)')

# Mostramos la figura en Streamlit
st.pyplot(fig)

En Python 3.13, podemos aprovechar las mejoras en rendimiento para generar gráficos más complejos y detallados sin comprometer la velocidad de la aplicación. Algunas visualizaciones avanzadas que podemos implementar incluyen:

• Gráficos de contorno: Ideales para representar datos multidimensionales.
• Mapas de calor: Perfectos para mostrar correlaciones entre variables.
• Subplots múltiples: Para comparar varios conjuntos de datos en una única visualización.

También podemos hacer que nuestros gráficos sean interactivos utilizando widgets de Streamlit:

import streamlit as st
import matplotlib.pyplot as plt
import numpy as np

# Widget para seleccionar la función
funcion = st.selectbox(
    'Selecciona una función',
    ['sin', 'cos', 'tan']
)

# Widget para ajustar la frecuencia
frecuencia = st.slider('Frecuencia', 0.1, 3.0, 1.0)

# Generamos datos
x = np.linspace(0, 10, 100)

# Aplicamos la función seleccionada
if funcion == 'sin':
    y = np.sin(frecuencia * x)
elif funcion == 'cos':
    y = np.cos(frecuencia * x)
else:
    y = np.tan(frecuencia * x)

# Creamos y mostramos la figura
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title(f'Función {funcion}({frecuencia}x)')
ax.grid(True)

st.pyplot(fig)

Un aspecto importante a considerar es la personalización del estilo de los gráficos para que se integren mejor con la interfaz de Streamlit. Podemos utilizar temas de matplotlib o definir estilos personalizados:

import streamlit as st
import matplotlib.pyplot as plt
import numpy as np

# Aplicamos un estilo
plt.style.use('ggplot')

# Generamos datos
categorias = ['A', 'B', 'C', 'D', 'E']
valores = [23, 17, 35, 29, 12]

# Creamos gráfico de barras
fig, ax = plt.subplots(figsize=(10, 6))
bars = ax.bar(categorias, valores, color='steelblue')
ax.set_title('Distribución por Categoría')

# Añadimos valores sobre las barras
for bar in bars:
    height = bar.get_height()
    ax.text(
        bar.get_x() + bar.get_width()/2., 
        height + 0.3, 
        f'{height}', 
        ha='center'
    )

# Mostramos en Streamlit
st.pyplot(fig)

Visualizaciones Avanzadas con Seaborn

Seaborn complementa a matplotlib proporcionando una interfaz de alto nivel para crear visualizaciones estadísticas atractivas. Su integración con Streamlit es similar a la de matplotlib, pero con la ventaja de requerir menos código para visualizaciones estadísticas complejas.

Podemos implementar un gráfico de seaborn de la siguiente manera:

import streamlit as st
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Creamos un DataFrame de ejemplo
np.random.seed(42)
df = pd.DataFrame({
    'x': np.random.normal(0, 1, 100),
    'y': np.random.normal(0, 1, 100),
    'categoria': np.random.choice(['A', 'B', 'C'], 100)
})

# Creamos un scatter plot con seaborn
fig, ax = plt.subplots(figsize=(10, 6))
sns.scatterplot(
    data=df,
    x='x',
    y='y',
    hue='categoria',
    palette='viridis',
    ax=ax
)
ax.set_title('Distribución por Categoría')

# Mostramos en Streamlit
st.pyplot(fig)

Seaborn destaca en la creación de gráficos estadísticos como:

• Diagramas de violín: Para visualizar la distribución de datos a través de diferentes categorías.
• Gráficos de pares: Para explorar relaciones entre múltiples variables.
• Gráficos de regresión: Para visualizar relaciones junto con líneas de tendencia.

Un ejemplo de visualización estadística interactiva combinando seaborn con widgets de Streamlit:

import streamlit as st
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# Cargamos un dataset de ejemplo
dataset = st.selectbox(
    'Selecciona un dataset',
    ['iris', 'tips', 'diamonds']
)

if dataset == 'iris':
    data = sns.load_dataset('iris')
elif dataset == 'tips':
    data = sns.load_dataset('tips')
else:
    data = sns.load_dataset('diamonds').sample(1000)  # Muestra para rendimiento

# Mostramos un resumen del dataset
st.write(f"Dataset: {dataset}")
st.dataframe(data.head())

# Seleccionamos el tipo de gráfico
plot_type = st.radio(
    'Tipo de visualización',
    ['Histograma', 'Boxplot', 'Pairplot', 'Heatmap']
)

# Configuramos y mostramos el gráfico seleccionado
if plot_type == 'Histograma':
    col = st.selectbox('Variable a visualizar', data.select_dtypes('number').columns)
    fig, ax = plt.subplots()
    sns.histplot(data[col], kde=True, ax=ax)
    st.pyplot(fig)
    
elif plot_type == 'Boxplot':
    num_col = st.selectbox('Variable numérica', data.select_dtypes('number').columns)
    cat_col = st.selectbox('Variable categórica (opcional)', 
                          ['None'] + list(data.select_dtypes('object').columns))
    
    fig, ax = plt.subplots()
    if cat_col != 'None':
        sns.boxplot(x=cat_col, y=num_col, data=data, ax=ax)
    else:
        sns.boxplot(y=num_col, data=data, ax=ax)
    st.pyplot(fig)
    
elif plot_type == 'Pairplot':
    # Limitamos variables para rendimiento
    cols = st.multiselect('Variables a incluir', 
                         data.select_dtypes('number').columns,
                         default=list(data.select_dtypes('number').columns)[:3])
    
    hue = st.selectbox('Variable para color (opcional)', 
                      ['None'] + list(data.select_dtypes('object').columns))
    
    if cols:
        with st.spinner('Generando pairplot...'):
            fig = sns.pairplot(
                data,
                vars=cols,
                hue=None if hue == 'None' else hue
            )
            st.pyplot(fig)
    
elif plot_type == 'Heatmap':
    corr = data.select_dtypes('number').corr()
    fig, ax = plt.subplots(figsize=(10, 8))
    sns.heatmap(corr, annot=True, cmap='coolwarm', ax=ax)
    st.pyplot(fig)

Implementación de Modelos de Machine Learning con Scikit-learn

La integración de modelos de machine learning en aplicaciones Streamlit permite crear herramientas interactivas de análisis predictivo. Scikit-learn es la biblioteca más utilizada para este propósito, ofreciendo una amplia gama de algoritmos con una interfaz consistente.

Veamos cómo podemos implementar un modelo simple de regresión lineal:

import streamlit as st
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Generamos datos sintéticos
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

# Widget para seleccionar el tamaño del conjunto de prueba
test_size = st.slider('Tamaño del conjunto de prueba (%)', 10, 50, 20) / 100

# Dividimos los datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)

# Entrenamos el modelo
model = LinearRegression()
model.fit(X_train, y_train)

# Realizamos predicciones
y_pred = model.predict(X_test)

# Calculamos métricas
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# Mostramos resultados
st.write(f"Coeficiente: {model.coef_[0][0]:.4f}")
st.write(f"Intercepto: {model.intercept_[0]:.4f}")
st.write(f"Error cuadrático medio: {mse:.4f}")
st.write(f"Coeficiente R²: {r2:.4f}")

# Visualizamos resultados
fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(X_train, y_train, color='blue', label='Datos de entrenamiento')
ax.scatter(X_test, y_test, color='green', label='Datos de prueba')
ax.plot(X_test, y_pred, color='red', linewidth=2, label='Predicción')
ax.set_xlabel('X')
ax.set_ylabel('y')
ax.set_title('Regresión Lineal')
ax.legend()
ax.grid(True)

st.pyplot(fig)

Podemos extender este ejemplo para crear una aplicación interactiva que permita al usuario seleccionar diferentes algoritmos y ajustar sus hiperparámetros:

import streamlit as st
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
import seaborn as sns

# Cargamos dataset (iris como ejemplo)
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names

# Creamos DataFrame
df = pd.DataFrame(X, columns=feature_names)
df['target'] = y
df['species'] = df['target'].map({0: target_names[0], 1: targe