¿Qué hacer cuando tengo muchas variables?

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Introducción al análisis exploratorio de datos

Análisis univariado

Análisis bivariado

Análisis multivariado

Conclusiones

Tomar examen

¿Qué hacer cuando tengo muchas variables?

Comentarios

Carlos Mazzaroli

student

Bueno gente, se estudió mucho para llegar acá, se busco mucha información en youtube, otras fuentes, se experimentó con las prácticas, ahora aprovecho para meter memes de terra planismo

Pasen memes para la banda, nos lo merecemos por llegar hasta acá

Jeinfferson Bernal G

student

Que hacer cuando tengo muchas variables?

Cuando se tiene muchas variables, un analisis de pares de variables puede ser confuso por lo que tenemos que recurrir a tecnicas que nos ayudan a entender la variacion de todos los datos de manera simple: Reduciendo las dimensiones para obtener un unico espacio (Pasar de 10 variables a solo 2). Algunas de estas tecnicas son:

Analisis de Componentes Principales (PCA): un ejemplo de utilidad es la demostracion de que los genes reflejan la geografia de Europa
TSNE (T - Distributed Stochastic Neighbor Embedding): Separacion de todos los tipos de cancer
UMAP (Uniform Manifold Approximation and Projection for Dimension Reduction): intenta capturar la estructura global preservando la estructura local de los datos utlizando proyecciones en un plano
Comparacion: algoritmo de reduccion de dimension vs conjunto de datos

Ruddy Ramos

student

Muchas gracias por el aporte.

Alfonso Andres Zapata Guzman

student

processed_penguins_df = processed_penguins_df.assign(
    is_island_numeric=lambda df: df.island.replace(
        ["Torgersen", "Biscoe", "Dream"], (0, 1, 2)
    )
)

processed_penguins_df = processed_penguins_df.assign(
    is_species_numeric=lambda df: df.species.replace(
        ["Adelie", "Gentoo", "Chinstrap"], (0, 1, 2)
    )
)

import plotly.express as px
from sklearn.decomposition import PCA

X = processed_penguins_df[['bill_length_mm', 'bill_depth_mm',
       'flipper_length_mm', 'body_mass_g', 'year', 'numeric_sex',
       'is_island_numeric', 'is_species_numeric']]

pca = PCA(n_components=3)
components = pca.fit_transform(X)

total_var = pca.explained_variance_ratio_.sum() * 100

fig = px.scatter_3d(
    components, x=0, y=1, z=2, color=processed_penguins_df['species'],
    title=f'Total Explained Variance: {total_var:.2f}%',
    labels={'0': 'PC 1', '1': 'PC 2', '2': 'PC 3'}
)
fig.show()

Alfonso Andres Zapata Guzman

student

from sklearn.manifold import TSNE
import plotly.express as px

features = processed_penguins_df[['bill_length_mm', 'bill_depth_mm',
       'flipper_length_mm', 'body_mass_g', 'year', 'numeric_sex',
       'is_island_numeric', 'is_species_numeric']]

tsne = TSNE(n_components=3, random_state=0)
projections = tsne.fit_transform(features, )

fig = px.scatter_3d(
    projections, x=0, y=1, z=2,
    color=processed_penguins_df.species, labels={'color': 'species'}
)
fig.update_traces(marker_size=8)
fig.show()

Alfonso Andres Zapata Guzman

student

from umap import UMAP

umap_2d = UMAP(n_components=2, init='random', random_state=0)
umap_3d = UMAP(n_components=3, init='random', random_state=0)

proj_2d = umap_2d.fit_transform(features)
proj_3d = umap_3d.fit_transform(features)

fig_2d = px.scatter(
    proj_2d, x=0, y=1,
    color=processed_penguins_df.species, labels={'color': 'species'}
)
fig_3d = px.scatter_3d(
    proj_3d, x=0, y=1, z=2,
    color=processed_penguins_df.species, labels={'color': 'species'}
)
fig_3d.update_traces(marker_size=5)

