Doble argsort para rangos de arrays de NumPy

La Lógica Matemática Detrás del Doble Argsort para la Clasificación de Arrays en NumPy

Aplicar np.argsort(np.argsort(x)) dos veces produce los rangos de los elementos en un array sin funciones especializadas. Esto funciona para arrays con valores únicos y tiene en cuenta las posiciones originales con duplicados. A diferencia de scipy.stats.rankdata, que comienza en 1, el doble argsort utiliza indexación basada en cero y es equivalente al enfoque method='ordinal'.

Considera el array a = [13, 0, 47, 52, 27]. La versión ordenada es s = [0, 13, 27, 47, 52]. El primer argsort da los índices [1, 0, 4, 2, 3], el segundo produce los rangos [1, 0, 3, 4, 2], coincidiendo con rankdata(a, method='ordinal') - 1.

import numpy as np
from scipy.stats import rankdata

a = np.array([13, 0, 47, 52, 27])
print("a:", a)
s = np.sort(a)
print("s = sort(a):", s)
m = np.argsort(a)
print("m = argsort(a):", m)
p = np.argsort(m)
print("p = argsort(argsort(a)):", p)
r = rankdata(a, method="ordinal") - 1
print("r = rank(a):", r)

Salida:

a: [13 0 47 52 27]
s = sort(a): [0 13 27 47 52]
m = argsort(a): [1 0 4 2 3]
p = argsort(argsort(a)): [1 0 3 4 2]
r = rank(a): [1 0 3 4 2]

Formalizando el Problema

Define:

• a = (a_1, ..., a_N) — el array original.
• s = (s_1, ..., s_N) — ordenado en orden ascendente.
• m = argsort(a) — índices donde a_{m_i} = s_i.
• p = argsort(m) — el doble argsort.
• r = (r_1, ..., r_N) — rangos donde s_{r_i} = a_i.

Objetivo: Demostrar p_i = r_i para todo i.

Con duplicados, el doble argsort asigna un rango más bajo al elemento con el índice original más pequeño, asegurando rangos únicos.

Demostración Paso a Paso

• El array m es una permutación de {1, ..., N}, todos los m_i son únicos: m_i ≠ m_k para i ≠ k.

• p = argsort(m) ordena m en orden ascendente: m_{p_1} < m_{p_2} < ... < m_{p_N}, ya que las igualdades son imposibles. Por lo tanto, m_{p_i} = i para todo i.

• De la propiedad de argsort: a_{m_i} = s_i. Sustituye i = p_k: a_{m_{p_k}} = s_{p_k}.

• Del paso 2, m_{p_k} = k, así que a_k = s_{p_k}.

• Esto significa que p_k es la posición de a_k en el array ordenado s, es decir, el rango: p_i = r_i.

La demostración confirma la corrección para arrays de cualquier dimensión con la ordenación estable de NumPy.

Aspectos de Aplicación Práctica

• Estabilidad: El argsort de NumPy es estable, por lo que los elementos iguales mantienen su orden de índice.
• Rendimiento: El doble argsort es más rápido que rankdata para arrays grandes sin personalización de método.
• Limitaciones: Funciona solo para arrays reales o enteros; para arrays de cadenas, usa orden lexicográfico.

Lista de escenarios de uso:

• Calcular percentiles en flujos de trabajo de ciencia de datos.
• Clasificar características en modelos de ML antes de la normalización.
• Construir matrices de confusión basadas en rangos predichos.
• Analizar series temporales para identificar extremos locales.

Conclusiones Clave

• El doble argsort(argsort(x)) es equivalente a rangos basados en cero con el método ordinal.
• La demostración se basa en propiedades de permutación y composición de argsort.
• Con duplicados, los rangos son únicos y dependen del orden original.
• Más eficiente que rankdata para casos simples sin parámetros adicionales.
• Adecuado para desarrolladores de nivel medio a senior en tareas de procesamiento de datos.

— Editorial Team