No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Varianza y desviación estándar muestral en Python

9/22
Recursos

Aportes 28

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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 ![](

Pequeño aporte: en seaborn ya está cargado el dataset de iris, por lo cual no es necesario sacarlo de la URL. Sólo necesitas la siguiente orden:

df_iris=sns.load_dataset('iris')
no debería haber otro comando para la varianza y desviación estandar muestral? como en la formula hay un n-1 en el denominador.

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 forma más sencilla de completar el ejercicio:

💡 Agregar la varianza al df.describe()

df_describe = df.describe().T   #Transpuesta 
df_describe.insert(3, 'varianza', np.sqrt(df_describe['std']) )
df_describe = df_describe.T

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

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.

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
sep, aqui está el reto `sample.describe()` ![](https://static.platzi.com/media/user_upload/image-cc5e125d-0177-4858-ac6f-2ea71500b2e1.jpg)![](https://static.platzi.com/media/user_upload/image-e02c8ef9-84a6-4709-8212-a6d77a7b006b.jpg)
también pueden cargar el dataset de esta manera iris = sns.load\_dataset('iris')
Dejo mis propias formulas para calcular: 1. Varianza Poblacional: 2. Varianza Muestral 3. Desviación Estandar (para ambas varianzas) ```python def varianza_poblacional(poblacion: list) -> float: promedio = np.mean(poblacion) numerador = sum([(x - promedio)**2 for x in poblacion]) denominador = len(poblacion) return numerador / denominador def varianza_muestral(muestra: list) -> float: promedio = np.mean(muestra) numerador = sum([(x - promedio)**2 for x in muestra]) denominador = len(muestra) - 1 return numerador / denominador def desviacion_estandar(varianza: float) -> float: return varianza ** (1/2) ```def varianza\_poblacional(poblacion: list) -> float:  promedio = np.mean(poblacion)  numerador = sum(\[(x - promedio)\*\*2 for x in poblacion])  denominador = len(poblacion)   return numerador / denominador

Para quienes trabajan con Visual Studio Code, hay un código con distplot que arroja una advertencia. Esta es la forma para eliminarla:

sns.displot(data=iris, kde=True, x='sepal-length', bins=int(180/5), color = 'orange') # Kde nos traza la línea de la distribución
plt.show()

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

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

#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/

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.