fig_2d.show()
fig_3d.show()```

Antonio Demarco Bonino

student

Lo que dijo Jesús relacionado al cáncer me hizo buscar información al respecto y encontré esta charla. Espero que pueda ayudar a más de uno de ustedes: https://www.youtube.com/watch?v=jYwxbXAiIaE&ab_channel=TEDxTalks

Andres Sanchez

student

26. ¿Qué hacer cuando tengo muchas variables?

Análisis de Componentes Principales (PCA)

TSNE (T-distributed Stochastic Neighbor Embedding)

UMAP: Uniform Manifold Approximation and Projectino for Dimension Reduction

Representar muchas dimensiones en menos, por ejemplo 5 a 2.

Se pueden comparar los algoritmos con los datasets que son utilizados principalmente para ML.

Comparación: algoritmo de reducción de dimensión vs. conjunto de datos.

Existen varios algoritmos que ayudan a reducir las dimensiones del dataset.

Además de t-SNE y PCA, existen varios algoritmos populares para la reducción de dimensionalidad en el campo de la ciencia de datos. Algunos de ellos son:

MDS (Multidimensional Scaling): Similar a t-SNE, MDS también se utiliza para visualizar datos en un espacio de menor dimensión. MDS busca preservar las distancias entre los puntos de datos en el espacio de alta dimensión al mapearlos en el espacio de baja dimensión.
LLE (Locally Linear Embedding): LLE es un algoritmo de reducción de dimensionalidad no lineal que se basa en la presunción de que los puntos cercanos en el espacio de alta dimensión tienen estructuras lineales similares. LLE encuentra pesos lineales para reconstruir localmente cada punto a partir de sus vecinos cercanos en el espacio de alta dimensión y luego mapea los puntos en un espacio de menor dimensión.
UMAP (Uniform Manifold Approximation and Projection): UMAP es un algoritmo de reducción de dimensionalidad reciente que combina técnicas de preservación de vecindarios y topología. UMAP se centra en preservar la estructura local y global de los datos y ha demostrado ser efectivo para la visualización y el análisis de datos de alta dimensión.
Autoencoders: Los autoencoders son una clase de redes neuronales que pueden utilizarse para la reducción de dimensionalidad no lineal. Los autoencoders consisten en una etapa de codificación y una etapa de decodificación, donde los datos de alta dimensión se comprimen en un espacio de menor dimensión y luego se reconstruyen a partir de ese espacio comprimido.
NMF (Non-Negative Matrix Factorization): NMF es una técnica de factorización de matrices que se utiliza para encontrar representaciones de baja dimensión de datos no negativos. NMF descompone una matriz de datos en dos matrices de menor rango, donde los elementos son no negativos, lo que puede ser útil para descubrir patrones y componentes subyacentes en los datos.

Estos son solo algunos ejemplos de algoritmos de reducción de dimensionalidad utilizados en ciencia de datos. Cada algoritmo tiene sus propias suposiciones y enfoques, y la elección del algoritmo depende del tipo de datos, el objetivo de reducción de dimensionalidad y las características específicas del problema.

John Alfredo Miranda Alva

student

UMAP

Diego Jurado

student

UMAP?

Mauricio Escobar

student

¡UMAP!

Jhon Freddy Tavera Blandon

student

Cuando se tienen muchas variables en un conjunto de datos, puede resultar difícil visualizar y analizar la relación entre ellas. Algunas herramientas que pueden ser útiles para abordar este problema son:

Análisis de componentes principales (PCA): es una técnica de reducción de la dimensionalidad que permite identificar patrones y estructuras en los datos a través de la transformación de las variables originales en un conjunto de nuevas variables no correlacionadas llamadas componentes principales.

from sklearn.decomposition import PCA
import seaborn as sns

# Cargamos el conjunto de datos de pingüinos
penguins = sns.load_dataset("penguins")

# Eliminamos las filas con valores faltantes
penguins = penguins.dropna()

# Creamos un objeto PCA y ajustamos los datos
pca = PCA(n_components=2)
pca.fit(penguins.drop(columns=['species']))

# Transformamos los datos a los componentes principales
transformed_data = pca.transform(penguins.drop(columns=['species']))

# Creamos un gráfico con los datos transformados
sns.scatterplot(x=transformed_data[:,0], y=transformed_data[:,1], hue=penguins['species'])

Este código utiliza la biblioteca Scikit-learn para realizar un análisis de componentes principales (PCA) en el conjunto de datos de pingüinos. El resultado es un gráfico de dispersión de los datos transformados en dos componentes principales. Podemos observar que las tres especies de pingüinos están separadas en el espacio de los componentes principales, lo que indica que hay patrones y estructuras distintas en los datos que permiten diferenciar las especies.

Luis Ernesto Domínguez Velásquez

student

https://medium.com/@nicolasarrioja/13-t%C3%A9cnicas-de-reducci%C3%B3n-de-dimensionalidad-b33b2340a060

Pablo Alejandro Figueroa

student

Genial..!!! Gracias...!

Juan R. Vergara M.

student

Esta clase como todo el curso me serán de mucha utilidad, estaba esperando una actualización de este curso 🚀🔥

Juan Pablo Marin Vanegas

student

Mi aporte para reducirla cantidad de variables es a través de un Análisis Factorial Exploratorio (AFE) y un Análisis Factorial Confirmatorio (AFC)

EDWING ALFONSO ARENAS RUEDA

student

# Analisis de datos mediante PCA from sklearn.decomposition import PCAfrom sklearn.preprocessing import StandardScaler # Copiar el dataset para evitar modificaciones directasdf_analisis_pca = df_procesado_3.copy() # Filtrar solo las columnas numéricas para PCAdf_numerico = df_analisis_pca.select_dtypes(include=[np.number]).drop(columns=['species'], errors='ignore') # Verificar si hay valores nulos y eliminarlos o imputarlosdf_numerico = df_numerico.dropna() # Escalar los datos (PCA es sensible a la escala)# ajusta todas las variables a la misma escala, permitiendo que cada una contribuya de manera justa.scaler = StandardScaler()df_scaled = scaler.fit_transform(df_numerico) # Aplicar PCA con 2 componentes principalespca = PCA(n_components=2)transformed_data = pca.fit_transform(df_scaled) # Convertir en DataFramedf_pca = pd.DataFrame(transformed_data, columns=['PC1', 'PC2'])df_pca['species'] = df_analisis_pca['species'].iloc[df_numerico.index] # Restaurar etiquetas de especie

# Graficarplt.figure(figsize=(8, 6))sns.scatterplot(x=df_pca['PC1'], y=df_pca['PC2'], hue=df_pca['species'], palette="magma", alpha=0.7)plt.title('PCA: Componentes Principales')plt.xlabel('Componente Principal 1')plt.ylabel('Componente Principal 2')plt.legend(title='Especie')plt.show() # Mostrar la varianza explicada por cada componenteprint("Varianza explicada por cada componente:", pca.explained_variance_ratio_)

Alexander Sencion Cespedes

student

Ejemplo Práctico

Supongamos que estamos desarrollando un sistema de recomendación de películas. Podríamos utilizar SVD para descomponer la matriz de calificaciones de películas en matrices de menor dimensión que representen las características latentes de usuarios y películas. Luego, estas representaciones latentes pueden ser utilizadas para predecir las calificaciones y recomendar películas que el usuario aún no ha visto.

Diego Cesar Lerma Torres

student

Otra técnica para reducción de dimensionalidad son los autoencoders, que me emocionan mucho porque son IA. Les dejo un apunte sobre ellos:

Concepto: Un autoencoder es una red neuronal diseñada para aprender una representación comprimida (encoding) de los datos, para luego reconstruirlos (decoding). La capa intermedia representa los datos en una dimensión reducida.

Aplicación: Ampliamente usado en aprendizaje profundo para reducción de dimensionalidad, compresión de datos, y generación de datos.

Robert Yesid Barrios Acendra

student

No conozco otra técnica fuera del PCA, me toca usarla para mi tesis de maestría, 1100 columnas de espectroscopía infrarroja (NIR). Lo único es que después de hacer el PCA y tomar esas X para predecir cualquiera de las Y de mi data, no está prediciendo bien, y se supone que debería por el artículo en el que me baso.

Elkin Rodriguez

student

¡Nunca pares de aprender! Vamos por todo

Ruben Gavilanes

student

Modelos de reduccion de dimesiones

Carlos Andrés Pinilla Castillo

student

Revisar cada uno de los metodos de reduccion de dimensiones

processed_penguins_df = processed_penguins_df.assign(
    is_island_numeric=lambda df: df.island.replace(
        ["Torgersen", "Biscoe", "Dream"], (0, 1, 2)
    )
)

processed_penguins_df = processed_penguins_df.assign(
    is_species_numeric=lambda df: df.species.replace(
        ["Adelie", "Gentoo", "Chinstrap"], (0, 1, 2)
    )
)

import plotly.express as px
from sklearn.decomposition import PCA

X = processed_penguins_df[['bill_length_mm', 'bill_depth_mm',
       'flipper_length_mm', 'body_mass_g', 'year', 'numeric_sex',
       'is_island_numeric', 'is_species_numeric']]

pca = PCA(n_components=3)
components = pca.fit_transform(X)

total_var = pca.explained_variance_ratio_.sum() * 100

fig = px.scatter_3d(
    components, x=0, y=1, z=2, color=processed_penguins_df['species'],
    title=f'Total Explained Variance: {total_var:.2f}%',
    labels={'0': 'PC 1', '1': 'PC 2', '2': 'PC 3'}
)
fig.show()

from sklearn.manifold import TSNE
import plotly.express as px

features = processed_penguins_df[['bill_length_mm', 'bill_depth_mm',
       'flipper_length_mm', 'body_mass_g', 'year', 'numeric_sex',
       'is_island_numeric', 'is_species_numeric']]

tsne = TSNE(n_components=3, random_state=0)
projections = tsne.fit_transform(features, )

fig = px.scatter_3d(
    projections, x=0, y=1, z=2,
    color=processed_penguins_df.species, labels={'color': 'species'}
)
fig.update_traces(marker_size=8)
fig.show()

from umap import UMAP

umap_2d = UMAP(n_components=2, init='random', random_state=0)
umap_3d = UMAP(n_components=3, init='random', random_state=0)

proj_2d = umap_2d.fit_transform(features)
proj_3d = umap_3d.fit_transform(features)

fig_2d = px.scatter(
    proj_2d, x=0, y=1,
    color=processed_penguins_df.species, labels={'color': 'species'}
)
fig_3d = px.scatter_3d(
    proj_3d, x=0, y=1, z=2,
    color=processed_penguins_df.species, labels={'color': 'species'}
)
fig_3d.update_traces(marker_size=5)

fig_2d.show()
fig_3d.show()```

