Contenido del curso
Visualización de valores faltantes en dos variables
Jeinfferson Bernal G
Estudiante
Ian Cristian Ariel Yané
EstudianteJeinfferson Bernal G
Estudiante
José Fernando Aguilar Arredondo
Estudiante
Juan Jose Sepulveda Calderon
EstudianteIan Cristian Ariel Yané
Estudiante
Carlos Mazzaroli
EstudianteJuan Jose Sepulveda Calderon
Estudiante
Daniel Andres Rojas Paredes
Estudiante
Nestor Colmenarez
Estudiante
Diego Cesar Lerma Torres
Estudiante
Iván Roberto Rivas Celeita
Estudiante
Julián Cárdenas
Estudiante
jhon velasque
Estudiante
Mario Alexander Vargas Celis
EstudianteCodigo de la funcion que permite completar los datos faltante para poder graficar el scatterplot
# funcion que añade valores aleatorios a las variables con valores faltantes # para visualizarlos en un eje def column_fill_with_dummies( column: pd.Series, proportion_below: float=0.10, #Proporcion de los datos en la grafica jitter: float=0.075, # evita el asolapamiento de los puntos en la grafica seed: int=42, #semilla para la aleatoriedad ) -> pd.Series: # la funcion retorna una serie #Copiar las columnas del dataframe column = column.copy(deep=True) #Extraer los valores de las variables missing_mask = column.isna() # matriz de booleanos number_missing_values = missing_mask.sum() #conteo de valores faltantes column_range = column.max() - column.min() #rango de las variables # shift data column_shift = column.min() - column.min() * proportion_below # crear un poco de ruido alrededor de los puntos np.random.seed(seed) column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter #Guardar los nuevos datos aleatorios column[missing_mask] = column_shift + column_jitter return column
No se como aria sin tus resúmenes al final de cada vídeo
Visualizacion de valores faltantes en dos variables
Permite visualizar y comparar dos variables cuando a ambas le faltan valores. Un grafico muy util para este tipo de comparaciones son los scatterplot
Para este ejemplo, los puntos azules indican que existe valores tanto para la temperatura como para la humedad. Los puntos rojos indican que solo hay valores para una de las variables y no para la otra. Este tipo de grafica nos ayuda a conocer donde estan agrupados los valores faltantes respecto a otras variables y se grafican fuera de la presencia de los puntos reales para que no introduzcan ruido.
Ademas podemos incluir otro tipo de graficos como los boxplot que nos ayudan a compara la distribucion de los datos de las variables con la distribucion de los datos faltantes y a visualizar si se estan acumulando en un espacio del scatterplot
Este tipo de analisis es importante porque al realizar un EDA sobre los datos faltantes queremos saber si estos siguen una relacion, una tendencia, un comportamiento caracteristico que podamos rellenar segun su variabilidad.
El sentido de la vida, el universo y todo lo demás: El número 42
No había captado la referencia hasta que vi el artículo de Wikipedia 😄
Claramente el profe tiene un IQ destacable!!, hace rato me aparece el libro de esa saga en los recomendados.. Sera que llego la hora de ver su resumen ?!!!
la función column_fill_with dummies debería ir en la carpeta de los utils? 👀
Referencia a la guía del autoestopista galáctico 👀
no me quedo claro el proposito y la naturaleza de la funcion missing _mask utilizada en la clase.?
El concepto de semilla no me quedo claro? que es lo que estamos creando alli?
Dejo mi solución al reto: Función nullity_scatterplot```js def nullity_scatterplot( self, x:str, y:str, **kwargs ): """Recieves a DataFrame and 2 strings with the names of the columns to be used as x and y. Plots a nullity scatterplot"""
return( self._obj.select_dtypes( exclude='category' ) .pipe( lambda df : df[df.columns[df.isna().any()]] ) .missing.bind_shadow_matrix(true_string=True, false_string=False) .apply( lambda column: column if "_NA" in column.name else column.missing.column_fill_with_dummies( proportion_below=0.05, jitter=0.075) ) .assign( nullity = lambda df:df[x+'_NA'] | df[y+'_NA'] ) .pipe( lambda df:( sns.scatterplot( data=df, x=x, y=y, hue='nullity' ) ) ) )
Entonces la implementaríamos al final del archivo de la siguiente manera: ```js @pd.api.extensions.register_series_accessor("missing") class MissingSeriesMethods: def __init__(self, pandas_obj): self._obj = pandas_obj def column_fill_with_dummies( self, proportion_below: float = 0.10, jitter: float = 0.075, seed: int = 42 ) -> pd.Series: """Fills a column with missing values with dummies, to be used in a scatterplot""" # We don't need to copy the original series because we're not modifying it in place # We're going to create a new series for the dummy data # Extract values metadata missing_mask = self._obj.isna() number_missing_values = missing_mask.sum() column_range = self._obj.max() - self._obj.min() # Shift data column_shift = self._obj.min() - self._obj.min() * proportion_below # Create the "jitter" (noise) to be added around the points np.random.seed(seed) column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter # Create new series for dummy data with the same index as the missing values in the original series dummy_data = pd.Series(column_shift + column_jitter, index=self._obj[missing_mask].index) # Return a series combining original and dummy data return self._obj.fillna(dummy_data)
la semilla de aleatoridad permite que el experimento se puede volver a reproducir bajo las mismas condiciones. Puede ser cualquier 42 o cualquier numero
def column_fill_with_dummies( column: pd.Series, proportion_below: float=0.10, jitter: float=0.075, seed: int=42 ) -> pd.Series: column = column.copy(deep=True) # Extract values metadata. missing_mask = column.isna() number_missing_values = missing_mask.sum() column_range = column.max() - column.min() # Shift data column_shift = column.min() - column.min() * proportion_below # Create the "jitter" (noise) to be added around the points. np.random.seed(seed) column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter # Save new dummy data. column[missing_mask] = column_shift + column_jitter return column
def colum_fill_dummies( column:pd.Series, # La columna que se debe procesar proportion_bellow:float =0.10, # Porcentaje para determinar el valor mínimo jitter:float=0.075, # Valor para crear "jitter" en los valores dummies seed:int=42 # Semilla para la función de números aleatorios ) -> pd.Series: # La función devuelve una columna "Series" de pandas # Copiar la columna de entrada column=column.copy(deep=True) # Obtener máscara de valores faltantes y número de valores faltantes missing_mask=column.isna() number_missing_values=missing_mask.sum() # Calcular el rango de valores de la columna column_range=column.max()-column.min() # Calcular el valor mínimo de la columna con el porcentaje especificado column_shift=column.min()-column.min()*proportion_bellow # Crear "jitter" utilizando números aleatorios y el rango de la columna np.random.seed(seed) column_jitter=(np.random.rand(number_missing_values)-2)*column_range*jitter # Reemplazar valores faltantes con valores dummies creados column[missing_mask]=column_shift+column_jitter # Devolver la columna modificada return column
Para visualizar los valores faltantes en dos variables de un conjunto de datos, puedes usar varias técnicas que permiten comparar la relación entre las dos variables y cómo los valores faltantes están distribuidos entre ellas. A continuación te muestro algunas técnicas comunes para visualizar esta información.
### 1. Gráfico de Dispersión con Colores que Indiquen los Valores Faltantes
Puedes crear un gráfico de dispersión para comparar dos variables, usando colores diferentes para mostrar si alguno de los puntos tiene valores faltantes en alguna de las variables.
import pandas as pd import seaborn as sns import matplotlib.pyplot as plt \# Crear un DataFrame de ejemplo con valores faltantes data = {'Variable1': \[1, 2, None, 4, 5, 6, 7, None, 9, 10],   'Variable2': \[5, None, 7, None, 9, 10, None, 12, 13, 14]} df = pd.DataFrame(data) \# Crear una nueva columna que identifique si hay valores faltantes en alguna de las dos variables df\['Missing'] = df.isnull().any(axis=1) \# Visualizar con un gráfico de dispersión plt.figure(figsize=(8, 6)) sns.scatterplot(x='Variable1', y='Variable2', hue='Missing', data=df, palette='coolwarm') plt.title('Valores Faltantes en Dos Variables') plt.show()
### 2. Gráfico de Mapa de Calor para Mostrar Correlación de Faltantes
Otra técnica es un mapa de calor que indica la correlación de valores faltantes entre dos o más variables, permitiendo ver si los valores faltantes en una variable coinciden con los faltantes en otra.
import seaborn as sns import matplotlib.pyplot as plt import pandas as pd \# Crear un DataFrame de ejemplo con valores faltantes data = {'Variable1': \[1, None, 3, 4, 5, None, 7, 8, 9, None],   'Variable2': \[None, 2, 3, None, 5, 6, None, 8, None, 10]} df = pd.DataFrame(data) \# Visualización de valores faltantes con un mapa de calor plt.figure(figsize=(6, 4)) sns.heatmap(df.isnull(), cmap='coolwarm', cbar=False, yticklabels=False) plt.title('Mapa de Calor de Valores Faltantes en Dos Variables') plt.show()
### 3. Gráfico de Barras Apiladas
Otra opción es usar un gráfico de barras apiladas para visualizar la proporción de valores faltantes en dos variables. Esto permite ver claramente qué porcentaje de los datos está presente o ausente.
import pandas as pd import seaborn as sns import matplotlib.pyplot as plt \# Crear un DataFrame de ejemplo con valores faltantes data = {'Variable1': \[1, 2, None, 4, 5, None, 7, 8, 9, 10],   'Variable2': \[None, 2, 3, None, 5, None, 7, 8, None, 10]} df = pd.DataFrame(data) \# Contar valores faltantes y no faltantes missing\_counts = df.isnull().sum() present\_counts = len(df) - missing\_counts \# Crear DataFrame para el gráfico bar\_df = pd.DataFrame({'Missing': missing\_counts, 'Present': present\_counts}) \# Gráfico de barras apiladas bar\_df.T.plot(kind='bar', stacked=True, color=\['red', 'green']) plt.title('Valores Faltantes en Dos Variables') plt.xlabel('Variables') plt.ylabel('Conteo') plt.show()
### Descripción:
1. **Gráfico de Dispersión**: Permite ver la relación entre dos variables, con los puntos coloreados según si tienen o no valores faltantes.
2. **Mapa de Calor**: Muestra de manera visual qué celdas del DataFrame tienen valores faltantes, utilizando colores.
3. **Gráfico de Barras Apiladas**: Da una vista general de cuántos valores faltantes y presentes hay para cada variable.
Estas visualizaciones ayudan a entender mejor cómo se distribuyen los valores faltantes entre las dos variables, lo que es crucial antes de aplicar técnicas de imputación o limpieza.
¿Te gustaría más ejemplos o alguna ampliación sobre alguno de estos métodos?
