Explora y encuentra patrones en la información

El EDA es para conocer los datos que tenemos 📊

Y es que puede pasar que luego de haber recolectado información aún nos haga falta para responder nuestra pregunta. El EDA (Exploratory Data Analysis) entonces nos hace ver lo que tenemos y lo que podemos hacer con los datos.

¿Y cómo podemos podemos hacer un EDA?

Ve de lo más pequeño a lo más grande. Y de lo más general a lo más específico.

Un buen inicio es hacer una breve descripción estadística de nuestro dataframe usando df.info(). Luego pasa al análisis univariable, bivariable y multivariable. Además, recuerda que necesitas mucha visualización de datos.

Análisis univariable

Aquí buscas entender lo que representa cada variable (columna) por sí sola. Puedes usar distribuciones o histogramas.

Análisis bivariable

En este caso, tu objetivo es entender la relación entre dos variables de interés. Puedes usar distribuciones e histogramas, pero ya añades un hue según necesites. Las correlaciones son muy usadas también.

Análisis multivariable

Ahora ya necesitas entender la relación entre 3 o más variables.

Toma el Curso de Análisis Exploratorio de Datos para entender más.

El curso de Análisis Exploratorio de Datos deben reestructurarlo completamente, fue muy lamentable el curso a diferencia de otros que hay en el learning path de Data Science y esto lo digo con mucha pena.

df.memory_usage( )

Devuelve la cantidad de memoria que utiliza cada columna en bytes. Es útil especialmente cuando trabajamos con grandes dataframes.

Empece a encontrar patrones en el tránsito y la verdad es que me llena de alegría ver cómo se comporta el transporte automovilístico en la ciudad de Montevideo, Uruguay:

Les dejo dos funciones imprescindibles para que puedan visualizar y luego optimizar el tamaño en memoria de su dataset.

memory_usage = df_data.memory_usage(deep=True) / 1024 ** 2
memory_usage.loc['total'] = memory_usage.sum()
memory_usage = memory_usage.to_frame(name="memory usage of variable (MB)")
memory_usage.style.bar(subset=["memory usage of variable (MB)",], color='#ee1f5f', axis=0).format("{:.6f} MB")

def reduce_memory_usage(df, verbose=True):
    numerics = ["int8", "int16", "int32", "int64", "float16", "float32", "float64"]
    start_mem = df.memory_usage().sum() / 1024 ** 2
    for col in df.columns:
        col_type = df[col].dtypes
        if col_type in numerics:
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == "int":
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)
            else:
                if (
                    c_min > np.finfo(np.float16).min
                    and c_max < np.finfo(np.float16).max
                ):
                    df[col] = df[col].astype(np.float16)
                elif (
                    c_min > np.finfo(np.float32).min
                    and c_max < np.finfo(np.float32).max
                ):
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
    end_mem = df.memory_usage().sum() / 1024 ** 2
    if verbose:
        print(
            "Mem. usage decreased to {:.2f} Mb ({:.1f}% reduction)".format(
                end_mem, 100 * (start_mem - end_mem) / start_mem
            )
        )
    return df

df_data = reduce_memory_usage(df_data, verbose=True)

import pandas as pd
import matplotlib.pyplot as plt

# Análisis bivariable de 'cobertura_bruta' y 'cobertura_neta'
plt.scatter(data_limpia['cobertura_bruta'], data_limpia['cobertura_neta'])
plt.title('Relación entre Cobertura Bruta y Neta')
plt.xlabel('Cobertura Bruta')
plt.ylabel('Cobertura Neta')
plt.show()

Este código representa los valores de ‘cobertura_bruta’ en el eje xy ‘cobertura_neta’ en el eje y. Observar la dispersión de puntos en un gráfico de dispersión puede proporcionar una idea inicial sobre la relación entre estas dos variables.

Además del gráfico de dispersión, existen varias técnicas de análisis bivariable que podrían ser aplicadas dependiendo de las variables que desees analizar. Estos incluyen tablas de contingencia, coeficientes de evaluación, gráficos de líneas, histogramas, entre otros, para explorar la relación entre diferentes pares de variables en tu conjunto de datos.

EL GOOGLE COLAB LO CORRE MUY BIEN

me enamore del profe muy lindo curso carajos, lo demas es solo para llenar