from sklearn.decomposition import PCA
import seaborn as sns

# Cargamos el conjunto de datos de pingüinos
penguins = sns.load_dataset("penguins")

# Eliminamos las filas con valores faltantes
penguins = penguins.dropna()

# Creamos un objeto PCA y ajustamos los datos
pca = PCA(n_components=2)
pca.fit(penguins.drop(columns=['species']))

# Transformamos los datos a los componentes principales
transformed_data = pca.transform(penguins.drop(columns=['species']))

# Creamos un gráfico con los datos transformados
sns.scatterplot(x=transformed_data[:,0], y=transformed_data[:,1], hue=penguins['species'])

Introducción al análisis exploratorio de datos

¿Qué es y para qué sirve el análisis exploratorio de datos?

¿Cómo hacer un análisis exploratorio de datos?

Tipos de análisis de datos

Tipos de datos y análisis de variables

Herramientas de software para el análisis exploratorio de datos

Conociendo nuestros datos: palmerpenguins

Recolección de datos, limpieza y validación

Ejercicio de validación de datos

Análisis univariado

Explorando una variable categórica: conteos y proporciones

Estadística descriptiva aplicada: medidas de tendencia central

Estadística descriptiva aplicada: medidas de dispersión

Ejercicio de obtención de medidas de dispersión

Estadística descriptiva aplicada: distribuciones

Estadística descriptiva aplicada: funciones de densidad de probabilidad

Bonus: Teorema del límite central

Análisis bivariado

Estableciendo relaciones: gráficos de puntos

Estableciendo relaciones: gráficos de violín y boxplots

Estableciendo relaciones: matrices de correlación

Limitantes de los coeficientes de correlación lineal

Estableciendo relaciones: análisis de regresión simple

Limitaciones del análisis de regresión simple

Análisis multivariado

Análisis de regresión múltiple

Visualización del análisis de regresión múltiple

Análisis de regresión logística

Paradoja de Simpson

¿Qué hacer cuando tengo muchas variables?

Conclusiones

Diversidad de gráficas al explorar datos

Continúa aprendiendo sobre EDA