Ejercicio de obtención de medidas de dispersión

Es interesante ver la distribución del conjunto de datos de las tres especies. 🤔

Ciertamente, parece bimodal, aunque posiblemente al normalizar la data, encontraremos algún factor influyente que cambie este panorama 📊

var_flipper_len = processed_penguins_df['flipper_length_mm']

g=sns.histplot(
    data=processed_penguins_df,
    x='flipper_length_mm',
    binwidth=1,
    hue='species',
    alpha=.5
)
g.set_title('Penguins Flipper Length Distribution', y=1.03)

# Mean(Red)
plt.axvline(
    x =var_flipper_len.mean(),
    linestyle="dashed",
    color="r",
    linewidth=2
)

# Median(Green)
plt.axvline(
    x=var_flipper_len.median(),
    linestyle="dashed",
    color="g",
    linewidth=2
)

# Q_75(Black)
plt.axvline(
    x=var_flipper_len.quantile(0.75),
    linestyle="dashed",
    color="k",
    linewidth=2
)

# Q_25(Black)
plt.axvline(
    x=var_flipper_len.quantile(0.25),
    linestyle="dashed",
    color="k",
    linewidth=2
)

plt.text(184.7,17.5, 'Q(25%)', fontsize=12)
plt.text(192,17.5, 'median', fontsize=12, color='g')
plt.text(201.5,17.5, 'mean', fontsize=12, color='r')
plt.text(213.5,17.5, 'Q(75%)', fontsize=12)

plt.show()

Aca visualizamos la distribucion de las distintas caracteristicas por especie

numeric_columns = penguins_df.select_dtypes(include=np.number).columns

fig,ax = plt.subplots(1,len(numeric_columns), figsize=(15,5))

for i in range(len(numeric_columns)):
    sns.histplot( 
        ax=ax[i],
        data=penguins_df,
        x=numeric_columns[i],
        multiple='stack',
        hue='species',
        bins=15,
        palette=penguin_color,
        kde=True,
        )

Aca visualizamos una caracteristica en especifico con su media respectiva, cuantiles y ya separadas las especies

species = penguins_df.species.unique()

adelie_df = penguins_df.query("species == 'Adelie'")
gentoo_df = penguins_df.query("species == 'Gentoo'")
chinstrap_df = penguins_df.query("species == 'Chinstrap'")

list = [adelie_df,gentoo_df,chinstrap_df]

fig,ax = plt.subplots(1,len(list), figsize=(15,5), sharey=True)

for i in range(len(list)):
    sns.histplot( 
        ax=ax[i],
        data=list[i],
        x='flipper_length_mm',
        multiple='layer',
        hue='species',
        bins=15,
        kde=True,
        palette=penguin_color,
        )

    ax[i].axvline(
        x=list[i]['flipper_length_mm'].mean(),
        color='red'
        )

    ax[i].axvline(
        x=list[i]['flipper_length_mm'].quantile(.25),
        color='blue'
        )

    ax[i].axvline(
        x=list[i]['flipper_length_mm'].quantile(.75),
        color='blue'
        )```

¿Cuál es el valor Freedman-Diaconis?

Después de la función la declaramos.
Para Flipper_length_mm: 3.3 👇

Las gráficas boxenplot nos ayudan a identificar un poco mejor la distribución de nuestros datos sin necesidad de hacer un histplot. Es tan versatil que podemos ajustar la cantidad de quantiles que queremos relfejar.
Aunque es más útil cuando hay mayor cantidad de datos puede influir en una mejor interpretación:

sns.boxenplot(
    data=preprocess_penguins_df,
    x="flipper_length_mm",
    y="species",
    palette=penguin_color,
    k_depth=4
);

Un plus sería analizarlos por sexo:

Para poder hacer una comparación rápida entre las variables de los pinguineins

species = penguins_df.species.unique()

adelie_df = penguins_df.query("species == 'Adelie'")
gentoo_df = penguins_df.query("species == 'Gentoo'")
chinstrap_df = penguins_df.query("species == 'Chinstrap'")

list = [adelie_df,gentoo_df,chinstrap_df]
numeric_columns = penguins_df.select_dtypes(include=np.number).columns

fig,ax = plt.subplots(len(numeric_columns),len(list),sharey=True, figsize=(15,12))

for j in range(len(numeric_columns)):
    for i in range(len(list)):
        sns.histplot( 
            ax=ax[j][i],
            data=list[i],
            x=numeric_columns[j],
            multiple='stack',
            hue='species',
            bins=15,
            kde=True,
            palette=penguin_color,
            )
        

        ax[j][i].set_ylabel(f'{numeric_columns[j]}')
        ax[j][i].set_xlabel(f'{species[i]}')

        ax[j][i].get_legend().remove()

Menos codigo mas accion.

sns.histplot(
    data=processed_penguins_df,
    x='flipper_length_mm'
)
x_stats = [
    [processed_penguins_df.flipper_length_mm.mean(),'r',2],
    [processed_penguins_df.flipper_length_mm.median(),'g',2],
    [processed_penguins_df.flipper_length_mm.mode().max(),'y',2],
    [processed_penguins_df.flipper_length_mm.quantile(0.75),'k',2],
    [processed_penguins_df.flipper_length_mm.quantile(0.25),'k',1]
    ]
 
[plt.axvline(
    x=value[0], 
    color=value[1],
    linestyle='dashed',
    linewidth=value[2]
    ) for value in x_stats]
    
heigth = 75
plt.text(processed_penguins_df.flipper_length_mm.quantile(0.25)+ 0.25,heigth, 'Q(25%)', fontsize=12)
plt.text(processed_penguins_df.flipper_length_mm.mode().max() + 0.25,heigth-3, 'mode', fontsize=12, color='y')
plt.text(processed_penguins_df.flipper_length_mm.median() + 0.25,heigth-6, 'median', fontsize=12, color='g')
plt.text(processed_penguins_df.flipper_length_mm.mean()+ 0.25,heigth-9, 'mean', fontsize=12, color='r')
plt.text(processed_penguins_df.flipper_length_mm.quantile(0.75)+0.25,heigth, 'Q(75%)', fontsize=12)

Con la longitud del pico pingüinesco:

*La Isla Biscoe es la más densamente poblada: En ella, los pingüinos suelen tener una longitud del pico promedio, también es donde podemos encontrar la mayor cantidad de pingüinos con el pico más grande, aunque no es una cantidad significativa

Determinación el tamaño de binwidth del histograma mediante la regla de Freedman-Diaconis

Los histogramas se utilizan para estimar la distribución de probabilidad de una variable aleatoria continua. Se utilizan con frecuencia como punto de partida del análisis exploratorio de datos y proporcionan información sobre la forma y la variabilidad de los datos en cuestión. Uno de los desafíos en la construcción de histogramas es seleccionar el número óptimo de contenedores (o, análogamente, el ancho de cada contenedor). Para ayudar a determinar un ancho de intervalo razonable, podemos aprovechar la regla de Freedman-Diaconis, que fue diseñada para minimizar la diferencia entre el área bajo la distribución de probabilidad empírica y el área bajo la distribución de probabilidad teórica.

Formalmente, la regla toma como entrada el rango intercuartílico IQR(x) y el número de observaciones n en el conjunto de datos empíricos, y devuelve una estimación del ancho del intervalo. La regla se puede expresar como:

$$Bin~width = 2 \frac{IQR(x)}{\sqrt{n}}$$

sns.histplot(data=penguins_df_final, x="flipper_length_mm", kde=True, binwidth=freedman_diaconis_bindwidth(penguins_df_final.bill_length_mm));
plt.axvline(x=penguins_df_final.flipper_length_mm.mean(), color = 'red', linestyle='dashed', linewidth=2); 

Para complementar el ultimo comentario de la clase, les comparto el Anscombe’s Quartet:

Never trust summary statistics alone; always visualize your data

Aquí mi histograma con bins=3 y haciendo hue=‘species’:

sns.histplot(
    data = preprocess_penguins_df,
    x='flipper_length_mm',
    hue='species',
    palette=penguin_color,
    binwidth=3
)

plt.axvline(
    x=preprocess_penguins_df.flipper_length_mm.mean(),
    color = 'red',
    linestyle = 'dashed',
    linewidth=3
)
plt.axvline(
    x=preprocess_penguins_df.flipper_length_mm.median(),
    color = 'green',
    linestyle = 'dashed',
    linewidth=3
)

plt.text(preprocess_penguins_df.flipper_length_mm.median(),30, 'median', fontsize=12, color='g')
plt.text(preprocess_penguins_df.flipper_length_mm.mean(), 30, 'mean', fontsize=12, color='r')

plt.show()```

Medidas de Dispersion Notebook

• max() arroja los valores maximos de las variables del dataset. Utiliza el parametro numeric_only para obtener el maximo solo de las variables numericas

dataFrame.max(numeric_only=True)

• min() arroja los valores minimos de las variables del dataset

dataFrame.min(numeric_only=True)

• Calculo del rango intercuartil mostrado en una tabla

(
    dataFrame
    .quantile(q=[0.75,0.50,0.25])
    .transpose()
    .rename_axis('variable')
    .reset_index()
    .assign(
        iqr=lambda df: df[0.75] - df[0.25]
    )
)

• Histograma de una variable del dataset

#histograma
sns.histplot(
    data=preprocessed_penguins_df,
    x='flipper_length_mm'
)

#trazar la media en la grafica
plt.axvline(
    x=preprocessed_penguins_df.flipper_length_mm.mean(),
    color='red',
    linestyle='dashed',
    linewidth=2
)

• Diagrama de caja de una variable del dataset

sns.boxplot(
    data=preprocessed_penguins_df,
    x='flipper_length_mm',
)

• Funcion Freedman Diaconis. Permite calcular el bin mas adecuado basados en el rango intercuartil

La proporción de los pinguinos por isla:

Luego, hice un hist para comparar la masa en cada isla.
Al parecer también muchas comparaciones serán bimodales ya que serán pinguinos de islas distintas, pero al parecer los pinguinos en la isla biscoe son más gorditos

fig = px.histogram(processed_penguins_df, x="flipper_length_mm",
                   marginal="box", color='species', opacity=0.8,
                   hover_data=processed_penguins_df.columns)
fig.show()

fig = px.box(processed_penguins_df, y="flipper_length_mm", color='species', points="all")
fig.show()

Comparto un histograma sobre la variable bill_length_mm con las medidas de tendencia central .

El ancho de banda de Freedman-Diaconis (Freedman-Diaconis bin width) es una regla de referencia para determinar el tamaño óptimo de los intervalos (bins) en un histograma. Esta regla equilibra la necesidad de suficiente resolución en el histograma para ver los detalles en la distribución de datos, sin sobreajustar el ruido.

También si corregimos el boxplot por especie da lo siguiente:  ```js sns.boxplot( data=penguins_df, x='flipper_length_mm', y='species', palette=penguin_color ) ```sns.boxplot(    data=penguins\_df,    x='flipper\_length\_mm',    y='species',    palette=penguin\_color)

Minuto 7:56 si les aparece key 0.25 error, aqui esta la solucion

result = (
    data
    .quantile(q=[0.75, 0.50, 0.20])
    .transpose()
    .rename_axis("variable")
    .reset_index()
)

if 0.25 in result.columns and 0.75 in result.columns:
    result = result.assign(iqr=lambda df: df[0.75] - df[0.25])

result

Con la funcion describe() de pandas tambien podemos tener las medidas de dispersion por lo que use estos datos para ya graficarlos en el histograma 😉

sns.histplot(
        data=df,
        x='flipper_length_mm',
        bins=6)

colors = ['red', 'blue', 'green', 'orange', 'yellow', 'brown']
df_metrics = df.describe()[['flipper_length_mm']].transpose()

i = 0
for metric in df_metrics.columns:
    if metric != 'std' and metric != 'count': 
        plt.axvline(x=df_metrics[metric].values, 
                    color=colors[i], 
                    label=metric, 
                    linestyle='dashed', 
                    linewidth = 2)
        i = i+1
    else: pass

plt.legend()

Para ver de forma gráfica la media de cada especie hice lo siguiente:

ys = processed_penguins_df.groupby(['species']).flipper_length_mm.mean()

sns.histplot(processed_penguins_df,
             x='flipper_length_mm',
             binwidth=1,
             hue='species',
             alpha=.5
             )
plt.axvline(
    x=ys[0],
    linestyle="dashed",
    color="blue",
    linewidth=2
)
plt.axvline(
    x=ys[1],
    linestyle="dashed",
    color="green",
    linewidth=2
)
plt.axvline(
    x=ys[2],
    linestyle="dashed",
    color="orange",
    linewidth=2
)

plt.show()

Para ver de forma gráfica la media de cada especie hice lo siguiente:

ys = processed_penguins_df.groupby(['species']).flipper_length_mm.mean()

sns.histplot(processed_penguins_df,
             x='flipper_length_mm',
             binwidth=1,
             hue='species',
             alpha=.5
             )
plt.axvline(
    x=ys[0],
    linestyle="dashed",
    color="blue",
    linewidth=2
)
plt.axvline(
    x=ys[1],
    linestyle="dashed",
    color="green",
    linewidth=2
)
plt.axvline(
    x=ys[2],
    linestyle="dashed",
    color="orange",
    linewidth=2
)

plt.show()

Implementando la función `freedman` lo hice así (espero que sea así):  Me arrojó un resultado grafico  Espero que sea correcto. Si desean visitar mi repositorio de Git Hub de este curso, aquí lo dejo: <https://github.com/DensLopez/Analisis_Exploratorio>

```python # Creacion de ejes: 2 filas y 1 columna fig, ax = plt.subplots(2,1,figsize=(6, 6), sharex=True) # Configuracion para texto bbox_props = dict( boxstyle="round,pad=0.3", edgecolor="none", facecolor="black", alpha=0.7 ) # Grafico de distribucion sns.histplot( data=preproces_penguins_df, x='flipper_length_mm', ax=ax[0] ) # Media linea ax[0].axvline( x=preproces_penguins_df.flipper_length_mm.mean(), color='red', linestyle='dashed', linewidth=2, label='mediana' ) ax[0].text( preproces_penguins_df.flipper_length_mm.mean(), 70, 'Media', color='w', verticalalignment='bottom', bbox=bbox_props) # Q25 linea ax[0].axvline( x=preproces_penguins_df.flipper_length_mm.quantile(0.25), color='green', linestyle='dashed', linewidth=2, label='mediana' ) ax[0].text( preproces_penguins_df.flipper_length_mm.quantile(0.25), 70, 'Q25', color='w', verticalalignment='bottom', bbox=bbox_props) # Q75 linea ax[0].axvline( x=preproces_penguins_df.flipper_length_mm.quantile(0.75), color='green', linestyle='dashed', linewidth=2, label='mediana' ) ax[0].text( preproces_penguins_df.flipper_length_mm.quantile(0.75), 70, 'Q75', color='w', verticalalignment='bottom', bbox=bbox_props) # Grafico de cajas sns.boxplot( data=preproces_penguins_df, x='flipper_length_mm', ax=ax[1] ) # Quitar todo del gráfico de cajas excepto el gráfico ax[1].set_yticks([]) # Quitar los ticks del eje y ax[1].set_ylabel('') # Quitar la etiqueta del eje y ax[0].set_xlabel('') # Quitar la etiqueta del eje x ax[1].xaxis.set_ticks([]) # Quitar los ticks del eje x ax[1].xaxis.set_ticklabels([])# Quitar las etiquetas de los ticks del eje x ax[1].grid(False) # Quitar la cuadrícula # Quitar el recuadro (marco) alrededor del gráfico ax[1].spines['top'].set_visible(False) ax[1].spines['right'].set_visible(False) ax[1].spines['left'].set_visible(False) ax[1].spines['bottom'].set_visible(False) plt.show() ```*#* Creacion de ejes: 2 filas y 1 columnafig, ax = plt.subplots(2,1,figsize=(6, 6), sharex=True) *#* Configuracion para textobbox\_props = dict( boxstyle="round,pad=0.3", edgecolor="none", facecolor="black", alpha=0.7) *#* Grafico de distribucionsns.histplot( data=preproces\_penguins\_df, x='flipper\_length\_mm', ax=ax\[0]) *#* Media lineaax\[0].axvline( x=preproces\_penguins\_df.flipper\_length\_mm.mean(), color='red', linestyle='dashed', linewidth=2, label='mediana')ax\[0].text( preproces\_penguins\_df.flipper\_length\_mm.mean(), 70, 'Media', color='w', verticalalignment='bottom', bbox=bbox\_props) *#* Q25 lineaax\[0].axvline( x=preproces\_penguins\_df.flipper\_length\_mm.quantile(0.25), color='green', linestyle='dashed', linewidth=2, label='mediana')ax\[0].text( preproces\_penguins\_df.flipper\_length\_mm.quantile(0.25), 70, 'Q25', color='w', verticalalignment='bottom', bbox=bbox\_props) *#* Q75 lineaax\[0].axvline( x=preproces\_penguins\_df.flipper\_length\_mm.quantile(0.75), color='green', linestyle='dashed', linewidth=2, label='mediana')ax\[0].text( preproces\_penguins\_df.flipper\_length\_mm.quantile(0.75), 70, 'Q75', color='w', verticalalignment='bottom', bbox=bbox\_props) *#* Grafico de cajassns.boxplot( data=preproces\_penguins\_df, x='flipper\_length\_mm', ax=ax\[1]) *#* Quitar todo del gráfico de cajas excepto el gráficoax\[1].set\_yticks(\[]) *#* Quitar los ticks del eje yax\[1].set\_ylabel('') *#* Quitar la etiqueta del eje yax\[0].set\_xlabel('') *#* Quitar la etiqueta del eje xax\[1].xaxis.set\_ticks(\[]) *#* Quitar los ticks del eje xax\[1].xaxis.set\_ticklabels(\[])*#* Quitar las etiquetas de los ticks del eje xax\[1].grid(False) *#* Quitar la cuadrícula *#* Quitar el recuadro (marco) alrededor del gráficoax\[1].spines\['top'].set\_visible(False)ax\[1].spines\['right'].set\_visible(False)ax\[1].spines\['left'].set\_visible(False)ax\[1].spines\['bottom'].set\_visible(False) plt.show() 

 `sns.histplot( data=processed_penguins_df, x='flipper_length_mm', hue='species', # Utiliza la columna 'species' para diferenciar colores palette=penguin_color # Aplica la paleta de colores personalizada)` `# Obtener valores para las líneas verticalesmedian_value = processed_penguins_df.flipper_length_mm.median()mode_value = processed_penguins_df.flipper_length_mm.mode().values[0]quantile_25_value = processed_penguins_df.flipper_length_mm.quantile(0.25)quantile_75_value = processed_penguins_df.flipper_length_mm.quantile(0.75)` `# Agregar líneas verticales y etiquetasplt.axvline( x=median_value, color='blue', linestyle='dashed', linewidth=2)plt.text(median_value, plt.gca().get_ylim()[1] * 0.9, 'Mediana', color='blue', rotation=0)` `plt.axvline( x=mode_value, color='black', linestyle='dashed', linewidth=4)plt.text(mode_value, plt.gca().get_ylim()[1] * 0.9, 'Moda', color='black', rotation=0)` `plt.axvline( x=quantile_25_value, color='yellow', linestyle='dashed', linewidth=2)plt.text(quantile_25_value, plt.gca().get_ylim()[1] * 0.3, 'Cuartil 1 (Q1)', color='yellow', rotation=0)` `plt.axvline( x=quantile_75_value, color='yellow', linestyle='dashed', linewidth=2)plt.text(quantile_75_value, plt.gca().get_ylim()[1] * 0.9, 'Cuartil 3 (Q3)', color='black', rotation=0)` `# Mostrar el gráficoplt.show()`

Hay distribuciones bimodales aún dentro del mismo pinguino. 

```js sns.set_theme() fig3,ax3 = plt.subplots(1,len(numeric_columns)-1, figsize=(15,5)) for i in range(len(numeric_columns)-1): g=sns.violinplot( ax=ax3[i], data=pen_df, hue='species', legend= True if i == 3 else False, x=numeric_columns[i], palette = "inferno" ) sns.move_legend(g, 'lower center', bbox_to_anchor=(-1.3, 1.05), ncol=6, title='Especie') plt.show() ```Hay distribuciones bimodales aún entre el mismo tipo de pinguino. 

```js sns.set_theme() fig2,ax2 = plt.subplots(1,len(numeric_columns)-1, figsize=(15,5)) for i in range(len(numeric_columns)-1): g=sns.boxplot( ax=ax2[i], data=pen_df, hue='species', legend= True if i == 3 else False, x=numeric_columns[i], notch = True, palette = "inferno" ) sns.move_legend(g, 'lower center', bbox_to_anchor=(-1.3, 1.05), ncol=6, title='Especie') plt.plot() sns.reset_orig() ```Aquí muestro por una prueba no paramétrica que la diferencia entre cada especie en todos los datos numéricos es estadísticamente significativa. 

Se están observando distribuciones con más de un punto crítico máximo gracias a la combinación de especies. 

