sklearn.metrics.pairwise_distances_chunked

sklearn.metrics.pairwise_distances_chunked()

Genera una matriz de distancia trozo a trozo con reducción opcional.

En los casos en los que no es necesario almacenar toda la matriz de distancias por pares a la vez, se utiliza para calcular las distancias por pares en trozos del tamaño de working_memory. Si se da reduce_func, se ejecuta en cada trozo y sus valores de retorno se concatenan en listas, arreglos o matrices dispersas.

Parámetros

Xndarray de forma (n_samples_X, n_samples_X) o (n_samples_X, n_features)

Arreglo de distancias entre pares de muestras, o un arreglo de características. La forma del arreglo debe ser (n_muestras_X, n_muestras_X) si metric=”precomputed” y (n_samples_X, n_features) en caso contrario.

Yndarray de forma (n_samples_Y, n_features), default=None

Un segundo arreglo de características opcional. Sólo se permite si metric != «precomputed».

reduce_funcinvocable, default=None

La función que se aplica a cada trozo de la matriz de distancias, reduciéndola a los valores necesarios. Se llama repetidamente a reduce_func(D_chunk, start), donde D_chunk es un trozo vertical contiguo de la matriz de distancias por pares, empezando por la fila start. Debe devolver uno de los siguientes elementos: None; un arreglo, una lista, o una matriz dispersa de longitud D_chunk.shape[0]; o una tupla de tales objetos. Devolver None es útil para las operaciones, en lugar de las reducciones.

Si es None, pairwise_distances_chunked devuelve un generador de trozos verticales de la matriz de distancias.

metriccadena de caracteres o invocable, default=”euclidean”

La métrica a utilizar cuando se calcula la distancia entre instancias en un arreglo de características. Si la métrica es una cadena de caracteres, debe ser una de las opciones permitidas por scipy.spatial.distance.pdist para su parámetro de métrica, o una métrica listada en pairwise.PAIRWISE_DISTANCE_FUNCTIONS. Si metric es «precomputed», se asume que X es una matriz de distancia. Alternativamente, si la métrica es una función invocable, se llama a cada par de instancias (filas) y se registra el valor resultante. El invocable debe tomar dos arreglos de X como entrada y devolver un valor que indique la distancia entre ellos.

n_jobsentero, default=None

El número de trabajos a utilizar para el cálculo. Esto funciona descomponiendo la matriz por pares en n_jobs partes iguales y calculándolas en paralelo.

None significa 1 a menos que esté en un contexto joblib.parallel_backend. -1 significa que se utilizan todos los procesadores. Consulta Glosario para más detalles.

working_memoryentero, default=None

La memoria máxima buscada para los trozos temporales de la matriz de distancia. Cuando es None (predeterminado), se utiliza el valor de sklearn.get_config()['working_memory'].

`**kwds`parámetros opcionales de palabra clave

Cualquier parámetro adicional se pasa directamente a la función de distancia. Si se utiliza una métrica scipy.spatial.distance, los parámetros siguen siendo dependientes de la métrica. Consulta los documentos scipy para ver ejemplos de uso.

Produce

D_chunk{ndarray, sparse matrix}

Una porción contigua de la matriz de distancia, procesada opcionalmente por reduce_func.

Ejemplos

Sin reduce_func:

>>> import numpy as np
>>> from sklearn.metrics import pairwise_distances_chunked
>>> X = np.random.RandomState(0).rand(5, 3)
>>> D_chunk = next(pairwise_distances_chunked(X))
>>> D_chunk
array([[0.  ..., 0.29..., 0.41..., 0.19..., 0.57...],
       [0.29..., 0.  ..., 0.57..., 0.41..., 0.76...],
       [0.41..., 0.57..., 0.  ..., 0.44..., 0.90...],
       [0.19..., 0.41..., 0.44..., 0.  ..., 0.51...],
       [0.57..., 0.76..., 0.90..., 0.51..., 0.  ...]])

Recuperar todos los vecinos y la distancia media dentro del radio r:

>>> r = .2
>>> def reduce_func(D_chunk, start):
...     neigh = [np.flatnonzero(d < r) for d in D_chunk]
...     avg_dist = (D_chunk * (D_chunk < r)).mean(axis=1)
...     return neigh, avg_dist
>>> gen = pairwise_distances_chunked(X, reduce_func=reduce_func)
>>> neigh, avg_dist = next(gen)
>>> neigh
[array([0, 3]), array([1]), array([2]), array([0, 3]), array([4])]
>>> avg_dist
array([0.039..., 0.        , 0.        , 0.039..., 0.        ])

Donde r está definido por muestra, necesitamos hacer uso de start:

>>> r = [.2, .4, .4, .3, .1]
>>> def reduce_func(D_chunk, start):
...     neigh = [np.flatnonzero(d < r[i])
...              for i, d in enumerate(D_chunk, start)]
...     return neigh
>>> neigh = next(pairwise_distances_chunked(X, reduce_func=reduce_func))
>>> neigh
[array([0, 3]), array([0, 1]), array([2]), array([0, 3]), array([4])]

Forzar generación de filas por fila reduciendo working_memory:

>>> gen = pairwise_distances_chunked(X, reduce_func=reduce_func,
...                                  working_memory=0)
>>> next(gen)
[array([0, 3])]
>>> next(gen)
[array([0, 1])]