Tutorial Numpy: Funciones estadísticas

En el contexto de Numpy, las operaciones estadísticas y de reducción son funciones matemáticas que se aplican sobre arrays para sintetizar o reducir la información en un valor representativo. Estas operaciones proporcionan métodos esenciales para el análisis y procesamiento de datos científicos y de ingeniería. 

Aquí, las funciones estadísticas permiten obtener medidas centrales, de dispersión y de forma de los datos en los arrays, mientras que las operaciones de reducción se ocupan de transformar arrays de mayor dimensión en datos de menor dimensión.

Las operaciones estadísticas típicas incluyen:

• Media: un valor promedio de los elementos en un array.
• Mediana: el valor central de los elementos cuando están ordenados.
• Moda: el valor o valores que aparecen con mayor frecuencia.

Las operaciones de reducción, por su parte, comprenden:

• Suma: el total de los elementos en el array.
• Producto: el resultado de multiplicar todos los elementos del array.
• Mínimo y máximo: los valores más pequeño y más grande dentro del array.
• Desviación estándar y varianza: medidas de dispersión que indican cómo se distribuyen los elementos alrededor de la media.
• Percentiles y cuantiles: valores que dividen el array en segmentos porcentuales.

Estas operaciones se implementan en Numpy mediante funciones que pueden actuar sobre todo el array o sobre una dimensión específica (eje). Esto confiere gran flexibilidad y eficiencia a la biblioteca, permitiendo realizar cálculos complejos de manera rápida sobre grandes volúmenes de datos.

Ejemplo de operaciones de reducción en Numpy:

import numpy as np

# Creamos un array de ejemplo
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Media de todos los elementos
mean = np.mean(data)

# Suma por cada columna (eje=0)
sum_columns = np.sum(data, axis=0)

# Desviación estándar por cada fila (eje=1)
std_rows = np.std(data, axis=1)

print("Media:", mean)
print("Suma por columnas:", sum_columns)
print("Desviación estándar por filas:", std_rows)

En resumen, las operaciones estadísticas y de reducción en Numpy son herramientas potentes para resumir y entender la estructura de los datos en arrays, facilitando el análisis numérico y la toma de decisiones basada en datos.

Explicación y uso de media y mediana

La media y la mediana son dos medidas estadísticas que nos permiten entender mejor la distribución de los datos en un array. La media es el promedio de todos los elementos de un array, mientras que la mediana es el valor central cuando los elementos están ordenados.

Para calcular la media en Numpy, utilizamos la función numpy.mean(). Esta función puede aplicarse a todo el array o a lo largo de un eje específico. Por ejemplo, si tenemos un array bidimensional, podemos calcular la media de cada una de las filas o columnas.

Ejemplo de uso de numpy.mean():

import numpy as np

# Creamos un array de ejemplo
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Media de todos los elementos del array
mean_all = np.mean(data)

# Media de cada columna (eje=0)
mean_columns = np.mean(data, axis=0)

# Media de cada fila (eje=1)
mean_rows = np.mean(data, axis=1)

print("Media de todos los elementos:", mean_all)
print("Media por columna:", mean_columns)
print("Media por fila:", mean_rows)

La mediana se calcula utilizando la función numpy.median(). Al igual que con numpy.mean(), podemos calcular la mediana de todo el array o a lo largo de un eje específico.

Ejemplo de uso de numpy.median():

import numpy as np

# Creamos un array de ejemplo
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Mediana de todos los elementos del array
median_all = np.median(data)

# Mediana de cada columna (eje=0)
median_columns = np.median(data, axis=0)

# Mediana de cada fila (eje=1)
median_rows = np.median(data, axis=1)

print("Mediana de todos los elementos:", median_all)
print("Mediana por columna:", median_columns)
print("Mediana por fila:", median_rows)

Para ejemplificar estas funciones, supongamos un array de valores. La media nos da una idea del valor típico que podríamos esperar, mientras que la mediana nos indica el valor que se encuentra en la mitad de la distribución de datos, proporcionando una resistencia a valores atípicos que podrían sesgar la media.

En resumen, numpy.mean() y numpy.median() son herramientas esenciales en Numpy que nos permiten realizar cálculos estadísticos básicos para análisis de datos.

Explicación y uso de moda

La moda es una medida estadística que identifica el o los elementos más frecuentes en un conjunto de datos. En el contexto de los arrays de Numpy, la moda es particularmente útil para entender cuáles valores aparecen con mayor repetición y puede ser indicativa de tendencias o comportamientos comunes en un conjunto de datos.

A diferencia de la media y la mediana, Numpy no proporciona una función directa para calcular la moda. Sin embargo, podemos utilizar la biblioteca Scipy, específicamente la función mode del módulo stats, para calcularla eficientemente.

Ejemplo de uso de mode para encontrar la moda en un array:

import numpy as np
from scipy.stats import mode

# Creamos un array de ejemplo
data = np.array([1, 2, 2, 3, 4, 4, 4, 5, 6])

# Calculamos la moda
moda_result = mode(data)

# El resultado siempre sea tomado como array
mode_value = moda_result.mode if isinstance(moda_result.mode, np.ndarray) else np.array([moda_result.mode])
count_value = moda_result.count if isinstance(moda_result.count, np.ndarray) else np.array([moda_result.count])

print("Moda:", mode_value[0])
print("Frecuencia:", count_value[0])

Este ejemplo muestra cómo obtener la moda y su frecuencia dentro del array. La función mode retorna un objeto que contiene la moda (mode) y la cantidad de veces que esta aparece (count).

La moda es especialmente útil en el análisis de datos categóricos o cualitativos, donde los promedios y medianas pueden no ser aplicables. Por ejemplo, en encuestas de opinión, la moda puede indicar la opción más popular entre varias disponibles.

Explicación y uso de mínimo y máximo e índices de mínimo y máximo

En Numpy, se utilizan las funciones numpy.min() y numpy.max() para obtener el valor mínimo y máximo de un array respectivamente. Estas funciones pueden trabajar a lo largo de todo el array o a lo largo de un eje específico. Además, para obtener los índices de los valores mínimo y máximo, se utilizan las funciones numpy.argmin() y numpy.argmax().

La función numpy.min() se encarga de retornar el valor más pequeño del array, ofreciendo la opción de especificar el eje sobre el cual realizar la operación. De manera similar, numpy.max() retorna el valor más grande del array, también con la capacidad de especificar un eje específico.

Ejemplo de uso de numpy.min() y numpy.max():

import numpy as np

# Creamos un array de ejemplo
data = np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])

# Valor mínimo de todo el array
min_value = np.min(data)

# Valor máximo de todo el array
max_value = np.max(data)

# Valor mínimo por filas (eje=1)
min_rows = np.min(data, axis=1)

# Valor máximo por columnas (eje=0)
max_columns = np.max(data, axis=0)

print("Valor mínimo del array:", min_value)
print("Valor máximo del array:", max_value)
print("Valor mínimo por fila:", min_rows)
print("Valor máximo por columna:", max_columns)

Para obtener los índices de los valores mínimos y máximos, utilizamos numpy.argmin() y numpy.argmax(), los cuales nos proporcionan la posición en la que se encuentran estos valores dentro del array. Al igual que las funciones anteriores, estas también permiten especificar un eje a lo largo del cual se deben buscar los valores.

Ejemplo de uso de numpy.argmin() y numpy.argmax():

# Índice del valor mínimo en todo el array
min_index = np.argmin(data)

# Índice del valor máximo en todo el array
max_index = np.argmax(data)

# Índices del valor mínimo por filas (eje=1)
min_rows_index = np.argmin(data, axis=1)

# Índices del valor máximo por columnas (eje=0)
max_columns_index = np.argmax(data, axis=0)

print("Índice del valor mínimo del array:", min_index)
print("Índice del valor máximo del array:", max_index)
print("Índices del valor mínimo por fila:", min_rows_index)
print("Índices del valor máximo por columna:", max_columns_index)

En el ejemplo anterior, min_value y max_value nos dan los valores mínimo y máximo respectivamente, mientras que min_index y max_index nos proporcionan los índices del array en los que estos valores se encuentran. Las funciones np.min(), np.max(), np.argmin() y np.argmax() son esenciales cuando necesitas identificar extremos en datos y sirven de base para muchas operaciones estadísticas y de reducción dentro de los arrays en Numpy.

Explicación y uso de agregación con suma y suma acumulativa y con producto y producto acumulativo

En Numpy, además de las operaciones básicas de suma y producto, también se pueden realizar sumas y productos acumulativos a lo largo de un array o de un eje específico, lo que nos permite obtener resultados intermedios que son útiles en diversas aplicaciones de análisis de datos.

La función numpy.sum() se utiliza para calcular la suma de todos los elementos en un array o a lo largo de un eje determinado. Un ejemplo de su uso es el siguiente:

import numpy as np

# Creamos un array de ejemplo
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Suma de todos los elementos del array
sum_all = np.sum(data)

# Suma de los elementos por columna (eje=0)
sum_columns = np.sum(data, axis=0)

# Suma de los elementos por fila (eje=1)
sum_rows = np.sum(data, axis=1)

print("Suma de todos los elementos:", sum_all)
print("Suma por columna:", sum_columns)
print("Suma por fila:", sum_rows)

Para realizar una suma acumulativa, Numpy ofrece la función numpy.cumsum(), que devuelve un array donde cada elemento es la suma de todos los elementos previos a lo largo de un eje específico. Por ejemplo:

# Suma acumulativa de todos los elementos del array aplanado
cumsum_all = np.cumsum(data)

# Suma acumulativa por columnas (eje=0)
cumsum_columns = np.cumsum(data, axis=0)

# Suma acumulativa por filas (eje=1)
cumsum_rows = np.cumsum(data, axis=1)

print("Suma acumulativa de todos los elementos:", cumsum_all)
print("Suma acumulativa por columnas:", cumsum_columns)
print("Suma acumulativa por filas:", cumsum_rows)

De manera similar, para calcular el producto de todos los elementos, se utiliza la función numpy.prod(), que puede aplicarse sobre todo el array o a lo largo de un eje específico:

# Producto de todos los elementos del array
prod_all = np.prod(data)

# Producto de los elementos por columna (eje=0)
prod_columns = np.prod(data, axis=0)

# Producto de los elementos por fila (eje=1)
prod_rows = np.prod(data, axis=1)

print("Producto de todos los elementos:", prod_all)
print("Producto por columnas:", prod_columns)
print("Producto por filas:", prod_rows)

Para obtener el producto acumulativo, se utiliza numpy.cumprod(), que devuelve un array en el que cada elemento es el producto de todos los elementos previos a lo largo de un eje específico:

# Producto acumulativo de todos los elementos del array aplanado
cumprod_all = np.cumprod(data)

# Producto acumulativo por columnas (eje=0)
cumprod_columns = np.cumprod(data, axis=0)

# Producto acumulativo por filas (eje=1)
cumprod_rows = np.cumprod(data, axis=1)

print("Producto acumulativo de todos los elementos:", cumprod_all)
print("Producto acumulativo por columnas:", cumprod_columns)
print("Producto acumulativo por filas:", cumprod_rows)

Las funciones numpy.sum(), numpy.cumsum(), numpy.prod() y numpy.cumprod() son esenciales para operaciones de agregación, tanto en el análisis de series temporales como en muchos otros contextos donde se necesitan cálculos acumulativos o totales. Estas operaciones permiten explorar y entender los datos en profundidad, facilitando la toma de decisiones basada en resultados precisos.

Explicación y uso de percentiles

En el contexto de Numpy, un percentil es una medida que indica el valor por debajo del cual cae un cierto porcentaje de los datos en un array. Esta métrica es ampliamente utilizada en análisis estadístico para entender la distribución de los datos y es útil en diversas aplicaciones, como estadísticas descriptivas, análisis de rendimiento, y más.

Para calcular percentiles en Numpy, se usa la función numpy.percentile(). Esta función toma dos parámetros fundamentales: el array de entrada y el percentil que se desea calcular. Además, ofrece la posibilidad de especificar el eje (axis) a lo largo del cual se realizará la operación y el método de interpolación (interpolation) para los casos donde el percentil cae entre dos datos.

Ejemplo de uso de numpy.percentile():

import numpy as np

# Creamos un array de ejemplo
data = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])

# Percentil 25 de todo el array
percentile_25_all = np.percentile(data, 25)

# Percentil 50 (mediana) por columnas (eje=0)
percentile_50_columns = np.percentile(data, 50, axis=0)

# Percentil 90 por filas (eje=1)
percentile_90_rows = np.percentile(data, 90, axis=1)

print("Percentil 25 de todos los elementos:", percentile_25_all)
print("Percentil 50 (mediana) por columnas:", percentile_50_columns)
print("Percentil 90 por filas:", percentile_90_rows)

En el ejemplo anterior, hemos calculado el percentil 25 de todos los elementos del array, el percentil 50 (que es la mediana) a lo largo de las columnas, y el percentil 90 a lo largo de las filas. La función numpy.percentile() facilita la realización de estos cálculos sobre grandes cantidades de datos de manera eficiente.

La función numpy.percentile() permite ajustes adicionales mediante el parámetro method (anteriormente conocido como interpolation). Este parámetro define cómo se interpola en caso de que el percentil no corresponda exactamente a un índice del array. Los métodos disponibles incluyen:

• linear (por defecto): Calcula usando una interpolación lineal entre los dos valores más cercanos.
• lower: Usa el valor más bajo de los dos valores más cercanos.
• higher: Usa el valor más alto de los dos valores más cercanos.
• midpoint: Usa el promedio de los dos valores más cercanos.
• nearest: Usa el valor más cercano.

Ejemplo de uso del parámetro method:

# Percentil 50 usando diferentes métodos de interpolación
percentile_50_linear = np.percentile(data, 50, method='linear')
percentile_50_lower = np.percentile(data, 50, method='lower')
percentile_50_higher = np.percentile(data, 50, method='higher')
percentile_50_midpoint = np.percentile(data, 50, method='midpoint')
percentile_50_nearest = np.percentile(data, 50, method='nearest')

print("Percentil 50 (linear):", percentile_50_linear)
print("Percentil 50 (lower):", percentile_50_lower)
print("Percentil 50 (higher):", percentile_50_higher)
print("Percentil 50 (midpoint):", percentile_50_midpoint)
print("Percentil 50 (nearest):", percentile_50_nearest)

Los percentiles pueden ser una herramienta muy poderosa para analizar distribuciones de datos. Por ejemplo, en el contexto de análisis de rendimiento, uno podría usar el percentil 90 para identificar si un cierto nivel de rendimiento se logra al menos el 90% de las veces.

En resumen, la función numpy.percentile() ofrece una manera flexible y eficiente de calcular percentiles en arrays de Numpy, ofreciendo parámetros para la personalización y adaptación a diferentes necesidades analíticas.

Explicación y uso de cuantiles y rango intercuartílico

Los cuantiles son valores que dividen los datos en partes iguales, y el rango intercuartílico (IQR, por sus siglas en inglés) es una medida de la dispersión que comprende el intervalo entre el primer y el tercer cuartil, es decir, el 25% y el 75% de los datos. En Numpy, estas métricas son útiles para comprender la distribución y la variabilidad de nuestros datos.

Para calcular los cuantiles en Numpy, se utiliza la función numpy.quantile(). Esta función toma dos parámetros principales: el array de entrada y la lista de cuantiles que se desean calcular, donde cada cuantil se representa como un valor entre 0 y 1. La función también permite especificar el eje (axis) a lo largo del cual se efectuará la operación.

Ejemplo de uso de numpy.quantile():

import numpy as np

# Creamos un array de ejemplo
data = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])

# Cuantiles Q1 (25%), Q2 (50%) y Q3 (75%) de todo el array
q1, q2, q3 = np.quantile(data, [0.25, 0.5, 0.75])

# Cuantiles Q1, Q2 y Q3 por columnas (eje=0)
q1_columns, q2_columns, q3_columns = np.quantile(data, [0.25, 0.5, 0.75], axis=0)

print("Q1 de todos los elementos:", q1)
print("Q2 (mediana) de todos los elementos:", q2)
print("Q3 de todos los elementos:", q3)

print("Q1 por columnas:", q1_columns)
print("Q2 por columnas:", q2_columns)
print("Q3 por columnas:", q3_columns)

Para calcular el rango intercuartílico (IQR), simplemente se debe restar el primer cuartil (Q1) del tercer cuartil (Q3):

# Rango intercuartílico de todo el array
iqr = q3 - q1

print("Rango intercuartílico (IQR):", iqr)

También es posible calcular el rango intercuartílico a lo largo de un eje específico:

# Rango intercuartílico por columnas (eje=0)
iqr_columns = q3_columns - q1_columns

print("Rango intercuartílico por columnas (IQR):", iqr_columns)

La función numpy.quantile() también admite el parámetro method (anteriormente conocido como interpolation) para decidir cómo calcular los cuantiles cuando el percentil no corresponde exactamente a un índice del array. Los métodos posibles son los mismos que para numpy.percentile() como linear, lower, higher, midpoint y nearest.

Ejemplo de uso del parámetro method en numpy.quantile():

# Cuantiles usando el método 'linear' (por defecto)
q1_linear, q2_linear, q3_linear = np.quantile(data, [0.25, 0.5, 0.75], method='linear')

# Cuantiles usando el método 'nearest'
q1_nearest, q2_nearest, q3_nearest = np.quantile(data, [0.25, 0.5, 0.75], method='nearest')

print("Cuantiles usando 'linear':", q1_linear, q2_linear, q3_linear)
print("Cuantiles usando 'nearest':", q1_nearest, q2_nearest, q3_nearest)

El uso de cuantiles y el rango intercuartílico proporciona una manera eficaz de resumir y analizar la dispersión de los datos, especialmente en presencia de valores atípicos. La capacidad de calcular estos valores rápidamente sobre grandes conjuntos de datos mejora considerablemente el análisis estadístico en Python usando Numpy.

Explicación y uso de desviación estándar

La desviación estándar es una medida que indica cuánto se desvían los valores de un dataset respecto a su media. En arrays de Numpy, la desviación estándar se calcula utilizando la función numpy.std(). Esta función puede calcularse tanto a lo largo de un array completo como a lo largo de un eje específico, proporcionando así la flexibilidad necesaria para el análisis de datos multidimensionales.

Por defecto, la función numpy.std() calcula la desviación estándar poblacional, es decir, asume que los datos representan toda la población.

Ejemplo básico de uso de numpy.std():

import numpy as np

# Creamos un array de ejemplo
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])

# Desviación estándar de todos los elementos del array
std_all = np.std(data)

print("Desviación estándar de todos los elementos:", std_all)

También es posible calcular la desviación estándar a lo largo de un eje específico. Esto es particularmente útil en arrays multidimensionales. Por ejemplo, si se quiere calcular la desviación estándar a lo largo de cada columna o fila de una matriz:

import numpy as np

# Creamos un array bidimensional de ejemplo
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Desviación estándar a lo largo de las columnas (eje=0)
std_columns = np.std(data, axis=0)

# Desviación estándar a lo largo de las filas (eje=1)
std_rows = np.std(data, axis=1)

print("Desviación estándar por columnas:", std_columns)
print("Desviación estándar por filas:", std_rows)

En algunas aplicaciones, es común trabajar con muestras en lugar de con población completa. En tales casos, se debe calcular la desviación estándar muestral, donde se utiliza ( N-1 ) en lugar de ( N ) en la fórmula, a fin de obtener una estimación más precisa. Para calcular la desviación estándar muestral, se utiliza el parámetro ddof (grado de libertad) en la función numpy.std():

# Desviación estándar muestral (ddof=1) de todos los elementos del array
std_sample = np.std(data, ddof=1)

print("Desviación estándar muestral:", std_sample)

La función numpy.std() admite otros parámetros opcionales, como dtype para especificar el tipo de datos utilizado en los cálculos, o keepdims para mantener las dimensiones originales del array en el resultado.

Ejemplo de uso avanzado con dtype y keepdims:

# Desviación estándar con dtype=float64 y manteniendo dimensiones originales
std_advanced = np.std(data, axis=0, dtype=np.float64, keepdims=True)

print("Desviación estándar avanzada:", std_advanced)

Las capacidades de numpy.std() facilitan el análisis estadístico detallado, permitiendo a los desarrolladores calcular de manera rápida y precisa la dispersión de datos en arrays multidimensionales. Esta funcionalidad es crucial en numerosos campos como la ciencia de datos, el procesamiento de señales y la ingeniería.

Explicación y uso de varianza

En Numpy, la varianza es una medida que indica el grado de dispersión de los valores de un conjunto de datos respecto a la media. Se calcula como el promedio de las diferencias cuadráticas respecto a la media, proporcionando una visión cuantitativa sobre la variabilidad de los datos en un array. La función principal que se utiliza para calcular la varianza en Numpy es numpy.var().

Para calcular la varianza de todos los elementos en un array, usamos la función numpy.var(). Esta función tiene varias opciones para adaptar los cálculos a necesidades específicas.

Ejemplo básico de uso de numpy.var():

import numpy as np

# Creamos un array de ejemplo
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])

# Varianza de todos los elementos del array
variance_all = np.var(data)

print("Varianza de todos los elementos:", variance_all)

Es posible calcular la varianza a lo largo de un eje específico, lo que es particularmente útil en arrays multidimensionales. Por ejemplo, se puede calcular la varianza a lo largo de cada columna o fila de una matriz:

# Creamos un array bidimensional de ejemplo
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Varianza a lo largo de las columnas (eje=0)
variance_columns = np.var(data, axis=0)

# Varianza a lo largo de las filas (eje=1)
variance_rows = np.var(data, axis=1)

print("Varianza por columnas:", variance_columns)
print("Varianza por filas:", variance_rows)

Al igual que con la desviación estándar, la varianza también puede calcularse asumiendo que los datos son una muestra en lugar de una población completa. En estos casos, la varianza muestral se calcula usando ( N-1 ) en lugar de ( N ) en la fórmula para obtener una estimación más precisa. Esto se logra mediante el uso del parámetro ddof (grado de libertad) en la función numpy.var():

# Varianza muestral (ddof=1) de todos los elementos del array
variance_sample = np.var(data, ddof=1)

print("Varianza muestral:", variance_sample)

La función numpy.var() acepta otros parámetros opcionales, como dtype para especificar el tipo de datos utilizado en los cálculos, y keepdims para mantener las dimensiones originales del array en el resultado.

Ejemplo de uso avanzado con dtype y keepdims:

# Varianza con dtype=float64 y manteniendo dimensiones originales
variance_advanced = np.var(data, axis=0, dtype=np.float64, keepdims=True)

print("Varianza avanzada:", variance_advanced)

La varianza es una herramienta esencial para el análisis estadístico, permitiendo a los desarrolladores y científicos de datos comprender la variabilidad de los datos en arrays multidimensionales. La función numpy.var() facilita la realización de estos cálculos rápidamente y de manera eficiente, lo cual es vital en muchos campos como la ciencia de datos, econometría y análisis de rendimiento.

Explicación y uso de outliers (valores anómalos)

Los outliers, o valores anómalos, son datos que se encuentran significativamente alejados del resto de los datos en un conjunto. Estos valores pueden indicar errores en los datos, variaciones naturales extremas o puntos de interés que merecen una investigación adicional. La detección y tratamiento de outliers es crucial para un análisis de datos preciso, ya que pueden distorsionar resultados y afectar la interpretación de los datos.

En Numpy, no hay una función específica para detectar outliers, pero se pueden identificar utilizando métodos estadísticos comunes, como el rango intercuartílico (IQR) o la desviación estándar.

Detección de outliers usando el rango intercuartílico (IQR)

El IQR es el rango entre el primer cuartil (Q1) y el tercer cuartil (Q3). Los outliers se definen típicamente como aquellos valores que están por debajo de Q1 - 1.5 x IQR o por encima de Q3 + 1.5 x IQR.

Ejemplo de detección de outliers utilizando IQR:

import numpy as np

# Creamos un array de ejemplo
data = np.array([10, 12, 14, 15, 18, 21, 22, 23, 24, 29, 100])

# Calculamos Q1 y Q3
Q1 = np.percentile(data, 25)
Q3 = np.percentile(data, 75)
IQR = Q3 - Q1

# Definimos los límites para detectar outliers
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# Identificamos los outliers
outliers = data[(data < lower_bound) | (data > upper_bound)]

print("Outliers:", outliers)

En este ejemplo, el resultado Outliers: [100] indica que el valor 100 ha sido identificado como un outlier porque se encuentra significativamente alejado del resto de los valores en el array data. Este valor es atípico y puede representar un error, una variación natural extrema o un punto de interés especial.

Detección de outliers usando la desviación estándar

Otro método común es usar la desviación estándar para identificar outliers. Se considera que un valor es un outlier si se encuentra a más de 3 desviaciones estándar de la media.

Ejemplo de detección de outliers utilizando desviación estándar:

# Calculamos la media y la desviación estándar
mean = np.mean(data)
std_dev = np.std(data)

# Definimos los límites para detectar outliers
lower_bound = mean - 3 * std_dev
upper_bound = mean + 3 * std_dev

# Identificamos los outliers
outliers = data[(data < lower_bound) | (data > upper_bound)]

print("Outliers:", outliers)

Tratamiento de outliers

Una vez identificados los outliers, hay varias estrategias para tratarlos, dependiendo del contexto del análisis y la naturaleza de los datos:

1. Eliminar los outliers: Si los outliers son errores claros o no representan casos relevantes, pueden eliminarse del dataset.
2. Transformar los datos: Aplicar transformaciones, como logaritmos, puede reducir el impacto de outliers.
3. Imputar valores: Reemplazar outliers con valores más representativos, como la mediana o media del dataset.
4. Análisis separado: Tratar los outliers por separado para entender su causa y su impacto.

El manejo adecuado de los outliers es fundamental para garantizar la calidad y la precisión del análisis de datos, permitiendo así obtener conclusiones más fiables y útiles.