Recuperar registros similares con funciones de orden superior

Utilice las funciones de orden superior de Data Distiller para resolver una variedad de casos de uso comunes. Para identificar y recuperar registros similares o relacionados de uno o más conjuntos de datos, utilice las funciones de filtro, transformación y reducción que se detallan en esta guía. Para conocer cómo se pueden utilizar las funciones de orden superior para procesar tipos de datos complejos, consulte la documentación sobre cómo administrar matrices y asignar tipos de datos.

Utilice esta guía para identificar productos de diferentes conjuntos de datos que tienen una similitud significativa en sus características o atributos. Esta metodología proporciona soluciones para: deduplicación de datos, vinculación de registros, sistemas de recomendación, recuperación de información y análisis de texto, entre otros.

En el documento se describe el proceso de implementación de una unión de similitud, que a su vez utiliza funciones de orden superior de Data Distiller para calcular la similitud entre conjuntos de datos y filtrarlos en función de atributos seleccionados. Se proporcionan fragmentos de código SQL y explicaciones para cada paso del proceso. El flujo de trabajo implementa las uniones de similitud mediante la medida de similitud de Jaccard y la tokenización mediante funciones de orden superior de Data Distiller. A continuación, estos métodos se utilizan para identificar y recuperar registros similares o relacionados de uno o varios conjuntos de datos en función de una métrica de similitud. Las secciones clave del proceso incluyen: tokenización con funciones de orden superior, combinación cruzada de elementos únicos, cálculo de similitud de Jaccard y filtrado basado en umbrales.

Requisitos previos

Antes de continuar con este documento, debe estar familiarizado con los siguientes conceptos:

Introducción

El SKU de Data Distiller es necesario para realizar las funciones de orden superior en los datos de Adobe Experience Platform. Si no tiene el SKU de Distiller de datos, póngase en contacto con el representante del servicio de atención al cliente de Adobe para obtener más información.

Establecer similitud establish-similarity

Este caso de uso requiere una medida de similitud entre cadenas de texto que se puede utilizar más adelante para establecer un umbral de filtrado. En este ejemplo, los productos de los conjuntos A y B representan las palabras de dos documentos.

La medida de similitud de Jaccard se puede aplicar a una amplia gama de tipos de datos, incluidos datos de texto, datos categóricos y datos binarios. También es adecuado para el procesamiento en tiempo real o por lotes, ya que puede ser computacionalmente eficiente para calcular conjuntos de datos grandes.

Los conjuntos de productos A y B contienen los datos de prueba para este flujo de trabajo.

Para calcular la similitud de Jaccard entre los conjuntos de productos A y B, busque primero la intersección (elementos comunes) de los conjuntos de productos. En este caso, {iPhone, iPad}. A continuación, busque la unión (todos elementos únicos) de ambos conjuntos de productos. En este ejemplo, {iPhone, iPad, iWatch, iPad Mini, Macbook Pro}.

Finalmente, utilice la fórmula de similitud de Jaccard: J(A,B) = A∪B / A∩B para calcular la similitud.

J = Distancia Jaccard
A = conjunto 1
B = conjunto 2

La similitud de Jaccard entre los conjuntos de productos A y B es de 0,4. Esto indica un grado moderado de similitud entre las palabras utilizadas en los dos documentos. Esta similitud entre los dos conjuntos define las columnas de la unión de similitud. Estas columnas representan fragmentos de información o características asociadas con los datos, que se almacenan en una tabla y se utilizan para realizar cálculos de similitud.

Cálculo de Jaccard por pares con similitud de cadena pairwise-similarity

Para comparar con mayor precisión las similitudes entre cadenas, se debe calcular la similitud entre pares. La similitud por pares divide los objetos altamente dimensionales en objetos dimensionales más pequeños para la comparación y el análisis. Para ello, una cadena de texto se divide en partes o unidades más pequeñas (tokens). Pueden ser letras individuales, grupos de letras (como sílabas) o palabras completas. La similitud se calcula para cada par de tokens entre cada elemento del conjunto A y cada elemento del conjunto B. Esta tokenización proporciona una base para comparaciones, relaciones y perspectivas analíticas y computacionales que se extraerán de los datos.

Para el cálculo de similitud por pares, este ejemplo utiliza bi-gramas de caracteres (dos tokens de caracteres) para comparar una coincidencia de similitud entre las cadenas de texto de los productos de los conjuntos A y B. Un bi-grama es una secuencia consecutiva de dos elementos o elementos en una secuencia o texto determinados. Puede generalizar esto a n-gramas.

En este ejemplo se supone que el caso no importa y que no se deben contabilizar los espacios. Según estos criterios, el conjunto A y el conjunto B tienen los siguientes bi-gramas:

Conjunto de productos A bi-gramos:

Conjunto de productos B bi-gramos:

A continuación, calcule el coeficiente de similitud de Jaccard para cada par:

Creación de los datos de prueba con SQL create-test-data

Para crear manualmente una tabla de prueba para los conjuntos de productos, utilice la instrucción SQL CREATE TABLE.

CREATE TABLE featurevector1 AS SELECT *
FROM (
    SELECT 'iPad' AS ProductName
    UNION ALL
    SELECT 'iPhone'
    UNION ALL
    SELECT 'iWatch'
     UNION ALL
    SELECT 'iPad Mini'
);
SELECT * FROM featurevector1;

Las siguientes descripciones proporcionan un desglose del bloque de código SQL anterior:

La instrucción SQL crea una tabla como se muestra a continuación:

Para crear el segundo vector de función, utilice la siguiente instrucción SQL:

CREATE TABLE featurevector2 AS SELECT *
FROM (
    SELECT 'iPad' AS ProductName
    UNION ALL
    SELECT 'iPhone'
    UNION ALL
    SELECT 'Macbook Pro'
);
SELECT * FROM featurevector2;

Transformaciones de datos data-transformation

En este ejemplo, se deben realizar varias acciones para comparar los conjuntos con precisión. En primer lugar, los espacios en blanco se eliminan de los vectores de funciones, ya que se supone que no contribuyen a la medida de similitud. A continuación, los duplicados presentes en el vector de funciones se eliminan a medida que desperdician el procesamiento computacional. A continuación, se extraen tokens de dos caracteres (bi-gramos) de los vectores de funciones. En este ejemplo, se supone que se superponen.

Las siguientes secciones ilustran las transformaciones de datos previas, como la deduplicación, la eliminación de espacios en blanco y la conversión en minúsculas antes de iniciar el proceso de tokenización.

Anulación de duplicación deduplication

A continuación, utilice la cláusula DISTINCT para quitar duplicados. No hay duplicados en este ejemplo, pero es un paso importante para mejorar la precisión de cualquier comparación. A continuación se muestra el SQL necesario:

SELECT DISTINCT(ProductName) AS featurevector1_distinct FROM featurevector1
SELECT DISTINCT(ProductName) AS featurevector2_distinct FROM featurevector2

Eliminación de espacios en blanco whitespace-removal

En la siguiente instrucción SQL, los espacios en blanco se quitan de los vectores de características. La parte replace(ProductName, ' ', '') AS featurevector1_nospaces de la consulta toma la columna ProductName de la tabla featurevector1 y utiliza la función replace(). La función REPLACE reemplaza todas las apariciones de un espacio (" ") con una cadena vacía (""). Esto elimina efectivamente todos los espacios de los valores de ProductName. El resultado se denomina featurevector1_nospaces.

SELECT DISTINCT(ProductName) AS featurevector1_distinct, replace(ProductName, ' ', '') AS featurevector1_nospaces FROM featurevector1

Los resultados se muestran en la tabla siguiente:

La instrucción SQL y sus resultados en el segundo vector de características se ven a continuación:

SELECT DISTINCT(ProductName) AS featurevector2_distinct, replace(ProductName, ' ', '') AS featurevector2_nospaces FROM featurevector2

Convertir a minúsculas lowercase-conversion

A continuación, SQL se mejora para convertir los nombres de producto a minúsculas y eliminar cualquier espacio en blanco. La función lower (lower(...)) se aplica al resultado de la función replace(). La función lower convierte todos los caracteres de los valores ProductName modificados a minúsculas. Esto garantiza que los valores estén en minúsculas independientemente de sus mayúsculas y minúsculas originales.

SELECT DISTINCT(ProductName) AS featurevector1_distinct, lower(replace(ProductName, ' ', '')) AS featurevector1_transform FROM featurevector1;

El resultado de esta instrucción es:

La instrucción SQL y sus resultados en el segundo vector de características se ven a continuación:

SELECT DISTINCT(ProductName) AS featurevector2_distinct, lower(replace(ProductName, ' ', '')) AS featurevector2_transform FROM featurevector2

Extraer tokens mediante SQL tokenization

El siguiente paso es la tokenización o división de texto. La tokenización es el proceso de tomar texto y dividirlo en términos individuales. Normalmente, esto implica dividir frases en palabras. En este ejemplo, las cadenas se desglosan en bi-gramas (y n-gramas de orden superior) mediante la extracción de tokens utilizando funciones SQL como regexp_extract_all. Se deben generar bi-gramas superpuestos para una tokenización eficaz.

SQL se ha mejorado aún más para utilizar regexp_extract_all. regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0) AS tokens: Esta parte de la consulta procesa aún más los valores ProductName modificados creados en el paso anterior. Utiliza la función regexp_extract_all() para extraer todas las subcadenas no superpuestas de uno a dos caracteres de los valores ProductName modificados y en minúsculas. El patrón de expresión regular .{2} coincide con subcadenas de dos caracteres de longitud. A continuación, la parte regexp_extract_all(..., '.{2}', 0) de la función extrae todas las subcadenas coincidentes del texto de entrada.

SELECT DISTINCT(ProductName) AS featurevector1_distinct, lower(replace(ProductName, ' ', '')) AS featurevector1_transform,
regexp_extract_all(lower(replace(ProductName, ' ', '')) , '.{2}', 0) AS tokens
FROM featurevector1;

Los resultados se muestran en la tabla siguiente:

Para mejorar aún más la precisión, SQL debe utilizarse para crear tokens superpuestos. Por ejemplo, a la cadena "iPad" de arriba le falta el token "pa". Para solucionarlo, cambie el operador de búsqueda anticipada (que usa substring) un paso y genere los bi-gramas.

Similar al paso anterior, regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0): extrae secuencias de dos caracteres del nombre de producto modificado, pero comienza desde el segundo carácter utilizando el método substring para crear tokens superpuestos. A continuación, en las líneas 3-7 (array_union(...) AS tokens), la función array_union() combina las matrices de secuencias de dos caracteres obtenidas mediante las dos extracciones de expresiones regulares. Esto garantiza que el resultado contenga tokens únicos de secuencias no superpuestas y superpuestas.

SELECT DISTINCT(ProductName) AS featurevector1_distinct,
       lower(replace(ProductName, ' ', '')) AS featurevector1_transform,
       array_union(
           regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0),
           regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0)
       ) AS tokens
FROM featurevector1;

Los resultados se muestran en la tabla siguiente:

Sin embargo, el uso de substring como solución al problema tiene limitaciones. Si tuviera que crear tokens a partir del texto basados en tri-gramas (tres caracteres), se requeriría el uso de dos substrings para mirar hacia adelante dos veces y obtener los turnos requeridos. Para hacer 10 gramos, necesitaría nueve expresiones substring. Esto haría que el código se inflara y se volviera insostenible. El uso de expresiones regulares simples no es adecuado. Se necesita un nuevo enfoque.

Ajustar para la longitud del nombre del producto length-adjustment

El SQLl puede mejorarse con las funciones de secuencia y longitud. En el ejemplo siguiente, sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3) genera una secuencia de números desde uno hasta la longitud del nombre del producto modificado menos tres. Por ejemplo, si el nombre del producto modificado es "ipadmini" con una longitud de ocho caracteres, genera números del uno al cinco (ocho-tres).

La instrucción siguiente extrae nombres de productos únicos y luego desglosa cada nombre en secuencias de caracteres (tokens) de cuatro longitudes de caracteres, excluyendo espacios y presentándolos como dos columnas. Una columna muestra los nombres de producto únicos y la otra columna muestra los tokens generados.

SELECT
   DISTINCT(ProductName) AS featurevector1_distinct,
  transform(
    sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3),
    i -> substring(lower(replace(ProductName, ' ', '')), i, 4)
  ) AS tokens
FROM
  featurevector1;

Los resultados se muestran en la tabla siguiente:

Asegúrese de establecer la longitud del token ensure-set-token-length

Se pueden añadir condiciones adicionales a la instrucción para garantizar que las secuencias generadas tengan una longitud específica. La siguiente instrucción SQL amplía la lógica de generación de tokens al hacer que la función transform sea más compleja. La instrucción utiliza la función filter en transform para asegurarse de que las secuencias generadas tengan una longitud de seis caracteres. Gestiona los casos en los que esto no es posible asignando valores NULL a esas posiciones.

SELECT
  DISTINCT(ProductName) AS featurevector1_distinct,
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 5),
      i -> i + 5 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 6)) = 6
               THEN substring(lower(replace(ProductName, ' ', '')), i, 6)
               ELSE NULL
          END
  ) AS tokens
FROM
  featurevector1;

Los resultados se muestran en la tabla siguiente:

Exploración de soluciones mediante las funciones de orden superior de Data Distiller higher-order-function-solutions

Las funciones de orden superior son construcciones potentes que le permiten implementar "programación" como sintaxis en Data Distiller. Se pueden utilizar para repetir una función en varios valores de una matriz.

En el contexto de Data Distiller, las funciones de orden superior son ideales para crear n-gramas e iterar secuencias de caracteres.

La función reduce, especialmente cuando se utiliza dentro de secuencias generadas por transform, proporciona una forma de derivar valores acumulativos o agregados, que pueden ser fundamentales en varios procesos analíticos y de planificación.

Por ejemplo, en la instrucción SQL siguiente, la función reduce() agrega elementos en una matriz mediante un agregador personalizado. Simula un bucle for para crear las sumas acumulativas de todos los enteros de uno a cinco. 1, 1+2, 1+2+3, 1+2+3+4, 1+2+3+4.

SELECT transform(
    sequence(1, 5),
    x -> reduce(
        sequence(1, x),
        0,  -- Initial accumulator value
        (acc, y) -> acc + y  -- Higher-order function to add numbers
    )
) AS sum_result;

A continuación se muestra un análisis de la instrucción SQL:

En resumen, esta función de orden superior toma dos parámetros (acc y y) y define la operación que se va a realizar, que en este caso es agregar y al acumulador acc. Esta función de orden superior se ejecuta para cada elemento de la secuencia durante el proceso de reducción.

El resultado de esta instrucción es una sola columna (sum_result) que contiene las sumas acumulativas de números del uno al cinco.

El valor de las funciones de orden superior value-of-higher-order-functions

En esta sección se analiza una versión reducida de una instrucción SQL de tres gramos para comprender mejor el valor de las funciones de orden superior en Data Distiller y crear n-gramos de forma más eficaz.

La instrucción siguiente opera en la columna ProductName dentro de la tabla featurevector1. Produce un conjunto de subcadenas de tres caracteres derivadas de los nombres de productos modificados dentro de la tabla, utilizando posiciones obtenidas de la secuencia generada.

SELECT
  transform(
    sequence(1, length(lower(replace(ProductName, ' ', ''))) - 2),
    i -> substring(lower(replace(ProductName, ' ', '')), i, 3)
  )
FROM
  featurevector1

A continuación se muestra un análisis de la instrucción SQL:

El resultado es una lista de subcadenas de tres caracteres de longitud, extraídas de los nombres de productos modificados, basándose en las posiciones especificadas en la secuencia.

Filtrado de los resultados filter-results

La función filter, con las transformaciones de datos subsiguientes, permite una extracción más refinada y precisa de la información relevante de los datos de texto. Esto le permite obtener perspectivas, mejorar la calidad de los datos y facilitar mejores procesos de toma de decisiones.

La función filter de la siguiente instrucción SQL sirve para restringir y limitar la secuencia de posiciones dentro de la cadena desde la que se extraen las subcadenas mediante la función de transformación posterior.

SELECT
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 6),
      i -> i + 6 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 7)) = 7
               THEN substring(lower(replace(ProductName, ' ', '')), i, 7)
               ELSE NULL
          END
  )
FROM
  featurevector1;

La función filter genera una secuencia de posiciones iniciales válidas dentro de ProductName modificado y extrae subcadenas de una longitud específica. Solo se permiten las posiciones de inicio que permiten la extracción de una subcadena de siete caracteres.

La condición i -> i + 6 <= length(lower(replace(ProductName, ' ', ''))) garantiza que la posición inicial i más 6 (la longitud de la subcadena de siete caracteres deseada menos uno) no supere la longitud de ProductName modificado.

La instrucción CASE se usa para incluir o excluir condicionalmente subcadenas en función de su longitud. Solo se incluyen subcadenas de siete caracteres; otras se sustituyen por NULL. La función transform utiliza entonces estas subcadenas para crear una secuencia de subcadenas a partir de la columna ProductName en la tabla featurevector1.

Calcular la unión cruzada de elementos únicos en dos vectores de funciones cross-join-unique-elements

La identificación de las diferencias o discrepancias entre los dos conjuntos de datos en función de una transformación específica de los datos es un proceso común para mantener la precisión, mejorar la calidad y garantizar la coherencia entre los conjuntos de datos.

Esta instrucción SQL siguiente extrae los nombres de producto únicos que están presentes en featurevector2 pero no en featurevector1 después de aplicar las transformaciones.

SELECT lower(replace(ProductName, ' ', '')) FROM featurevector2
EXCEPT
SELECT lower(replace(ProductName, ' ', '')) FROM featurevector1;

Los resultados se muestran en la tabla siguiente:

A continuación, realice una combinación cruzada para combinar elementos de los dos vectores de funciones y crear pares de elementos para la comparación. El primer paso de este proceso es crear un vector tokenizado.

Un vector tokenizado es una representación estructurada de datos de texto en la que cada palabra, frase o unidad de significado (token) se convierte en un formato numérico. Esta conversión permite a los algoritmos de procesamiento de lenguaje natural comprender y analizar la información textual.

El SQL siguiente crea un vector tokenizado.

CREATE TABLE featurevector1tokenized AS SELECT
  DISTINCT(ProductName) AS featurevector1_distinct,
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 1),
      i -> i + 1 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 2)) = 2
               THEN substring(lower(replace(ProductName, ' ', '')), i, 2)
               ELSE NULL
          END
  ) AS tokens
FROM
  (SELECT lower(replace(ProductName, ' ', '')) AS ProductName FROM featurevector1);
SELECT * FROM featurevector1tokenized;

Los resultados se muestran en la tabla siguiente:

A continuación, repita el proceso para featurevector2:

CREATE TABLE featurevector2tokenized AS
SELECT
  DISTINCT(ProductName) AS featurevector2_distinct,
  transform(
    filter(
      sequence(1, length(lower(replace(ProductName, ' ', ''))) - 1),
      i -> i + 1 <= length(lower(replace(ProductName, ' ', '')))
    ),
    i -> CASE WHEN length(substring(lower(replace(ProductName, ' ', '')), i, 2)) = 2
               THEN substring(lower(replace(ProductName, ' ', '')), i, 2)
               ELSE NULL
          END
  ) AS tokens
FROM
(SELECT lower(replace(ProductName, ' ', '')) AS ProductName FROM featurevector2
);
SELECT * FROM featurevector2tokenized;

Los resultados se muestran en la tabla siguiente:

Con ambos vectores tokenizados completados, ahora puede crear la unión cruzada. Esto se ve en el siguiente SQL:

SELECT
    A.featurevector1_distinct AS SetA_ProductNames,
    B.featurevector2_distinct AS SetB_ProductNames,
    A.tokens AS SetA_tokens1,
    B.tokens AS SetB_tokens2
FROM
    featurevector1tokenized A
CROSS JOIN
    featurevector2tokenized B;

A continuación se muestra un resumen del SQL utilizado para crear la combinación cruzada:

Los resultados se muestran en la tabla siguiente:

Calcular la medida de similitud de Jaccard compute-the-jaccard-similarity-measure

A continuación, calcule y utilice el coeficiente de similitud de Jaccard para realizar un análisis de similitud entre los dos conjuntos de nombres de productos comparando sus representaciones tokenizadas. La salida del script SQL siguiente proporciona lo siguiente: nombres de producto de ambos conjuntos, sus representaciones tokenizadas, recuentos de tokens únicos comunes y totales, y el coeficiente de similitud de Jaccard calculado para cada par de conjuntos de datos.

SELECT
    SetA_ProductNames,
    SetB_ProductNames,
    SetA_tokens1,
    SetB_tokens2,
    size(array_intersect(SetA_tokens1, SetB_tokens2)) AS token_intersect_count,
    size(array_union(SetA_tokens1, SetB_tokens2)) AS token_union_count,
    ROUND(
        CAST(size(array_intersect(SetA_tokens1, SetB_tokens2)) AS DOUBLE) /    size(array_union(SetA_tokens1, SetB_tokens2)), 2) AS jaccard_similarity
FROM
    (SELECT
        A.featurevector1_distinct AS SetA_ProductNames,
        B.featurevector2_distinct AS SetB_ProductNames,
        A.tokens AS SetA_tokens1,
        B.tokens AS SetB_tokens2
    FROM
        featurevector1tokenized A
    CROSS JOIN
        featurevector2tokenized B
    );

A continuación se muestra un resumen del SQL utilizado para calcular el coeficiente de similitud de Jaccard:

Los resultados se muestran en la tabla siguiente:

Filtrar resultados según el umbral de similitud de Jaccard similarity-threshold-filter

Por último, filtre los resultados en función de un umbral predefinido para seleccionar solo aquellos pares que cumplan los criterios de similitud. La siguiente instrucción SQL filtra los productos con un coeficiente de similitud de Jaccard de al menos 0,4. Esto reduce los resultados a pares que muestran un grado sustancial de similitud.

SELECT
    SetA_ProductNames,
    SetB_ProductNames
FROM
(SELECT
    SetA_ProductNames,
    SetB_ProductNames,
    SetA_tokens1,
    SetB_tokens2,
    size(array_intersect(SetA_tokens1, SetB_tokens2)) AS token_intersect_count,
    size(array_union(SetA_tokens1, SetB_tokens2)) AS token_union_count,
    ROUND(
        CAST(size(array_intersect(SetA_tokens1, SetB_tokens2)) AS DOUBLE) / size(array_union(SetA_tokens1, SetB_tokens2)),
        2
    ) AS jaccard_similarity
FROM
    (SELECT
        A.featurevector1_distinct AS SetA_ProductNames,
        B.featurevector2_distinct AS SetB_ProductNames,
        A.tokens AS SetA_tokens1,
        B.tokens AS SetB_tokens2
    FROM
        featurevector1tokenized A
    CROSS JOIN
        featurevector2tokenized B
    )
)
WHERE jaccard_similarity>=0.4

Los resultados de esta consulta dan las columnas para la unión de similitud, como se ve a continuación: