Hämta liknande poster med funktioner i högre ordning

Använd högordningsfunktionerna i Data Distiller för att lösa många vanliga användningsområden. Om du vill identifiera och hämta liknande eller relaterade poster från en eller flera datauppsättningar använder du filtret, omformningen och reducerar funktioner enligt den här handboken. Mer information om hur funktioner i högre ordning kan användas för att bearbeta komplexa datatyper finns i dokumentationen om hur du hanterar datatyper för arrayer och kartor.

Använd den här vägledningen när du vill identifiera produkter från olika datauppsättningar som har en betydande likhet i deras egenskaper eller attribut. Den här metoden ger lösningar för bland annat: borttagning av datadubbletter, postkoppling, rekommendationssystem, informationshämtning och textanalys.

Dokumentet beskriver processen att implementera en likhetskoppling, som sedan använder högre ordningsfunktioner i Data Distiller för att beräkna likheterna mellan datauppsättningar och filtrera dem baserat på valda attribut. SQL-kodfragment och förklaringar tillhandahålls för varje steg i processen. Arbetsflödet implementerar likhetskopplingar med Jaccards likhetsmått och tokenisering med Data Distiller funktioner i högre ordning. Dessa metoder används sedan för att identifiera och hämta liknande eller relaterade poster från en eller flera datauppsättningar baserade på ett likhetsmått. Nyckelavsnitten i processen är: tokenisering med funktioner i högre ordning, korskopplingen för unika element, likhetsberäkningen för kort och tröskelbaserad filtrering.

Förhandskrav

Innan du fortsätter med det här dokumentet bör du känna till följande koncept:

Komma igång

Data Distiller SKU krävs för att utföra de högre ordningsfunktionerna på dina Adobe Experience Platform-data. Om du inte har Data Distiller SKU kontaktar du Adobe kundtjänstrepresentanten för mer information.

Fastställ likhet establish-similarity

Det här användningsfallet kräver ett likhetsmått mellan textsträngar som kan användas senare för att fastställa ett tröskelvärde för filtrering. I det här exemplet representerar produkterna i Set A och Set B orden i två dokument.

Jaccards likhetsmått kan användas på ett stort antal datatyper, inklusive textdata, kategoriserade data och binära data. Den är även lämplig för realtids- eller batchbearbetning eftersom den kan vara beräkningsmässigt effektiv att beräkna för stora datamängder.

Produktgrupp A och B innehåller testdata för det här arbetsflödet.

Om du vill beräkna Jaccard-likhet mellan produktuppsättningarna A och B ska du först hitta skärningspunkten (gemensamma element) för produktuppsättningarna. I det här fallet {iPhone, iPad}. Leta sedan reda på union (alla unika element) för båda produktuppsättningarna. I det här exemplet {iPhone, iPad, iWatch, iPad Mini, Macbook Pro}.

Slutligen använder du Jaccard-likhetsformeln: J(A,B) = A∪B / A∩B för att beräkna likheten.

J = Kontantavstånd
A = uppsättning 1
B = uppsättning 2

Jaccards likhet mellan produktuppsättningarna A och B är 0,4. Detta visar på en viss grad av likhet mellan de ord som används i de två dokumenten. Denna likhet mellan de två uppsättningarna definierar kolumnerna i likhetskopplingen. Dessa kolumner representerar information, eller egenskaper som är kopplade till data, som lagras i en tabell och används för att utföra likhetsberäkningar.

Parvis Jaccard-beräkning med stränglikhet pairwise-similarity

Om likheterna mellan strängar ska jämföras på ett mer exakt sätt måste den parvisa likheten beräknas. Med parvis likhet delas högdimensionella objekt upp i mindre dimensionella objekt för jämförelse och analys. För att göra detta delas en textsträng upp i mindre delar eller enheter (tokens). Det kan vara enskilda bokstäver, grupper av bokstäver (som stavelser) eller hela ord. Likheten beräknas för varje par av tokens mellan varje element i Set A med varje element i Set B. Denna tokenisering utgör grunden för analytiska och beräkningsmässiga jämförelser, relationer och insikter som ska hämtas från data.

För den parvisa likhetsberäkningen används i det här exemplet teckenbit i gram (två teckenvariabler) för att jämföra en likhetsmatchning mellan textsträngarna för produkterna i Uppsättning A och Uppsättning B. Ett bigram är en sekvens av två objekt eller element i en given sekvens eller text. Du kan generalisera detta till n-gram.

I det här exemplet antas att fallet inte har någon betydelse och att blanksteg inte ska tas med i beräkningen. Enligt dessa kriterier har set A och Set B följande bigram:

Produktgrupp A bigram:

Bigram för produktgrupp B:

Beräkna sedan Jaccards likhetskoefficient för varje par:

Skapa testdata med SQL create-test-data

Om du vill skapa en testtabell manuellt för produktuppsättningarna använder du SQL CREATE TABLE-satsen.

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;

I följande beskrivningar finns en beskrivning av SQL-kodblocket ovan:

SQL-satsen skapar en tabell enligt nedan:

Använd följande SQL-sats för att skapa den andra funktionsvektorn:

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

Dataomvandlingar data-transformation

I det här exemplet måste flera åtgärder utföras för att uppsättningarna ska kunna jämföras korrekt. För det första tas alla blanksteg bort från funktionsvektorerna eftersom det antas att de inte bidrar till likhetsmåttet. Alla dubbletter som finns i funktionsvektorn tas sedan bort eftersom de tar bort databearbetning. Därefter extraheras tokens med två tecken (bigram) från funktionsvektorerna. I det här exemplet antas de överlappa varandra.

Följande avsnitt visar de nödvändiga dataomvandlingarna som borttagning av dubbletter, borttagning av tomt utrymme och konvertering av gemener innan tokeniseringsprocessen startas.

Deduplicering deduplication

Använd sedan satsen DISTINCT för att ta bort dubbletter. Det finns inga dubbletter i det här exemplet, men det är ett viktigt steg att förbättra exaktheten i alla jämförelser. Nödvändig SQL visas nedan:

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

Borttagning av tomt utrymme whitespace-removal

I följande SQL-sats tas blanktecken bort från funktionsvektorerna. replace(ProductName, ' ', '') AS featurevector1_nospaces-delen av frågan tar ProductName-kolumnen från tabellen featurevector1 och använder funktionen replace(). Funktionen REPLACE ersätter alla förekomster av ett blanksteg (' ') med en tom sträng (''). Detta tar effektivt bort alla blanksteg från värdena ProductName. Resultatet har alias som featurevector1_nospaces.

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

Resultaten visas i tabellen nedan:

SQL-satsen och dess resultat för den andra funktionsvektorn visas nedan:

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

Konvertera till gemener lowercase-conversion

Därefter har SQL förbättrats så att produktnamnen konverteras till gemener och blanksteg tas bort. Den nedre funktionen (lower(...)) används på resultatet av funktionen replace(). Den nedre funktionen konverterar alla tecken i de ändrade ProductName-värdena till gemener. Detta garanterar att värdena är i gemener oavsett ursprungligt skiftläge.

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

Resultatet av programsatsen är:

SQL-satsen och dess resultat för den andra funktionsvektorn visas nedan:

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

Extrahera variabler med SQL tokenization

Nästa steg är tokenisering eller textdelning. Tokenisering är processen att ta text och bryta ned den till individuella termer. Vanligtvis innebär detta att meningar delas upp i ord. I det här exemplet delas strängar upp i bigram (och i högre ordning n-gram) genom att tokens extraheras med SQL-funktioner som regexp_extract_all. Överlappande bigram måste genereras för effektiv tokenisering.

SQL har förbättrats ytterligare för att använda regexp_extract_all. regexp_extract_all(lower(replace(ProductName, ' ', '')), '.{2}', 0) AS tokens: Den här delen av frågan bearbetar de ändrade ProductName-värdena som skapades i föregående steg. Funktionen regexp_extract_all() används för att extrahera alla icke-överlappande delsträngar från ett till två tecken från de ändrade och gemena ProductName -värdena. Det reguljära uttrycket .{2} matchar delsträngar med två tecken. regexp_extract_all(..., '.{2}', 0)-delen av funktionen extraherar sedan alla matchande delsträngar från indatatexten.

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

Resultaten visas i tabellen nedan:

Om du vill förbättra precisionen ytterligare måste du använda SQL för att skapa överlappande tokens. Strängen "iPad" ovan saknar till exempel variabeln "pa". Åtgärda detta genom att ändra framåtblickande operator (med substring) i ett steg och generera bigram.

På liknande sätt som i föregående steg extraherar regexp_extract_all(lower(replace(substring(ProductName, 2), ' ', '')), '.{2}', 0): sekvenser med två tecken från det ändrade produktnamnet, men börjar från det andra tecknet med metoden substring för att skapa överlappande tokens. I rad 3-7 (array_union(...) AS tokens) kombinerar funktionen array_union() arrayerna för sekvenser med två tecken som hämtas av de två reguljära uttrycksextraktionerna. Detta garanterar att resultatet innehåller unika variabler från både icke-överlappande och överlappande sekvenser.

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;

Resultaten visas i tabellen nedan:

Användningen av substring som lösning på problemet har dock begränsningar. Om du skapar tokens från texten baserat på tre gram (tre tecken) måste du använda två substrings för att se framåt två gånger för att få de ändringar som krävs. Om du vill göra 10 gram behöver du nio substring-uttryck. Detta skulle göra att koden blottar och blir ohållbar. Användning av reguljära uttryck är inte lämpligt. Det krävs en ny strategi.

Justera för längden på produktnamnet length-adjustment

SQl kan förbättras med sekvens- och längdfunktionerna. I följande exempel genererar sequence(1, length(lower(replace(ProductName, ' ', ''))) - 3) en nummersekvens från ett till längden på det ändrade produktnamnet minus tre. Om det ändrade produktnamnet till exempel är"ipadmini" med teckenlängden åtta, genereras nummer från ett till fem (åtta-tre).

Programsatsen nedan extraherar unika produktnamn och delar sedan upp varje namn i teckensekvenser (tokens) med fyra teckenlängder, exklusive blanksteg, och visar dem som två kolumner. En kolumn visar de unika produktnamnen och den andra kolumnen visar deras genererade tokens.

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;

Resultaten visas i tabellen nedan:

Ange tokenlängd ensure-set-token-length

Ytterligare villkor kan läggas till i programsatsen för att säkerställa att de genererade sekvenserna har en viss längd. Följande SQL-sats utökas på tokengenereringslogiken genom att göra funktionen transform mer komplex. Programsatsen använder funktionen filter i transform för att säkerställa att de genererade sekvenserna har en längd på sex tecken. Den hanterar fall där det inte är möjligt genom att tilldela NULL-värden till dessa positioner.

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;

Resultaten visas i tabellen nedan:

Utforska lösningar med Data Distiller funktioner för högre ordning higher-order-function-solutions

Funktioner i högre ordning är kraftfulla konstruktioner som gör att du kan implementera"programmering" som syntax i Data Distiller. De kan användas för att iterera en funktion över flera värden i en array.

I Data Distiller är funktioner med högre ordning idealiska för att skapa n-gram och iterera över teckensekvenser.

Funktionen reduce, särskilt när den används i sekvenser som genereras av transform, erbjuder ett sätt att härleda kumulativa värden eller aggregat, som kan vara avgörande i olika analys- och planeringsprocesser.

I SQl-satsen nedan aggregerar funktionen reduce() element i en array med hjälp av en anpassad aggregator. Den simulerar en for-slinga för att skapa de kumulativa summorna för alla heltal från ett till fem. 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;

Här följer en analys av SQL-satsen:

Sammanfattningsvis tar den här funktionen för högre ordning två parametrar (acc och y) och definierar åtgärden som ska utföras, vilket i det här fallet lägger till y till ackumulatorn acc. Den här funktionen för högre ordning körs för varje element i sekvensen under reduceringsprocessen.

Utdata för den här programsatsen är en enda kolumn (sum_result) som innehåller den kumulativa summan av tal från ett till fem.

Värdet för funktioner i högre ordning value-of-higher-order-functions

I det här avsnittet analyseras en nedbantad version av en SQL-sats på tre gram för att bättre förstå värdet på funktioner i högre ordning i Data Distiller och skapa n-gram mer effektivt.

Programsatsen nedan fungerar på kolumnen ProductName i tabellen featurevector1. Den skapar en uppsättning treteckendelsträngar som härleds från de ändrade produktnamnen i tabellen, med hjälp av positioner som hämtas från den sekvens som genereras.

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

Här följer en analys av SQL-satsen:

Resultatet är en lista med delsträngar med tre tecken i längd, som extraheras från de ändrade produktnamnen, baserat på de positioner som anges i sekvensen.

Filtrera resultaten filter-results

Funktionen filter, med efterföljande dataomformningar, ger en mer detaljerad extrahering av relevant information från textdata. På så sätt kan ni få insikter, förbättra datakvaliteten och underlätta bättre beslutsprocesser.

Funktionen filter i följande SQL-sats används för att förfina och begränsa positionssekvensen i strängen som delsträngar extraheras från med den efterföljande omformningsfunktionen.

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;

Funktionen filter genererar en sekvens med giltiga startpositioner inom den ändrade ProductName och extraherar delsträngar med en viss längd. Endast startpositioner som tillåter extrahering av en delsträng med sju tecken tillåts.

Villkoret i -> i + 6 <= length(lower(replace(ProductName, ' ', ''))) säkerställer att startpositionen i plus 6 (längden på den önskade delsträngen med sju tecken minus ett) inte överskrider längden på den ändrade ProductName.

Programsatsen CASE används för att villkorligt inkludera eller exkludera delsträngar baserat på deras längd. Endast delsträngar med sju tecken ingår, andra ersätts med NULL. Dessa delsträngar används sedan av funktionen transform för att skapa en sekvens av delsträngar från kolumnen ProductName i tabellen featurevector1.

Beräkna korskopplingen mellan unika element i två funktionsvektorer cross-join-unique-elements

Att identifiera skillnader eller avvikelser mellan de två datauppsättningarna baserat på en specifik omvandling av data är en vanlig process för att bibehålla datakvaliteten, förbättra datakvaliteten och säkerställa konsekvens mellan datauppsättningarna.

Den här SQL-satsen nedan extraherar de unika produktnamn som finns i featurevector2 men inte i featurevector1 efter att omformningarna har tillämpats.

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

Resultaten visas i tabellen nedan:

Utför sedan en korskoppling för att kombinera element från de två funktionsvektorerna och skapa par av element för jämförelse. Det första steget i den här processen är att skapa en tokeniserad vektor.

En tokeniserad vektor är en strukturerad representation av textdata där varje ord, fras eller meningsenhet (token) konverteras till ett numeriskt format. Med den här konverteringen kan naturliga språkbearbetningsalgoritmer förstå och analysera textinformation.

SQl nedan skapar en tokeniserad vektor.

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;

Resultaten visas i tabellen nedan:

Upprepa sedan processen för 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;

Resultaten visas i tabellen nedan:

När båda tokeniserade vektorerna är klara kan du nu skapa krysset. Detta visas i SQL nedan:

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;

Här följer en sammanfattning av SQl som används för att skapa krysset:

Resultaten visas i tabellen nedan:

Beräkna likhetsmåttet för Jaccard compute-the-jaccard-similarity-measure

Beräkna sedan med Jaccards likhetskoefficient för att utföra en likhetsanalys mellan de två uppsättningarna produktnamn genom att jämföra deras tokeniserade representationer. Utdata från SQL-skriptet nedan ger följande: produktnamn från båda uppsättningarna, deras tokeniserade representationer, antal gemensamma och totala unika tokens samt den beräknade Jaccard-likhetskoefficienten för varje par med datauppsättningar.

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

Nedan följer en sammanfattning av den SQL som används för att beräkna likhetskoefficienten för Jaccard:

Resultaten visas i tabellen nedan:

Filtrera resultat baserat på tröskelvärdet för jacard-likhet similarity-threshold-filter

Filtrera slutligen resultaten baserat på ett fördefinierat tröskelvärde för att endast markera de par som uppfyller likhetskriterierna. SQL-satsen nedan filtrerar produkterna med en Jaccard-likhetskoefficient på minst 0,4. Detta minskar resultaten till par som uppvisar en avsevärd grad av likhet.

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

Resultatet av den här frågan ger kolumnerna för likhetskopplingen enligt nedan: