Recuperar registros semelhantes com funções de ordem superior

Use as funções de ordem superior do Data Distiller para resolver vários casos de uso comuns. Para identificar e recuperar registros semelhantes ou relacionados de um ou mais conjuntos de dados, use as funções de filtragem, transformação e redução, conforme detalhado neste guia. Para saber como funções de ordem superior podem ser usadas para processar tipos de dados complexos, consulte a documentação sobre como gerenciar matriz e mapear tipos de dados.

Use este guia para identificar produtos de diferentes conjuntos de dados que tenham uma semelhança significativa em suas características ou atributos. Essa metodologia fornece soluções para: desduplicação de dados, vinculação de registros, sistemas de recomendação, recuperação de informações e análise de texto, entre outras.

O documento descreve o processo de implementação de uma junção de similaridade, que usa funções de ordem superior do Data Distiller para calcular a similaridade entre conjuntos de dados e filtrá-los com base em atributos selecionados. São fornecidos trechos de código SQL e explicações para cada etapa do processo. O workflow implementa junções de similaridade usando a medida de similaridade Jaccard e a tokenização usando funções de ordem superior do Data Distiller. Esses métodos são usados para identificar e recuperar registros semelhantes ou relacionados de um ou mais conjuntos de dados com base em uma métrica de similaridade. As principais seções do processo incluem: tokenização usando funções de ordem superior, a junção cruzada de elementos exclusivos, o cálculo de similaridade de Jaccard e a filtragem baseada em limite.

Pré-requisitos

Antes de continuar com este documento, você deve se familiarizar com os seguintes conceitos:

Introdução

O SKU do Data Distiller é necessário para executar as funções de ordem superior nos dados do Adobe Experience Platform. Se você não tiver o Data Distiller SKU, entre em contato com o representante do serviço de atendimento ao cliente da Adobe para obter mais informações.

Estabelecer similaridade establish-similarity

Este caso de uso requer uma medida de similaridade entre cadeias de texto que podem ser usadas posteriormente para estabelecer um limite para filtragem. Neste exemplo, os produtos no Conjunto A e no Conjunto B representam as palavras em dois documentos.

A medida de similaridade de Jaccard pode ser aplicada a uma grande variedade de tipos de dados, incluindo dados de texto, dados categóricos e dados binários. Também é adequado para processamento em tempo real ou em lote, pois pode ser computacionalmente eficiente para calcular conjuntos de dados grandes.

O Conjunto de produtos A e o Conjunto B contêm os dados de teste para esse workflow.

Para calcular a similaridade de Jaccard entre os conjuntos de produtos A e B, localize primeiro a interseção (elementos comuns) dos conjuntos de produtos. Neste caso, {iPhone, iPad}. Em seguida, localize a união (todos os elementos exclusivos) de ambos os conjuntos de produtos. Neste exemplo, {iPhone, iPad, iWatch, iPad Mini, Macbook Pro}.

Finalmente, use a fórmula de similaridade de Jaccard: J(A,B) = A∪B / A∩B para calcular a similaridade.

J = Distância de Jacard
A = conjunto 1
B = conjunto 2

A similaridade de Jaccard entre os conjuntos de produtos A e B é de 0,4. Isso indica um grau moderado de similaridade entre as palavras usadas nos dois documentos. Essa similaridade entre os dois conjuntos define as colunas na junção de similaridade. Essas colunas representam informações, ou características associadas aos dados, que são armazenadas em uma tabela e usadas para executar os cálculos de similaridade.

Computação de Jaccard emparelhada com similaridade de strings pairwise-similarity

Para comparar com mais precisão as semelhanças entre as cadeias de caracteres, a similaridade emparelhada deve ser calculada. A similaridade emparelhada divide objetos altamente dimensionais em objetos dimensionais menores para comparação e análise. Para fazer isso, uma cadeia de caracteres de texto é dividida em partes ou unidades menores (tokens). Elas podem ser letras individuais, grupos de letras (como sílabas) ou palavras inteiras. A similaridade é calculada para cada par de tokens entre cada elemento no Conjunto A com cada elemento no Conjunto B. Essa geração de tokens fornece uma base para comparações analíticas e computacionais, relações e insights a serem obtidos dos dados.

Para o cálculo de similaridade em pares, este exemplo usa bigramas de caracteres (dois tokens de caracteres) para comparar uma correspondência de similaridade entre as strings de texto dos produtos no Conjunto A e no Conjunto B. Um bigrama é uma sequência consecutiva de dois itens ou elementos em uma determinada sequência ou texto. Você pode generalizar isso para n-gramas.

Este exemplo pressupõe que o caso não importa e que os espaços não devem ser contabilizados. De acordo com esses critérios, o conjunto A e o conjunto B têm os seguintes bigramas:

Conjunto de produtos A, em gramas:

Grupo de produtos B, em bigramas:

Em seguida, calcule o coeficiente de similaridade de Jaccard para cada par:

Criar os dados de teste com SQL create-test-data

Para criar manualmente uma tabela de teste para os conjuntos de produtos, use a instrução 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;

As descrições a seguir fornecem um detalhamento do bloco de código SQL acima:

A instrução SQL cria uma tabela como visto abaixo:

Para criar o segundo vetor de recurso, use a seguinte instrução SQL:

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

Transformações de dados data-transformation

Neste exemplo, várias ações devem ser executadas para comparar com precisão os conjuntos. Primeiro, todos os espaços em branco são removidos dos vetores de recursos, pois assume-se que não contribuem para a medida de similaridade. Em seguida, quaisquer duplicatas presentes no vetor de recurso são removidas, pois desperdiçam o processamento computacional. Em seguida, tokens de dois caracteres (bigramas) são extraídos dos vetores de recursos. Neste exemplo, supõe-se que estejam sobrepostas.

As seções a seguir ilustram as transformações de dados de pré-requisito, como desduplicação, remoção de espaços em branco e conversão de minúsculas, antes de iniciar o processo de geração de tokens.

Desduplicação deduplication

Em seguida, use a cláusula DISTINCT para remover duplicatas. Não há duplicatas neste exemplo, no entanto, é uma etapa importante para melhorar a precisão de qualquer comparação. O SQL necessário é exibido abaixo:

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

Remoção de espaço em branco whitespace-removal

Na instrução SQL a seguir, os espaços em branco são removidos dos vetores de recursos. A parte replace(ProductName, ' ', '') AS featurevector1_nospaces da consulta pega a coluna ProductName da tabela featurevector1 e usa a função replace(). A função REPLACE substitui todas as ocorrências de um espaço (' ') por uma cadeia de caracteres vazia (''). Isso remove efetivamente todos os espaços dos valores ProductName. O resultado recebeu o alias de featurevector1_nospaces.

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

Os resultados são mostrados na tabela abaixo:

A instrução SQL e seus resultados no segundo vetor de recurso são vistos abaixo:

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

Converter para minúsculas lowercase-conversion

Em seguida, o SQL é aprimorado para converter os nomes de produtos em minúsculas e remover espaços em branco. A função inferior (lower(...)) é aplicada ao resultado da função replace(). A função lower converte todos os caracteres nos valores ProductName modificados em minúsculas. Isso garante que os valores estejam em minúsculas, independentemente da caixa original.

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

O resultado dessa instrução é:

A instrução SQL e seus resultados no segundo vetor de recurso são vistos abaixo:

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

Extrair tokens usando SQL tokenization

A próxima etapa é a geração de tokens ou a divisão de texto. Tokenization é o processo de pegar o texto e quebrá-lo em termos individuais. Normalmente, isso envolve dividir frases em palavras. Neste exemplo, as cadeias de caracteres são divididas em bigramas (e n-gramas de ordem superior) extraindo tokens usando funções SQL como regexp_extract_all. Bigramas sobrepostos devem ser gerados para geração de tokens eficaz.

O SQL foi aprimorado para usar regexp_extract_all. regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0) AS tokens: Essa parte da consulta processa ainda mais os ProductName valores modificados criados na etapa anterior. Ele usa a função regexp_extract_all() para extrair todas as subcadeias de um a dois caracteres não sobrepostas dos valores ProductName modificados e em minúsculas. O padrão de expressão regular .{2} corresponde a subsequências de dois caracteres de comprimento. A parte regexp_extract_all(..., '.{2}', 0) da função extrai todas as subsequências correspondentes do 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;

Os resultados são mostrados na tabela abaixo:

Para melhorar ainda mais a precisão, o SQL deve ser usado para criar tokens sobrepostos. Por exemplo, a cadeia de caracteres "iPad" acima não tem o token "pa". Para corrigir isso, alterne o operador de lookahead (usando substring) em uma etapa e gere os bigramas.

Semelhante à etapa anterior, o regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0): extrai sequências de dois caracteres do nome do produto modificado, mas começa com o segundo caractere usando o método substring para criar tokens sobrepostos. Em seguida, nas linhas 3-7 (array_union(...) AS tokens), a função array_union() combina as matrizes de sequências de dois caracteres obtidas pelas duas extrações de expressão regular. Isso garante que o resultado contenha tokens exclusivos de sequências não sobrepostas e sobrepostas.

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;

Os resultados são mostrados na tabela abaixo:

No entanto, o uso do substring como solução para o problema tem limitações. Se você fizesse tokens do texto com base em trigramas (três caracteres), seria necessário usar dois substrings para analisar com antecedência para obter os turnos necessários. Para criar 10 gramas, você precisaria de nove expressões substring. Isso faria o código inflar e se torna insustentável. O uso de expressões regulares simples não é adequado. É necessária uma nova abordagem.

Ajustar para o comprimento do nome do produto length-adjustment

O SQl pode ser melhorado com as funções de sequência e comprimento. No exemplo a seguir, sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3) gera uma sequência de números de um ao comprimento do nome de produto modificado menos três. Por exemplo, se o nome do produto modificado for "ipadmini" com um comprimento de caracteres de oito, ele gerará números de um a cinco (oito a três).

A instrução abaixo extrai nomes de produtos exclusivos e depois divide cada nome em sequências de caracteres (tokens) de quatro tamanhos de caracteres, excluindo espaços e apresentando-os como duas colunas. Uma coluna mostra os nomes exclusivos de produtos e a outra mostra os tokens gerados.

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;

Os resultados são mostrados na tabela abaixo:

Garantir o comprimento do token definido ensure-set-token-length

Condições adicionais podem ser adicionadas à instrução para garantir que as sequências geradas sejam de um comprimento específico. A instrução SQL a seguir se expande na lógica de geração de token tornando a função transform mais complexa. A instrução usa a função filter em transform para garantir que as sequências geradas tenham seis caracteres de comprimento. Ela trata os casos em que isso não é possível, atribuindo valores NULL a essas posições.

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;

Os resultados são mostrados na tabela abaixo:

Explorar soluções usando funções de ordem superior do Data Distiller higher-order-function-solutions

Funções de ordem superior são construções poderosas que permitem implementar "programação" como sintaxe no Data Distiller. Eles podem ser usados para iterar uma função sobre vários valores em uma matriz.

No contexto do Data Distiller, funções de ordem mais alta são ideais para criar n-gramas e iterar sequências de caracteres.

A função reduce, especialmente quando usada em sequências geradas por transform, fornece uma maneira de derivar valores cumulativos ou agregações, que podem ser fundamentais em vários processos analíticos e de planejamento.

Por exemplo, na instrução SQL abaixo, a função reduce() agrega elementos em uma matriz usando um agregador personalizado. Ele simula um loop for para criar as somas cumulativas de todos os números inteiros de um 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;

Veja a seguir uma análise da instrução SQL:

Para resumir, esta função de ordem superior pega dois parâmetros (acc e y) e define a operação a ser executada, que neste caso está adicionando y ao acumulador acc. Essa função de ordem superior é executada para cada elemento na sequência durante o processo de redução.

A saída desta instrução é uma única coluna (sum_result) que contém as somas cumulativas de números de um a cinco.

O valor de funções de ordem superior value-of-higher-order-functions

Esta seção analisa uma versão reduzida de uma instrução SQL de três gramas para entender melhor o valor de funções de ordem superior no Data Distiller para criar n-gramas com mais eficiência.

A instrução abaixo opera na coluna ProductName dentro da tabela featurevector1. Ele produz um conjunto de substrings de três caracteres derivadas dos nomes de produtos modificados na tabela, usando posições obtidas da sequência gerada.

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

Veja a seguir uma análise da instrução SQL:

A saída é uma lista de substrings de três caracteres de comprimento, extraídas dos nomes de produtos modificados, com base nas posições especificadas na sequência.

Filtrar os resultados filter-results

A função filter, com transformações de dados subsequentes, permite uma extração mais refinada e precisa de informações relevantes de dados de texto. Isso permite obter insights, melhorar a qualidade dos dados e facilitar melhores processos de tomada de decisão.

A função filter na instrução SQL a seguir serve para refinar e limitar a sequência de posições na cadeia de caracteres da qual as subsequências de caracteres são extraídas usando a função de transformação subsequente.

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;

A função filter gera uma sequência de posições iniciais válidas dentro da ProductName modificada e extrai subsequências de um comprimento específico. Somente as posições iniciais que permitem a extração de uma subsequência de sete caracteres são permitidas.

A condição i -> i + 6 <= length(lower(replace(ProductName, ' ', ''))) garante que a posição inicial i mais 6 (o comprimento da subcadeia de sete caracteres desejada menos um) não exceda o comprimento da ProductName modificada.

A instrução CASE é usada para incluir ou excluir condicionalmente subsequências de caracteres com base em seu comprimento. Somente substrings de sete caracteres são incluídas; outras são substituídas por NULL. Essas subsequências de caracteres são usadas pela função transform para criar uma sequência de subsequências de caracteres a partir da coluna ProductName na tabela featurevector1.

Calcular a junção cruzada de elementos únicos em dois vetores de recursos cross-join-unique-elements

Identificar as diferenças ou discrepâncias entre os dois conjuntos de dados com base em uma transformação específica dos dados é um processo comum para manter a precisão dos dados, melhorar a qualidade dos dados e garantir a consistência entre os conjuntos de dados.

Esta instrução SQL abaixo extrai os nomes de produtos exclusivos que estão presentes em featurevector2, mas não em featurevector1, após a aplicação das transformações.

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

Os resultados são mostrados na tabela abaixo:

Em seguida, execute uma junção cruzada para combinar elementos dos dois vetores de recursos para criar pares de elementos para comparação. A primeira etapa desse processo é criar um vetor tokenizado.

Um vetor tokenizado é uma representação estruturada de dados de texto em que cada palavra, frase ou unidade de significado (token) é convertida em um formato numérico. Essa conversão permite que algoritmos de processamento de linguagem natural entendam e analisem informações textuais.

O SQL abaixo cria um vetor 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;

Os resultados são mostrados na tabela abaixo:

Em seguida, repita o processo 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;

Os resultados são mostrados na tabela abaixo:

Com ambos os vetores tokenizados concluídos, agora é possível criar a associação cruzada. Isso é visto no SQL abaixo:

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;

Veja a seguir um resumo do SQl usado para criar a junção cruzada:

Os resultados são mostrados na tabela abaixo:

Calcular a medida de similaridade de Jaccard compute-the-jaccard-similarity-measure

Em seguida, calcule usar o coeficiente de similaridade de Jaccard para executar uma análise de similaridade entre os dois conjuntos de nomes de produtos comparando suas representações tokenizadas. A saída do script SQL abaixo fornece o seguinte: nomes de produtos de ambos os conjuntos, suas representações tokenizadas, contagens de tokens únicos comuns e totais e o coeficiente de similaridade de Jaccard calculado para cada par de conjuntos de dados.

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
    );

Veja a seguir um resumo do SQL usado para calcular o coeficiente de similaridade de Jaccard:

Os resultados são mostrados na tabela abaixo:

Filtrar resultados com base no limite de Similaridade de Jacard similarity-threshold-filter

Por fim, filtre os resultados com base em um limite predefinido para selecionar apenas os pares que atendem aos critérios de similaridade. A instrução SQL abaixo filtra os produtos com um coeficiente de similaridade de Jaccard de pelo menos 0,4. Isso estreita os resultados para pares que exibem um grau substancial de similaridade.

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

Os resultados desta consulta fornecem as colunas para a junção de similaridade, conforme visto abaixo: