La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

pdist2

Distancia por pares entre dos conjuntos de observaciones

Sintaxis

D = pdist2(X,Y,Distance)

D = pdist2(X,Y,Distance,DistParameter)

D = pdist2(___,Name,Value)

[D,I] = pdist2(___)

Descripción

D = pdist2(X,Y,Distance) devuelve la distancia entre cada par de observaciones en X e Y usando la métrica especificada por Distance.

D = pdist2(X,Y,Distance,DistParameter) devuelve la distancia usando la métrica especificada por Distance y DistParameter. Puede especificar DistParameter solo cuando Distance sea 'seuclidean', 'minkowski' o 'mahalanobis'.

D = pdist2(___,Name,Value), para cualquier argumento previo, modifica el cálculo usando parámetros de nombre-valor. Por ejemplo:

• D = pdist2(X,Y,Distance,'Smallest',K) calcula la distancia usando la métrica especificada por Distance y devuelve las K distancias entre pares más pequeñas hasta las observaciones en X para cada observación en Y en orden ascendente.

• D = pdist2(X,Y,Distance,DistParameter,'Largest',K) calcula la distancia usando la métrica especificada por Distance y DistParameter y devuelve las K distancias entre pares más grandes en orden descendente.

[D,I] = pdist2(___) también devuelve la matriz I. La matriz I contiene los índices de las observaciones en X correspondientes a las distancias en D. Debe especificar Smallest o Largest para devolver I.

Ejemplos

Calcular la distancia euclidiana

Cree dos matrices con tres observaciones y dos variables.

rng('default') % For reproducibility
X = rand(3,2);
Y = rand(3,2);

Calcule la distancia euclidiana. El valor predeterminado del argumento de entrada Distance es 'euclidean'. Cuando se calcula la distancia euclidiana sin utilizar un argumento de par nombre-valor, no es necesario especificar Distance.

D = pdist2(X,Y)

D = 3×3

    0.5387    0.8018    0.1538
    0.7100    0.5951    0.3422
    0.8805    0.4242    1.2050

D(i,j) corresponde a la distancia entre pares entre la observación i en X y la observación j en Y.

Calcular la distancia de Minkowski

Cree dos matrices con tres observaciones y dos variables.

rng('default') % For reproducibility
X = rand(3,2);
Y = rand(3,2);

Calcule la distancia de Minkowski con el exponente predeterminado 2.

D1 = pdist2(X,Y,'minkowski')

D1 = 3×3

    0.5387    0.8018    0.1538
    0.7100    0.5951    0.3422
    0.8805    0.4242    1.2050

Calcule la distancia de Minkowski con un exponente de 1, que es igual a la distancia Manhattan.

D2 = pdist2(X,Y,'minkowski',1)

D2 = 3×3

    0.5877    1.0236    0.2000
    0.9598    0.8337    0.3899
    1.0189    0.4800    1.7036

D3 = pdist2(X,Y,'cityblock')

D3 = 3×3

    0.5877    1.0236    0.2000
    0.9598    0.8337    0.3899
    1.0189    0.4800    1.7036

Encontrar las dos distancias entre pares más pequeñas

Cree dos matrices con tres observaciones y dos variables.

rng('default') % For reproducibility
X = rand(3,2);
Y = rand(3,2);

Encuentre las dos distancias euclidianas entre pares más pequeñas a las observaciones en X para cada observación en Y.

[D,I] = pdist2(X,Y,'euclidean','Smallest',2)

D = 2×3

    0.5387    0.4242    0.1538
    0.7100    0.5951    0.3422

I = 2×3

     1     3     1
     2     2     2

Para cada observación en Y, pdist2 encuentra las dos distancias más pequeñas calculando y comparando los valores de las distancias con todas las observaciones en X. Después, la función ordena las distancias en cada columna de D en orden ascendente. I contiene los índices de las observaciones en X correspondientes a las distancias en D.

Acelerar el cálculo de la distancia usando la distancia fasteuclidean

Cree dos matrices grandes de puntos y, luego, mida el tiempo utilizado por pdist2 con la métrica de distancia predeterminada "euclidean".

rng default % For reproducibility
N = 10000;
X = randn(N,1000);
Y = randn(N,1000);
D = pdist2(X,Y); % Warm up function for more reliable timing information
tic
D = pdist2(X,Y);
standard = toc

standard = 7.8404

A continuación, mida el tiempo utilizado por pdist2 con la métrica de distancia "fasteuclidean". Especifique un tamaño de caché de 100.

D = pdist2(X,Y,"fasteuclidean",CacheSize=100); % Warm up function
tic
D2 = pdist2(X,Y,"fasteuclidean",CacheSize=100);
accelerated = toc

accelerated = 1.4593

Evalúe por qué factor es más rápido el cálculo acelerado en comparación con el estándar.

standard/accelerated

ans = 5.3726

La versión acelerada es más de dos veces más rápida en este ejemplo.

Calcular la distancia por pares con elementos faltantes usando una función de distancia personalizada

Establezca una función de distancia personalizada que ignore las coordenadas con valores NaN y calcule la distancia por pares usando esa función.

Cree dos matrices con tres observaciones y tres variables.

rng('default') % For reproducibility
X = rand(3,3)
Y = [X(:,1:2) rand(3,1)]

X =

    0.8147    0.9134    0.2785
    0.9058    0.6324    0.5469
    0.1270    0.0975    0.9575


Y =

    0.8147    0.9134    0.9649
    0.9058    0.6324    0.1576
    0.1270    0.0975    0.9706

Las primeras dos columnas de X e Y son idénticas. Supongamos que falta X(1,1).

X(1,1) = NaN

X =

       NaN    0.9134    0.2785
    0.9058    0.6324    0.5469
    0.1270    0.0975    0.9575

Calcule la distancia de Hamming.

D1 = pdist2(X,Y,'hamming')

D1 =

       NaN       NaN       NaN
    1.0000    0.3333    1.0000
    1.0000    1.0000    0.3333

Si la observación i en X o la observación j en Y contiene valores NaN, la función pdist2 devuelve NaN para la distancia entre pares entre i y j. Por lo tanto, D1(1,1), D1(1,2) y D1(1,3) son valores NaN.

Establezca una función de distancia personalizada nanhamdist que ignore las coordenadas con valores NaN y calcule la distancia de Hamming. Cuando trabaja con un número grande de observaciones, puede calcular la distancia con más rapidez creando un bucle que recorra todas las coordenadas de los datos.

function D2 = nanhamdist(XI,XJ)  
%NANHAMDIST Hamming distance ignoring coordinates with NaNs
[m,p] = size(XJ);
nesum = zeros(m,1);
pstar = zeros(m,1);
for q = 1:p
    notnan = ~(isnan(XI(q)) | isnan(XJ(:,q)));
    nesum = nesum + ((XI(q) ~= XJ(:,q)) & notnan);
    pstar = pstar + notnan;
end
D2 = nesum./pstar; 

Calcule la distancia con nanhamdist pasando el identificador de la función como un argumento de entrada de pdist2.

D2 = pdist2(X,Y,@nanhamdist)

D2 =

    0.5000    1.0000    1.0000
    1.0000    0.3333    1.0000
    1.0000    1.0000    0.3333

Asignar nuevos datos a grupos existentes y generar código C/C++

kmeans lleva a cabo agrupamiento de k-medias para dividir datos en k grupos. Cuando tenga un nuevo conjunto de datos que agrupar, puede crear nuevos grupos que incluyan los datos existentes y los nuevos datos utilizando kmeans. La función kmeans es compatible con la generación de código C/C++, de modo que puede generar código que acepte los datos de entrenamiento, devuelva los resultados del agrupamiento y, después, implemente el código en un dispositivo. En este flujo de trabajo, debe pasar los datos de entrenamiento, que pueden tener un tamaño considerable. Para ahorrar memoria en el dispositivo, puede separar el entrenamiento y la predicción por uso de kmeans y pdist2, respectivamente.

Utilice kmeans para crear grupos en MATLAB® y utilice pdist2 en el código generado para asignar nuevos datos a grupos existentes. Para la generación de código, defina una función de punto de entrada que acepte las posiciones de los centroides de los grupos y el nuevo conjunto de datos, y devuelva el índice del grupo más cercano. Después, genere código para la función de punto de entrada.

Generar código C/C++ requiere MATLAB® Coder™.

Llevar a cabo agrupamiento de k-medias

Genere un conjunto de datos de entrenamiento con tres distribuciones.

rng('default') % For reproducibility
X = [randn(100,2)*0.75+ones(100,2);
    randn(100,2)*0.5-ones(100,2);
    randn(100,2)*0.75];

Divida los datos de entrenamiento en tres grupos con kmeans.

[idx,C] = kmeans(X,3);

Represente los grupos y sus centroides.

figure
gscatter(X(:,1),X(:,2),idx,'bgm')
hold on
plot(C(:,1),C(:,2),'kx')
legend('Cluster 1','Cluster 2','Cluster 3','Cluster Centroid')

Asignar nuevos datos a grupos existentes

Genere un conjunto de datos de prueba.

Xtest = [randn(10,2)*0.75+ones(10,2);
    randn(10,2)*0.5-ones(10,2);
    randn(10,2)*0.75];

Clasifique el conjunto de datos de prueba usando los grupos existentes. Encuentre el centroide más cercano de cada punto de datos de prueba con pdist2.

[~,idx_test] = pdist2(C,Xtest,'euclidean','Smallest',1);

Represente los datos de prueba y etiquete los datos de prueba con idx_test utilizando gscatter.

gscatter(Xtest(:,1),Xtest(:,2),idx_test,'bgm','ooo')
legend('Cluster 1','Cluster 2','Cluster 3','Cluster Centroid', ...
    'Data classified to Cluster 1','Data classified to Cluster 2', ...
    'Data classified to Cluster 3')

Generar código

Genere código C que asigne nuevos datos a los grupos existentes. Tenga en cuenta que generar código C/C++ requiere MATLAB® Coder™.

Defina una función de punto de entrada llamada findNearestCentroid que acepte las posiciones de los centroides y nuevos datos, y encuentre el grupo más cercano con pdist2.

Añada la directiva del compilador (o pragma) %#codegen a la función de punto de entrada después de la firma de la función para indicar que intenta generar código para el algoritmo de MATLAB. Añadir esta directiva instruye al analizador de código de MATLAB para ayudarle a diagnosticar y arreglar brechas que provocarían errores durante la generación de código.

type findNearestCentroid % Display contents of findNearestCentroid.m

function idx = findNearestCentroid(C,X) %#codegen
[~,idx] = pdist2(C,X,'euclidean','Smallest',1); % Find the nearest centroid

Nota: si hace clic en el botón ubicado en la zona superior derecha de esta página y abre este ejemplo en MATLAB®, MATLAB® abrirá la carpeta de ejemplo. Esta carpeta incluye el archivo de función de punto de entrada.

Genere código mediante codegen (MATLAB Coder). Dado que C y C++ son lenguajes de tipado estático, debe determinar las propiedades de todas las variables de la función de entrada en tiempo de compilación. Para especificar los tipos de datos y el tamaño de arreglo de las entradas de findNearestCentroid, pase una expresión de MATLAB que represente el conjunto de valores con un tipo de datos y un tamaño de arreglo determinado con la opción -args. Para obtener más detalles, consulte Specify Variable-Size Arguments for Code Generation.

codegen findNearestCentroid -args {C,Xtest}

Code generation successful.

codegen genera la función MEX de findNearestCentroid_mex con una extensión dependiente de la plataforma.

Compruebe el código generado.

myIndx = findNearestCentroid(C,Xtest);
myIndex_mex = findNearestCentroid_mex(C,Xtest);
verifyMEX = isequal(idx_test,myIndx,myIndex_mex)

verifyMEX = logical
   1

isequal devuelve una lógica 1 (true), que implica que todas las entradas son iguales. La comparación confirma que la función pdist2, la función findNearestCentroid y la función MEX vuelven al mismo índice.

También puede generar código optimizado CUDA® con GPU Coder™.

cfg = coder.gpuConfig('mex');
codegen -config cfg findNearestCentroid -args {C,Xtest}

Para obtener más información sobre generación de código, consulte General Code Generation Workflow. Para obtener más información sobre GPU coder, consulte Get Started with GPU Coder (GPU Coder) y Supported Functions (GPU Coder).

Argumentos de entrada

X,Y — Datos de entrada

matriz numérica

Datos de entrada, especificados como matriz numérica. X es una matriz de mx por n e Y es una matriz de my por n. Las filas corresponden a observaciones individuales, mientras que las columnas corresponden a variables individuales.

Tipos de datos: single | double

Distance — Métrica de distancia

vector de caracteres | escalar de cadena | identificador de función

Métrica de distancia, especificada como un vector de caracteres, un escalar de cadena o un identificador de función, tal y como se describe en la tabla siguiente.

Valor	Descripción
'euclidean'	Distancia euclidiana (valor predeterminado)
'squaredeuclidean'	Distancia euclidiana cuadrada. (Esta opción solo se ofrece para mejorar la eficiencia. No resuelve la desigualdad triangular).
'seuclidean'	Distancia euclidiana estandarizada. Cada diferencia de las coordenadas entre las observaciones se escala dividiendo por el elemento correspondiente de la desviación estándar, S = std(X,'omitnan'). Use DistParameter para especificar un valor distinto de S.
'fasteuclidean'	Distancia euclidiana calculada utilizando un algoritmo alternativo que ahorra tiempo cuando el número de predictores es al menos 10. En algunos casos, este algoritmo más rápido puede reducir la precisión. Los algoritmos que empiezan con 'fast' no admiten datos dispersos. Para obtener más detalles, consulte Algoritmos.
'fastsquaredeuclidean'	Distancia euclidiana cuadrada calculada utilizando un algoritmo alternativo que ahorra tiempo cuando el número de predictores es al menos 10. En algunos casos, este algoritmo más rápido puede reducir la precisión. Los algoritmos que empiezan con 'fast' no admiten datos dispersos. Para obtener más detalles, consulte Algoritmos.
'fastseuclidean'	Distancia euclidiana estandarizada calculada utilizando un algoritmo alternativo que ahorra tiempo cuando el número de predictores es al menos 10. En algunos casos, este algoritmo más rápido puede reducir la precisión. Los algoritmos que empiezan con 'fast' no admiten datos dispersos. Para obtener más detalles, consulte Algoritmos.
'mahalanobis'	Distancia de Mahalanobis, calculada usando la covarianza de muestra de X, C = cov(X,'omitrows'). Use DistParameter para especificar un valor distinto de C, donde la matriz C es simétrica y definida positiva.
'cityblock'	Distancia Manhattan
'minkowski'	Distancia de Minkowski. El exponente predeterminado es 2. Use DistParameter para especificar un exponente diferente P, donde P es un valor de escalar positivo del exponente.
'chebychev'	Distancia de Chebyshov (diferencia de coordenada máxima)
'cosine'	Uno menos el coseno del ángulo incluido entre puntos (tratados como vectores)
'correlation'	Uno menos la correlación de la muestra entre los puntos (tratados como secuencias de valores)
'hamming'	Distancia de Hamming, que es el porcentaje de coordenadas que difieren
'jaccard'	Uno menos el coeficiente de Jaccard, que es el porcentaje de coordenadas, que no son cero, que difieren
'spearman'	Uno menos la correlación del coeficiente de Spearman entre observaciones (tratadas como secuencias de valores)
@distfun	Identificador de función de la distancia personalizada. Una función de distancia tiene esta forma: function D2 = distfun(ZI,ZJ) % calculation of distance ... donde ZI es un vector de 1 por n que contiene una sola observación. ZJ es una matriz de m2 por n que contiene varias observaciones. distfun debe aceptar una matriz ZJ con un número arbitrario de observaciones. D2 es un vector de distancias de m2 por 1, mientras que D2(k) corresponde a la distancia entre las observaciones ZI y ZJ(k,:). Si sus datos no son dispersos, por lo general, podrá calcular las distancias más rápido usando una métrica de distancia integrada en lugar de un identificador de función.

Para ver las definiciones, consulte Métricas de distancia.

Cuando use 'seuclidean', 'minkowski' o 'mahalanobis', podrá especificar un argumento de entrada adicional DistParameter para controlar estas métricas. También puede usar estas métricas de la misma manera que el resto de métricas con el valor predeterminado de DistParameter.

Ejemplo: 'minkowski'

Tipos de datos: char | string | function_handle

DistParameter — Valores del parámetro de una métrica de distancia

escalar positivo | vector numérico | matriz numérica

Los valores del parámetro de una métrica de distancia, especificados como un escalar positivo, un vector numérico o una matriz numérica. Este argumento solo es válido cuando se especifica Distance como 'seuclidean', 'minkowski' o 'mahalanobis'.

• Si Distance es 'seuclidean', DistParameter es un vector de factores de escalado de cada dimensión, especificado como un vector positivo. El valor predeterminado es std(X,'omitnan').

• Si Distance es 'minkowski', DistParameter es el exponente de la distancia de Minkowski, especificado como un escalar positivo. El valor predeterminado es 2.

• Si Distance es 'mahalanobis', DistParameter es una matriz de covarianzas, especificada cono una matriz numérica. El valor predeterminado es cov(X,'omitrows'). DistParameter debe ser simétrica y definida positiva.

Ejemplo: 'minkowski',3

Tipos de datos: single | double

Argumentos de par nombre-valor

Especifique pares de argumentos opcionales Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos nombre-valor deben aparecer después de otros argumentos, pero el orden de los pares no importa.

En versiones anteriores a R2021a, use comas para separar cada nombre y valor y encierre Name entre comillas.

Ejemplo: 'Smallest',K o 'Largest',K. No puede utilizar 'Smallest' y 'Largest' a la vez.

CacheSize — Tamaño de la matriz de Gram en megabytes

1e3 (predeterminado) | escalar positivo | 'maximal'

Tamaño de la matriz de Gram en megabytes, especificado como un escalar positivo o 'maximal'. La función pdist2 puede usar CacheSize solo cuando el argumento Distance empiece por fast.

Si 'maximal', pdist2 intenta asignar suficiente memoria para una matriz intermedia entera cuyo tamaño es MX por MY, donde MX es el número de filas de los datos de entrada X y MY es el número de filas de los datos de entrada Y. El tamaño de la caché no tiene que ser lo suficientemente grande para una matriz intermedia completa, pero debe ser al menos lo suficientemente grande como para contener un vector de MX por 1. De lo contrario, pdist2 usa el algoritmo normal para calcular la distancia euclidiana.

Si el argumento de la distancia empieza por fast y CacheSize es demasiado grande o es 'maximal', pdist2 puede intentar asignar una matriz de Gram que supere la memoria disponible. En este caso, MATLAB^® muestra un error.

Ejemplo: CacheSize='maximal'

Tipos de datos: double | char | string

Smallest — Número de distancias más pequeñas que se desea encontrar

entero positivo

Número de distancias más pequeñas que se desea encontrar, especificado como el par separado por comas que consta de 'Smallest' y un entero positivo. Si especifica 'Smallest', pdist2 ordena las distancias en cada columna de D en orden ascendente. Solo puede usar uno de los argumentos Smallest y Largest.

Ejemplo: 'Smallest',3

Tipos de datos: single | double

Largest — Número de distancias más grandes que se desea encontrar

entero positivo

Número de distancias más grandes que se desea encontrar, especificado como el par separado por comas que consta de 'Largest' y un entero positivo. Si especifica 'Largest', pdist2 ordena las distancias en cada columna de D en orden descendente. Solo puede usar uno de los argumentos Smallest y Largest.

Ejemplo: 'Largest',3

Tipos de datos: single | double

Argumentos de salida

D — Distancias entre pares

matriz numérica

Distancias entre pares, devueltas como matriz numérica.

Si no especifica 'Smallest' o 'Largest', D es una matriz de mx por my, donde mx y my son el número de observaciones en X e Y, respectivamente. D(i,j) es la distancia entre la observación i en X y la observación j en Y. Si la observación i en X o la observación j en Y contiene valores NaN, D(i,j) es NaN para las funciones de distancia integradas.

Si especifica 'Smallest' o 'Largest' como K, D es una matriz de K por my. D contiene las distancias entre pares más pequeñas de K o más grandes de K hasta las observaciones en X para cada observación en Y. Para cada observación en Y, pdist2 encuentra las K distancias más pequeñas o más grandes calculando y comparando los valores de las distancias con todas las observaciones en X. Si K es mayor que mx, pdist2 devuelve una matriz de mx por my.

I — Índice de ordenación

matriz de enteros positivos

Índice de ordenación, devuelto como matriz de enteros positivos. I es del mismo tamaño que D. I contiene los índices de las observaciones en X correspondientes a las distancias en D. Debe especificar Smallest o Largest para devolver I.

Más acerca de

Métricas de distancia

Una métrica de distancia es una función que define la distancia entre dos observaciones. pdist2 admite varias métricas de distancia: distancia euclidiana, distancia euclidiana estandarizada, distancia de Mahalanobis, distancia Manhattan, distancia de Minkowski, distancia de Chebyshov, distancia del coseno, distancia de correlación, distancia de Hamming, distancia de Jaccard y distancia de Spearman.

Si tenemos una matriz de datos de mx por n X, que se trata como vectores fila mx (1 por n) x₁, x₂, ..., x_mx, y una matriz de datos de my por n Y, que se trata como vectores fila my (1 por n) y₁, y₂, ...,y_my, las diferentes distancias entre el vector x_s y y_t se definen de esta manera:

• Distancia euclidiana

  $$d_{st}^2=(x_s-y_t)(x_s-y_t{)}^{\prime }.$$

  La distancia euclidiana es un caso especial de la distancia de Minkowski, donde p = 2.

  Especifique la distancia euclidiana estableciendo el parámetro Distance en 'euclidean'.

• Distancia euclidiana estandarizada

  $$d_{st}^2=(x_s-y_t)V^{-1}(x_s-y_t{)}^{\prime },$$

  donde V es la matriz diagonal de n por n cuyo elemento diagonal número j es (S(j))², donde S es un vector de factores de escalado de cada dimensión.

  Especifique la distancia euclidiana estandarizada estableciendo el parámetro Distance en 'seuclidean'.

• La distancia euclidiana rápida es la misma que la distancia euclidiana, calculada utilizando un algoritmo alternativo que ahorra tiempo cuando el número de predictores es al menos 10. En algunos casos, este algoritmo más rápido puede reducir la precisión. No admite datos dispersos. Consulte Algoritmo de distancia euclidiana rápida.

  Especifique la distancia euclidiana rápida estableciendo el parámetro Distance en 'fasteuclidean'.

• La distancia euclidiana rápida estandarizada es la misma que la distancia euclidiana estandarizada, calculada utilizando un algoritmo alternativo que ahorra tiempo cuando el número de predictores es al menos 10. En algunos casos, este algoritmo más rápido puede reducir la precisión. No admite datos dispersos. Consulte Algoritmo de distancia euclidiana rápida.

  Especifique la distancia euclidiana rápida estandarizada estableciendo el parámetro Distance en 'fastseuclidean'.

• Distancia de Mahalanobis

  $$d_{st}^2=(x_s-y_t)C^{-1}(x_s-y_t{)}^{\prime },$$

  donde C es la matriz de covarianzas.

  Especifique la distancia de Mahalanobis estableciendo el parámetro Distance en 'mahalanobis'.

• Distancia Manhattan

  $$d_{st}={\displaystyle \sum _{j=1}^n\left|x_{sj}-y_{tj}\right|}.$$

  La distancia Manhattan es un caso especial de la distancia de Minkowski, donde p = 1.

  Especifique la distancia Manhattan estableciendo el parámetro Distance en 'cityblock'.

• Distancia de Minkowski

  $$d_{st}=\sqrt[p]{{\displaystyle \sum _{j=1}^n{\left|x_{sj}-y_{tj}\right|}^p}}.$$

  Para el caso especial de p = 1, la distancia de Minkowski ofrece la distancia Manhattan. Para el caso especial de p = 2, la distancia de Minkowski ofrece la distancia euclidiana. Para el caso especial de p = ∞, la distancia de Minkowski ofrece la distancia de Chebyshov.

  Especifique la distancia de Minkowski estableciendo el parámetro Distance en 'minkowski'.

• Distancia de Chebyshov

  $$d_{st}={\max }_j\left\{\left|x_{sj}-y_{tj}\right|\right\}.$$

  La distancia de Chebyshov es un caso especial de la distancia de Minkowski, donde p = ∞.

  Especifique la distancia de Chebyshov estableciendo el parámetro Distance en 'chebychev'.

• Distancia del coseno

  $$d_{st}=\left(1-\frac{x_s{y^{\prime }}_t}{\sqrt{\left(x_s{x^{\prime }}_s\right)\left(y_t{y^{\prime }}_t\right)}}\right).$$

  Especifique la distancia del coseno estableciendo el parámetro Distance en 'cosine'.

• Distancia de correlación

  $$d_{st}=1-\frac{\left(x_s-{\overline{x}}_s\right){\left(y_t-{\overline{y}}_t\right)}^{\prime }}{\sqrt{\left(x_s-{\overline{x}}_s\right){\left(x_s-{\overline{x}}_s\right)}^{\prime }}\sqrt{\left(y_t-{\overline{y}}_t\right){\left(y_t-{\overline{y}}_t\right)}^{\prime }}},$$

  donde

  $${\overline{x}}_s=\frac{1}{n}{\displaystyle \sum _j{x}_{sj}}$$

  y

  $${\overline{y}}_t=\frac{1}{n}{\displaystyle \sum _j{y}_{tj}}.$$

  Especifique la distancia de correlación estableciendo el parámetro Distance en 'correlation'.

• La distancia de Hamming es el porcentaje de coordenadas que difieren:

  $$d_{st}=(\#(x_{sj}\ne y_{tj})/n).$$

  Especifique la distancia de Hamming estableciendo el parámetro Distance en 'hamming'.

• La distancia de Jaccard es uno menos el coeficiente de Jaccard, que es el porcentaje de coordenadas que no son cero que difieren:

  $$d_{st}=\frac{\#\left[\left(x_{sj}\ne y_{tj}\right)\cap \left(\left(x_{sj}\ne 0\right)\cup \left(y_{tj}\ne 0\right)\right)\right]}{\#\left[\left(x_{sj}\ne 0\right)\cup \left(y_{tj}\ne 0\right)\right]}.$$

  Especifique la distancia de Jaccard estableciendo el parámetro Distance en 'jaccard'.

• La distancia de Spearman es uno menos la correlación del coeficiente de Spearman entre observaciones (tratadas como secuencias de valores):

  $$d_{st}=1-\frac{\left(r_s-{\overline{r}}_s\right){\left(r_t-{\overline{r}}_t\right)}^{\prime }}{\sqrt{\left(r_s-{\overline{r}}_s\right){\left(r_s-{\overline{r}}_s\right)}^{\prime }}\sqrt{\left(r_t-{\overline{r}}_t\right){\left(r_t-{\overline{r}}_t\right)}^{\prime }}},$$

  donde

  • r_sj es el rango de x_sj llevado a x_1j, x_2j, ...x_mx,j, tal y como lo calcula tiedrank.

  • r_tj es el rango de y_tj llevado a y_1j, y_2j, ...y_my,j, tal y como lo calcula tiedrank.

  • r_s y r_t son los vectores rango basados en coordenadas de x_s y y_t, es decir, r_s = (r_s1, r_s2, ... r_sn) y r_t = (r_t1, r_t2, ... r_tn).

  • $${\overline{r}}_s=\frac{1}{n}{\displaystyle \sum _j{r}_{sj}}=\frac{\left(n+1\right)}{2}$$.

  • $${\overline{r}}_t=\frac{1}{n}{\displaystyle \sum _j{r}_{tj}}=\frac{\left(n+1\right)}{2}$$.

  Especifique la distancia de Spearman estableciendo el parámetro Distance en 'spearman'.

Algoritmos

Algoritmo de distancia euclidiana rápida

Los valores del argumento Distance que empiezan con fast (como 'fasteuclidean' y 'fastseuclidean') calculan distancias euclidianas utilizando un algoritmo que utiliza memoria adicional para ahorrar tiempo de cálculo. Este algoritmo se denomina "Euclidean Distance Matrix Trick" en Albanie [1] y en otros lugares. Las pruebas internas muestran que este algoritmo ahorra tiempo cuando el número de predictores es al menos 10. Los algoritmos que empiezan con 'fast' no admiten datos dispersos.

Para encontrar la matriz D de distancias entre todos los puntos x_i y x_j, donde cada x_i tiene n variables, el algoritmo calcula la distancia usando la línea final de las ecuaciones siguientes:

$$\begin{array}{c}{D}_{i,j}^2=\Vert x_i-x_j{\Vert }^2\\ ={(}^{x_i}(x_i-x_j)\\ =\Vert x_i{\Vert }^2-2x_i^T{x}_j+\Vert x_j{\Vert }^2.\end{array}$$

La matriz $$x_i^T{x}_j$$ de la última línea de las ecuaciones se denominada la matriz de Gram. Cuando se calcula y se utiliza la matriz de Gram en lugar de calcular las distancias al cuadrado mediante el cuadrado y la suma, calcular el conjunto de distancias cuadradas es más rápido, pero ligeramente menos estable numéricamente. Para obtener más información, consulte Albanie [1].

Para almacenar la matriz de Gram, el software usa una caché con el tamaño predeterminado de 1e3 megabytes. Puede establecer el tamaño de la caché utilizando el argumento de nombre-valor CacheSize. Si el valor de CacheSize es demasiado grande o "maximal", pdist2 puede intentar asignar una matriz de Gram que supere la memoria disponible. En este caso, MATLAB muestra un error.

Referencias

[1] Albanie, Samuel. Euclidean Distance Matrix Trick. June, 2019. Available at https://www.robots.ox.ac.uk/%7Ealbanie/notes/Euclidean_distance_trick.pdf.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

Notas y limitaciones de uso:

• La primera entrada X debe ser un arreglo alto. La entrada Y no puede ser un arreglo alto.

Para obtener más información, consulte Arreglos altos.

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• El valor del argumento de entrada de distancia (Distance) debe ser una constante en tiempo de compilación. Por ejemplo, para usar la distancia de Minkowski, incluya coder.Constant('Minkowski') en el valor -args de codegen.

• El valor del argumento de entrada de distancia (Distance) no puede ser una función de distancia personalizada.

• pdist2 no admite la generación de código para cálculos rápidos de distancia euclidiana, lo que significa que no es compatible con las métricas de distancia cuyos nombres empiezan con fast (por ejemplo, 'fasteuclidean').

• Los nombres de los argumentos nombre-valor deben ser constantes en tiempo de compilación. Por ejemplo, para utilizar el argumento de par nombre-valor 'Smallest' en el código generado, incluya {coder.Constant('Smallest'),0} en el valor -args de codegen (MATLAB Coder).

• La posición en el orden para distancias idénticas en el código generado puede diferir del orden en MATLAB debido a la precisión numérica.

• El código generado de pdist2 usa parfor (MATLAB Coder) para crear bucles que se ejecutan en paralelo en las plataformas de núcleos múltiples de memoria compartida compatibles en el código generado. Si su compilador no es compatible con la interfaz de la aplicación de multiprocesamiento abierto (OpenMP) o desactiva la biblioteca OpenMP, MATLAB Coder™ trata los bucles parfor como bucles for. Para encontrar compiladores compatibles, consulte compiladores compatibles. Para desactivar la biblioteca OpenMP, establezca la propiedad EnableOpenMP del objeto de configuración como false. Para obtener más detalles, consulte coder.CodeConfig (MATLAB Coder).

• pdist2 devuelve índices de tipo de valor entero (int32) en código C/C++ independiente generado. Por lo tanto, la función permite un soporte de precisión simple estricto cuando utiliza entradas de precisión simple. Para la generación de código MEX, la función sigue devolviendo índices de precisión doble para igualar el comportamiento de MATLAB.

  Antes de R2020a: pdist2 devuelve índices de precisión doble en código C/C++ independiente generado.

Para obtener más información sobre la generación de código, consulte Introduction to Code Generation y General Code Generation Workflow.

Generación de código de GPU

Genere código CUDA® para GPU NVIDIA® mediante GPU Coder™.

Notas y limitaciones de uso:

• Los argumentos de entrada de distancia compatibles (Distance) para el código CUDA optimizado son 'euclidean', 'squaredeuclidean', 'seuclidean', 'cityblock', 'minkowski', 'chebychev', 'cosine', 'correlation', 'hamming' y 'jaccard'.

• Distance no puede ser una función de distancia personalizada.

• Distance debe ser una constante en tiempo de compilación.

• Los nombres en los argumentos de par nombre-valor deben ser constantes de tiempo de compilación.

• La posición en el orden para distancias idénticas en el código generado puede diferir del orden en MATLAB debido a la precisión numérica.

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

Notas y limitaciones de uso:

• No puede especificar el argumento de entrada Distance como "fasteuclidean", "fastsquaredeuclidean", "fastseuclidean" o una función de distancia personalizada.

Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Historial de versiones

Introducido en R2010a

R2023a: Distancia euclidiana rápida usando una caché

Las métricas de 'fasteuclidean', 'fastseuclidean' y 'fastsquaredeuclidean'Distance aceleran el cálculo de las distancias euclidianas utilizando una caché y un algoritmo diferente (consulte Algoritmos). Establezca el tamaño de la caché utilizando el argumento de nombre-valor CacheSize.

Consulte también

pdist | createns | knnsearch | ExhaustiveSearcher | KDTreeSearcher