```python ```def freedman\_diaconis\_binwidth(x: pd.Series) -> float:    IQR = x.quantile(0.75) - x.quantile(0.25)    N = x.size    return 2 \* IQR / N\*\*(1/3) data = penguin\_dfbinwidth = freedman\_diaconis\_binwidth(data) bins = (penguin\_df.flipper\_length\_mm.max() - penguin\_df.flipper\_length\_mm.min())/binwidth\[2] sns.histplot(data = penguin\_df, x = 'flipper\_length\_mm',             bins = math.ceil(bins)) quantiles = penguin\_df.flipper\_length\_mm.quantile(\[0, 0.25, 0.5, 0.75, 1])desv = \[penguin\_df.flipper\_length\_mm.mean() + penguin\_df.flipper\_length\_mm.std(), penguin\_df.flipper\_length\_mm.mean() - penguin\_df.flipper\_length\_mm.std()]desv2 = \[penguin\_df.flipper\_length\_mm.mean() + penguin\_df.flipper\_length\_mm.std()\*2, penguin\_df.flipper\_length\_mm.mean() - penguin\_df.flipper\_length\_mm.std()\*2] plt.axvline(x = penguin\_df.flipper\_length\_mm.mean(),            color = 'red',            linewidth=2) for d in desv:    plt.axvline(x = d,                color = 'green',                linewidth = 2) for d2 in desv2:    plt.axvline(x = d2,                color = 'blue',                linewidth = 2) for q in quantiles:    plt.axvline(x=q,                 color='brown',                 linestyle='dashed') plt.show()

Aqui mi aportacion, creo que no es lo mejor para presentar los datos pero puse la media, los cuartiles 0.25 y 0.75 el valor maximo y minimo y la media mas/menos desviacion estandar y calculo el numero de bins. def freedman\_diaconis\_binwidth(x: pd.Series) -> float:    IQR = x.quantile(0.75) - x.quantile(0.25)    N = x.size    return 2 \* IQR / N\*\*(1/3) data = penguin\_dfbinwidth = freedman\_diaconis\_binwidth(data) bins = (penguin\_df.flipper\_length\_mm.max() - penguin\_df.flipper\_length\_mm.min())/binwidth\[2] sns.histplot(data = penguin\_df, x = 'flipper\_length\_mm',             bins = math.ceil(bins)) quantiles = penguin\_df.flipper\_length\_mm.quantile(\[0, 0.25, 0.5, 0.75, 1])desv = \[penguin\_df.flipper\_length\_mm.mean() + penguin\_df.flipper\_length\_mm.std(), penguin\_df.flipper\_length\_mm.mean() - penguin\_df.flipper\_length\_mm.std()]desv2 = \[penguin\_df.flipper\_length\_mm.mean() + penguin\_df.flipper\_length\_mm.std()\*2, penguin\_df.flipper\_length\_mm.mean() - penguin\_df.flipper\_length\_mm.std()\*2] plt.axvline(x = penguin\_df.flipper\_length\_mm.mean(),            color = 'red',            linewidth=2) for d in desv:    plt.axvline(x = d,                color = 'green',                linewidth = 2) for d2 in desv2:    plt.axvline(x = d2,                color = 'blue',                linewidth = 2) for q in quantiles:    plt.axvline(x=q,                 color='brown',                 linestyle='dashed') plt.show()  ```python ```

La variable a la cual le saque los histogramas fue la de 'bill\_depth\_mm', en esta no se llega a ver una distribución binomial. 

La diferencia en el histograma sucede por las diferencia entre especies, se pude ver en el siguiente histograma: 

mi hipótesis es que la longitud de las aletas de los pingüinos varían de acuerdo a la isla donde habitan 

Con el código me dio error en la función del minuto 8:50. Para ello cambié el código a: ```js numeric_columns = processed_penguins_df.select_dtypes(include=[np.number]).columns ( processed_penguins_df[numeric_columns] .quantile(q=[0.75, 0.50, 0.25]) .transpose() .rename_axis('metric') .reset_index() .assign( iqr = lambda df: df[0.75] - df[0.25] ) ) ```

Lo que causa esta distribución bimodal de la longitud de las alas de pingüinos es que estamos observando superpuestos los datos de varias especies de pingüinos a la vez. Si tomamos en cuenta la variable de especie, esta distribución se normaliza un poco. 

Entre la clase y los comentarios, hay una cantidad sorprendete de buena informacion y cosas por aprender. Este curso es 10/10.

Boxplot:

• los bigotes deberían de mostrar el límite inferior y superior,
• la linea de la mitad es la mediana no la media,
• el rectángulo chico indica más concentración de los valores de los datos y el grande indica mayor dispersión de los valores de los datos,
• en ambos rectángulos existen la misma cantidad de datos.

 

 

indice = df_num.columns.tolist()
# => indice = ['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm', 'body_mass_g']

# pick me..!
var = indice[2]

# Calcula el IQR para cada columna (para el calculo de los bigotes)
IQR = df_num.quantile(0.75) - df_num.quantile(0.25)

# Cálculo de los límites de los bigotes
lower_limit = df_num.quantile(0.25) - 1.5 * IQR
upper_limit = df_num.quantile(0.75) + 1.5 * IQR

# Ajusta el ancho del gráfico
plt.figure(figsize=(12, 6))

sns.boxplot(
    x=df_num[var]
)

# Línea vertical punteada en la posición de la MEDIANA
plt.axvline(x=df_num[var].median(), 
            color='black', 
            linestyle='dashed', 
            linewidth=1)

# Línea vertical punteada en la posición de la MEDIA
plt.axvline(x=dfnn[var].mean(), 
            color='blue', 
            linestyle='dashed', 
            linewidth=1)

# Línea vertical punteada en la posición del MINIMO
plt.axvline(x=dfnn[var].min(), 
            color='red', 
            linestyle='dashed', 
            linewidth=1)

# Línea vertical punteada en la posición del MAXIMO
plt.axvline(x=dfnn[var].max(), 
            color='red', 
            linestyle='dashed', 
            linewidth=1)

# LIMITE INFERIOR (acá debería llegar el bigote)
plt.axvline(x=lower_limit[var], 
            color='purple', 
            linestyle='--', 
            linewidth=3)

# LIMITE SUPERIOR (acá debería llegar el bigote)
plt.axvline(x=upper_limit[var], 
            color='purple', 
            linestyle='--', 
            linewidth=3)

# Salidas de pantalla
print('\033[95m' + f'Límite inferior -> {lower_limit[var]}' + '\033[0m')
print('\033[91m' + f'Valor mínimo    -> {df_num[var].min()}' + '\033[0m')
print()
print('\033[91m' + f'Valor máximo    -> {df_num[var].max()}' + '\033[0m')
print('\033[95m' + f'Límite superior -> {upper_limit[var]}' + '\033[0m')

plt.show()

def freedman_diaconis_binwidth(x: pd.Series) -> float:

    IQR = x.quantile(0.75) - x.quantile(0.25)
    N = x.size

    return 2 * IQR / N **(1/3)

sns.histplot(data=processed_penguins_df, x="flipper_length_mm", kde=True, binwidth=freedman_diaconis_binwidth(processed_penguins_df.bill_length_mm));
plt.axvline(x=processed_penguins_df.flipper_length_mm.mean(), color = 'red', linestyle='dashed', linewidth=2)

Me basé en la información compartida por María Eugenia Pereira Chévez para completarlo.

12. Ejercicio de obtención de medidas de dispersión

sns.histplot(
    data=processed_penguins_df, 
    x='bill_depth_mm',
    binwidth=freedman_diaconis_bindwidth(processed_penguins_df['bill_depth_mm'])
    )

mean = processed_penguins_df['bill_depth_mm'].mean()
median = processed_penguins_df['bill_depth_mm'].median()
mode = processed_penguins_df['bill_depth_mm'].mode().values[0]
quantiles = np.percentile(processed_penguins_df['bill_depth_mm'], [25, 50, 75])

plt.axvline(mean, color='red', linestyle='--', linewidth=2, label='Mean')
plt.axvline(median, color='blue', linestyle='--', linewidth=2, label='Median')
plt.axvline(mode, color='green', linestyle='--', linewidth=2, label='Mode')

for i, quantile in enumerate(quantiles):
    plt.axvline(quantile, color='purple', linestyle='--', linewidth=2, label=f'Quantile {i+1}')

plt.legend()
plt.show()

<sns.histplot(
    data = preproced_penguins_df,
    x = "flipper_length_mm",
    hue = "species",
    kde = True,
    bins = 25
)
plt.axvline(
    x = preproced_penguins_df.flipper_length_mm.mean(),
    color = "red",
    ls = "dashed",
    linewidth = 2,
    label = "mean"
    )
plt.axvline(
    x = preproced_penguins_df.flipper_length_mm.median(),
    color = "green",
    ls = "dashed",
    linewidth = 2
)
plt.axvline(
    x = preproced_penguins_df.flipper_length_mm.mode().item(),
    color = "black",
    ls = "dashed",
    linewidth = 2
)
plt.text(201.5,20, "mean", fontsize =12, color = "red")
plt.text(192,20, "median", fontsize =12, color = "green")
plt.text(186,20, "mode", fontsize =12, color = "k")
plt.show()> 

Esta distribución bimodal cuenta con un sesgo positivo ya que cumple la condición “media > mediana > moda”.

• los rangos intercartiles son muchos mas robustos nos dan mas información porque se basan en percentiles

---

que consiste en dividir nuestros datos en partes iguales

preprossed_penguins_df.quantile()

• imprimiendo la media de las variables

count      bill_length_mm  bill_depth_mm  flipper_length_mm  body_mass_g
count      342.000000     342.000000         342.000000   342.000000
mean        43.921930      17.151170         200.915205  4201.754386
std          5.459584       1.974793          14.061714   801.954536
min         32.100000      13.100000         172.000000  2700.000000
25%         39.225000      15.600000         190.000000  3550.000000
50%         44.450000      17.300000         197.000000  4050.000000
75%         48.500000      18.700000         213.000000  4750.000000
max         59.600000      21.500000         231.000000  6300.000000

---

Por ejemplo, podemos ver que la longitud promedio del pico de los pingüinos es de 43,9 mm, con una desviación estándar de 5,5 mm. Esto nos da una idea de la conservación en las medidas de longitud del pico de los pingüinos en nuestro conjunto de datos.

🤔🧠🧑‍🏫👩‍🏫

sns.histplot(x=df.flipper_length_mm,hue=df.species,multiple='stack')

aquí se ve porque se ve esa distribución

Utilizando plotly.graph_objects y plotly.subplots podemos hacer sub gráficos de manera muy detallada, ya que plotly.graph_objects te permite jugar con muchísimos parámetros que puedes cambiar dentro de cada gráfica.

import plotly.graph_objects as go
from plotly.subplots import make_subplots

fig = make_subplots(1,3)

flipper_length_mm = go.Histogram(x=df_limpio.flipper_length_mm, name='Longitud Aleta')
bill_depth_mm = go.Histogram(x=df_limpio.bill_depth_mm, name='Profundidad Pico')
bill_length_mm = go.Histogram(x=df_limpio.bill_length_mm, name='Longitud Pico')

fig.append_trace(flipper_length_mm,1,1)
fig.append_trace(bill_depth_mm,1,2)
fig.append_trace(bill_length_mm,1,3)

fig.update_layout(bargap=0.1)

fig.show()

sns.histplot(
data=processed_penguins_df,
x=‘flipper_length_mm’,
binwidth= freedman_diaconis_bindwidth(preprocess_penguins_df.flipper_length_mm),
kde=True

)
plt.axvline(
x=processed_penguins_df.flipper_length_mm.median(),
color=‘red’,
linestyle=‘dashed’,
linewidth=2

)