Varianza y desviación estándar muestral en Python

al usar std() en pandas, la división la hace por defecto con N-1 (como hay que calcularla para muestras), esto se determina con el parámetro ddof (por defecto es 1), que significa Delta Degrees of Freedom. Pero se puede cambiar escogiendo otro numero entero, y en ese caso quedaría N - ddof
https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.std.html

Hola compañeros,

Les comparto la fórmula de la varianza en Markdown:

Varianza:
$$\sigma^{2} = \frac{\sum_{i=1}^{n} 
  \left(x_{i} - \mu\right)^{2}}
  {N}$$

se vería así:

Saludos.

Una exploración al (kde = kernel density estimation) para las 03 clases mediante ‘hue’ :

• Se usó sns.kdeplot con un poco de estilo y color con los parámetros ( multiple, palette, linewidth)
• Recomiendo explorar las formas distitnas de gráficas distribuciones en seaborn a manera de repaso.
• Ver: Curvas de densidad para tener una mejor noción sobre el kde ( https://www.youtube.com/watch?v=Txlm4ORI4Gs&t=303s )

Coeficiente de variacion ![](

Les dejo el url asi lo pegan

https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data

y el código sería

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'
names = ['sepal-length','sepal-width','petal-length','petal-width','class']
iris = pd.read_csv(url,names = names)
iris.head()

También pueden cargar el dataset desde seaborn:

iris = sns.load_dataset('iris')

La varianza

• Es una medida de la dispersión de los datos alrededor de los medios. Es una medida cuadrática de la desviación estándar. La desviación estándar es la raíz cuadrada de la variación. Ambas medidas pueden calcularse utilizando el módulo statisticsde Python.

• Para calcular la varianza muestral en Python, puede utilizar la función statistics.variance(). Esta función toma un conjunto de datos y devuelve la varianza muestral. Por ejemplo:

Copiar código

import statistics
datos = [4, 7, 9, 11, 13]
varianza = statistics.variance(datos)
print(varianza)

• Para calcular la desviación estándar muestral en Python, puede utilizar la función
  statistics.stdev().

• Esta función toma un conjunto de datos y devuelve la desviación estándar
  muestral. Por ejemplo:

Copiar código

import statistics

datos = [4, 7, 9, 11, 13]
desviacion_estandar = statistics.stdev(datos)
print(desviacion_estandar)

• Es importante mencionar que, en caso de querer calcular la varianza o desviación estandar poblacional, deberías utilizar la función numpy.var()o numpy.std()respectivamente, y pasarle el argumentoddof=0

Copiar código

import numpy as np

datos = [4, 7, 9, 11, 13]
varianza = np.var(datos,ddof=0)
print(varianza)

Copiar código

import numpy as np

datos = [4, 7, 9, 11, 13]
desviacion_estandar = np.std(datos,ddof=0)
print(desviacion_estandar)

• Espero que esta información te sea útil.

Un articulo de como interpretar la varianza y la desviación estándar: Link

def varianza(dfcolumn, name):
    print(f'La varianza de {name} es {dfcolumn.var(ddof=0):.3f}')

def desviacion(dfcolumn, name):
    print(f'La desviacion estandar de {name} es {dfcolumn.std(ddof=0):.3f}')
    
def promedio(dfcolumn, name):
    print(f'El promedio de {name} es {dfcolumn.mean():.3f}')
    
name = 'poblacional sepal-width'
varianza(iris['sepal-width'], name)
desviacion(iris['sepal-width'], name)
promedio(iris['sepal-width'], name)

name = 'muestra 20% sepal-width'
varianza(muestra['sepal-width'], name)
desviacion(muestra['sepal-width'], name)
promedio(muestra['sepal-width'], name)

En este caso la desviación estándar es baja. El coeficiente de variación está muy cercano a 0. Entre más grande sea, más heterogéneos serán los datos.

Una alternativa para importar el dataset es con Seaborn, utilizando el siguiente codigo:

sns.load_dataset('iris')

Si quieren obtener el dataset iris de manera mas rápida pueden usar este comando de la librería de Seaborn

iris = sns.load_dataset("iris")

Les dejo para que comparen ambas opciones y vean que hay un pequeño cambio en los resultados por la forma en la que se realizan las operaciones contra las que ya están estandarizadas

media_sepal_len = (sum( x for x in sepal_len)/sepal_len.count()).round(3)
varianza_sepal_len = (sum( (x - media_sepal_len)**2 for x in sepal_len) / sepal_len.count()).round(3) 
desv_sepal_len = (np.sqrt(varianza_sepal_len)).round(3)

" VS "

media_sepal_len_b = iris['sepal-length'].mean().round(3)
varianza_sepal_len_b = iris['sepal-length'].var().round(3)
desv_sepal_len_b = iris['sepal-length'].std().round(3)


print(f """
  media sepal length: {media_sepal_len}
  varianza sepal length: {varianza_sepal_len}
  desviación estandar: {desv_sepal_len}

  vs

  media sepal length: {media_sepal_len_b}
  varianza sepal length: {varianza_sepal_len_b}
  desviación estandar: {desv_sepal_len_b}
""")

Hola,
Les comparto el código que use para el ejercicio:

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
iris = pd.read_csv(url, names=names)
muestra = iris.sample(frac=0.5)
iris.info()

for column in iris.select_dtypes(include='number').columns:
    print('--- ',column,' ---')
    print('Varianza poblacion: ', iris[column].var(ddof=0))
    print('Desviavion estandar poblacion: ', iris[column].std(ddof=0))
    print('Varianza muestra: ', muestra[column].var())
    print('Desviavion estandar muestra: ', muestra[column].std())
    sns.displot(data=iris, x=column, kind='hist', kde=True, bins=int(180/5), color='orange')

Hice una funcion parecida al .describre()

Función para calcular media, varianza, desviación estándar y coeficiente de variación.

# Dependencias
import numpy as np
import pandas as pd

def calc_var_std(df,columns):

    index = ['MEAN','VAR','STD','C.V']
    
    # Creamos las listas donde guardaremos los resultados
    mean = []
    var = []
    std = []
    coef = []
    
    # Iteramos los valores de las columnas que queremos calcular: media, varianza, dev est, y coef de variacion
    for i in columns:  
        # Guardamos los valores en las listas creadas
        mean.append(df[i].mean())
        var.append(df[i].var())
        std.append(df[i].std())
        coef.append(df[i].std() / df[i].mean())

    # Damos forma a los datos para el dataframe
    data = np.array([mean,var,std,coef])
    data = data.reshape(len(index),len(columns))

    # Creamos el dataframe
    result = pd.DataFrame(columns=columns, data=data, index=index)
    return result

Cargamos dataframes

tips = sns.load_dataset('tips')
el_penguino = sns.load_dataset('penguins')
iris = sns.load_dataset('iris')

# Columns son las variables numericas del dataset que queremos calcular
columns_pinguinein =['bill_length_mm',	'bill_depth_mm',	'flipper_length_mm',	'body_mass_g']
columns_tips = ['total_bill','tip' ,'size']
columns_iris = ['sepal_length','sepal_width', 'petal_length','petal_width']


pingu = calc_var_std(df=el_penguino, columns=columns_pinguinein)
propina = calc_var_std(df=tips, columns=columns_tips)
florecillas = calc_var_std(df=iris, columns=columns_iris)

display('pingui',pingu) 
display('tips',propina)
display('iris',florecillas)

Output

Esta es una guia donde pueden ver acerca de la distribución de la muestra, en nuestro caso de iris tuvimos un 14% aprox en su coeficiente de variación, dentro de todo tenemos una varianza aceptable de los datos 😃

Una lectura para el joven que quiere saber un poco mas uwu

#codigo de la clase

iris["sepal-length"].var() = 0.6856935123042507 

#codigo de la fuente
#en caso de muestra

variance(iris["sepal-length"]) = 0.6856935123042506 

#en caso de población

pvariance(iris["sepal-length"])=0.6811222222222223 

fuente:
https://www.statology.org/sample-population-variance-python/

Acá va un df con los cálculos de la var, la std y el mean para las otras variables

df = pd.DataFrame({'name': ['sepal-width','petal-length','petal-width','sepal-width','petal-length','petal-width'],
'varianza' : [iris['sepal-width'].var(ddof=0),iris['petal-length'].var(ddof=0),iris['petal-width'].var(ddof=0), 
            muestra['sepal-width'].var(), muestra['petal-length'].var(), muestra['petal-width'].var()],
'desv_estandar' : [iris['sepal-width'].std(ddof=0),iris['petal-length'].std(ddof=0),iris['petal-width'].std(ddof=0),
            muestra['sepal-width'].std(),muestra['petal-length'].std(),muestra['petal-width'].std()],
'promedio' : [iris['sepal-width'].mean(),iris['petal-length'].mean(),iris['petal-width'].mean(),
        muestra['sepal-width'].mean(),muestra['petal-length'].mean(),muestra['petal-width'].mean()],
'estudio': ['poblacion','poblacion','poblacion','muestra','muestra','muestra']
})
df

Esta clase hace subir mi AMOR por NumPy y por Seaborn. De verdad que son bibliotecas MARAVILLOSAS.

Se ha hablado del diagrama de Kernel, aqui les dejo un enlace con una explicacion de que es: https://datavizcatalogue.com/ES/metodos/grafico_de_densidad.html#:~:text=Descripción,o período de tiempo continuo.