Byg taksonomi-baseret kontekstmålretning ved hjælp af AWS Media Intelligence og Hugging Face BERT

Efterhånden som nye databeskyttelsesforordninger som GDPR (General Data Protection Regulation, 2017) er trådt i kraft, er kunderne under øget pres for at tjene penge på medieaktiver, mens de overholder de nye regler. At tjene penge på medier, samtidig med at reglerne for beskyttelse af privatlivets fred respekteres, kræver muligheden for automatisk at udtrække granulære metadata fra aktiver som tekst, billeder, video og lydfiler på internetskala. Det kræver også en skalerbar måde at kortlægge medieaktiver til branchetaksonomier, der letter opdagelse og indtægtsgenerering af indhold. Denne brugssag er særlig vigtig for reklamebranchen, da databeskyttelsesregler forårsager et skift fra adfærdsmålretning ved hjælp af tredjepartscookies.

Tredjeparts cookies hjælpe med at aktivere personlige annoncer for webbrugere og give annoncører mulighed for at nå deres tilsigtede målgruppe. En traditionel løsning til at vise annoncer uden tredjepartscookies er kontekstbestemt annoncering, som placerer annoncer på websider baseret på det indhold, der er offentliggjort på siderne. Kontekstuel annoncering udgør imidlertid udfordringen med at udtrække kontekst fra medieaktiver i stor skala og ligeledes bruge denne kontekst til at tjene penge på aktiverne.

I dette indlæg diskuterer vi, hvordan du kan bygge en maskinlæringsløsning (ML), som vi kalder Contextual Intelligence Taxonomy Mapper (CITM) for at udtrække kontekst fra digitalt indhold og kortlægge det til standardtaksonomier for at skabe værdi. Selvom vi anvender denne løsning til kontekstuel annoncering, kan du bruge den til at løse andre use cases. For eksempel kan uddannelsesteknologivirksomheder bruge det til at kortlægge deres indhold til branchetaksonomier for at lette adaptiv læring, der leverer personlige læringsoplevelser baseret på elevernes individuelle behov.

Løsningsoversigt

Løsningen består af to komponenter: AWS Media Intelligence (AWS MI)-funktioner til kontekstudtrækning fra indhold på websider og CITM til intelligent kortlægning af indhold til en branchetaksonomi. Du kan få adgang til løsningens kodelager for et detaljeret overblik over, hvordan vi implementerer dets komponenter.

AWS Media Intelligence

AWS MI-kapaciteter muliggør automatisk udtrækning af metadata, der giver kontekstuel forståelse af en websides indhold. Du kan kombinere ML-teknikker som computersyn, tale til tekst og naturlig sprogbehandling (NLP) for automatisk at generere metadata fra tekst, videoer, billeder og lydfiler til brug i downstream-behandling. Administrerede AI-tjenester som f.eks Amazon-anerkendelse, Amazon Transcrib, Amazon Comprehendog amazontekst gøre disse ML-teknikker tilgængelige ved hjælp af API-kald. Dette eliminerer det nødvendige overhead til at træne og bygge ML-modeller fra bunden. I dette indlæg kan du se, hvordan brug af Amazon Comprehend og Amazon Rekognition til medieintelligens muliggør udtræk af metadata i stor skala.

Kontekstuel intelligens Taksonomi Mapper

Når du har udtrukket metadata fra medieindhold, har du brug for en måde at kortlægge disse metadata til en branchetaksonomi for at lette kontekstmålretning. For at gøre dette bygger du Contextual Intelligence Taxonomy Mapper (CITM), som drives af en BERT-sætningstransformer fra Hugging Face.

BERT-sætningstransformeren gør det muligt for CITM at kategorisere webindhold med kontekstuelt relaterede søgeord. For eksempel kan den kategorisere en webartikel om sund livsstil med nøgleord fra branchetaksonomien, såsom "Sund madlavning og spisning", "Løb og jogging" og mere, baseret på teksten skrevet og de billeder, der bruges i artiklen. CITM giver også mulighed for at vælge de tilknyttede taksonomiudtryk, der skal bruges til din annoncebudproces baseret på dine kriterier.

Følgende diagram illustrerer det konceptuelle syn på arkitekturen med CITM.

IAB (Interactive Advertising Bureau) indholdstaksonomi

Til dette indlæg bruger vi IAB Tech Labs indholdstaksonomi som branchestandardtaksonomien for kontekstuelle annonceringsbrug. Ved design hjælper IAB-taksonomien indholdsskabere mere præcist med at beskrive deres indhold, og det giver et fælles sprog for alle parter i den programmatiske annonceringsprocessen. Brugen af ​​en fælles terminologi er afgørende, fordi udvælgelsen af ​​annoncer til en webside, en bruger besøger, skal ske inden for millisekunder. IAB-taksonomien fungerer som en standardiseret måde at kategorisere indhold fra forskellige kilder, mens den også er en industriprotokol, som realtidsbudgivningsplatforme bruger til annoncevalg. Det har en hierarkisk struktur, som giver granularitet af taksonomitermer og forbedret kontekst for annoncører.

Løsnings arbejdsgang

Følgende diagram illustrerer løsningens arbejdsgang.

Trinnene er som følger:

1. Amazon Simple Storage Service (Amazon S3) gemmer IAB-indholdstaksonomien og udtrukket webindhold.
2. Amazon Comprehend udfører emnemodellering for at udtrække almindelige temaer fra samlingen af ​​artikler.
3. Amazonas anerkendelse objektlabel API registrerer etiketter i billeder.
4. CITM kortlægger indhold til en standard taksonomi.
5. Du kan eventuelt gemme indhold til taksonomikortlægning i et metadatalager.

I de følgende afsnit gennemgår vi hvert trin i detaljer.

Amazon S3 gemmer IAB-indholdstaksonomien og udtrukket webindhold

Vi gemmer udtrukket tekst og billeder fra en samling af webartikler i en S3-bøtte. Vi gemmer også IAB-indholdstaksonomien. Som et første skridt sammenkæder vi forskellige niveauer på taksonomien for at skabe kombinerede taksonomitermer. Denne tilgang hjælper med at opretholde taksonomiens hierarkiske struktur, når BERT-sætningstransformeren opretter indlejringer for hvert nøgleord. Se følgende kode:

def prepare_taxonomy(taxonomy_df):
    
    """
    Concatenate IAB Tech Lab content taxonomy tiers and prepare keywords for BERT embedding. 
    Use this function as-is if using the IAB Content Taxonomy
    
    Parameters (input):
    ----------
    taxonomy_df : Content taxonomy dataframe

    Returns (output):
    -------
    df_clean : Content taxonomy with tiers in the taxonomy concatenated
    keyword_list: List of concatenated content taxonomy keywords
    ids: List of ids for the content taxonomy keywords
    """
    
    df = taxonomy_df[['Unique ID ','Parent','Name','Tier 1','Tier 2','Tier 3']] 
    df_str = df.astype({"Unique ID ": 'str', "Parent": 'str', "Tier 1": 'str', "Tier 2": 'str', "Tier 3": 'str'})
    df_clean = df_str.replace('nan','')
    
    #create a column that concatenates all tiers for each taxonomy keyword
    df_clean['combined']=df_clean[df_clean.columns[2:6]].apply(lambda x: ' '.join(x.dropna().astype(str)),axis=1)
    
    #turn taxonomy keyords to list of strings a prep for encoding with BERT sentence transformer
    keyword_list=df_clean['combined'].to_list()
                       
    #get list of taxonomy ids
    ids = df_clean['Unique ID '].to_list()                  
            
    return df_clean, keyword_list, ids

taxonomy_df, taxonomy_terms, taxonomy_ids = prepare_taxonomy(read_taxonomy)

Følgende diagram illustrerer IAB-konteksttaksonomien med kombinerede niveauer.

Amazon Comprehend udfører emnemodellering for at udtrække almindelige temaer fra samlingen af ​​artikler

Med Amazon Comprehend topic modeling API analyserer du alle artikelteksterne ved hjælp af Latent Dirichlet Allocation (LDA) modellen. Modellen undersøger hver artikel i korpuset og grupperer søgeord i samme emne ud fra den kontekst og hyppighed, de optræder i på tværs af hele artikelsamlingen. For at sikre, at LDA-modellen registrerer meget sammenhængende emner, udfører du et forbehandlingstrin, før du kalder Amazon Comprehend API. Du kan bruge gensim bibliotekets CoherenceModel til at bestemme det optimale antal emner at opdage fra samlingen af ​​artikler eller tekstfiler. Se følgende kode:

def compute_coherence_scores(dictionary, corpus, texts, limit, start=2, step=3):
    """
    Compute coherence scores for various number of topics for your topic model. 
    Adjust the parameters below based on your data

    Parameters (input):
    ----------
    dictionary : Gensim dictionary created earlier from input texts
    corpus : Gensim corpus created earlier from input texts
    texts : List of input texts
    limit : The maximum number of topics to test. Amazon Comprehend can detect up to 100 topics in a collection

    Returns (output):
    -------
    models : List of LDA topic models
    coherence_scores : Coherence values corresponding to the LDA model with respective number of topics
    """
    coherence_scores = []
    models = []
    for num_topics in range(start, limit, step):
        model = gensim.models.LdaMulticore(corpus=corpus, num_topics=num_topics, id2word=id2word)
        models.append(model)
        coherencemodel = CoherenceModel(model=model, texts=corpus_words, dictionary=id2word, coherence='c_v')
        coherence_scores.append(coherencemodel.get_coherence())

    return models, coherence_scores

models, coherence_scores = compute_coherence_scores(dictionary=id2word, corpus=corpus_tdf, texts=corpus_words, start=2, limit=100, step=3)

Når du har fået det optimale antal emner, bruger du denne værdi til Amazon Comprehend-emnemodelleringsjobbet. Giver forskellige værdier for NumberOfTopics-parameteren i Amazon Comprehend StartTopicsDetectionJob-operation resulterer i en variation i fordelingen af ​​søgeord placeret i hver emnegruppe. En optimeret værdi for NumberOfTopics-parameteren repræsenterer antallet af emner, der giver den mest sammenhængende gruppering af søgeord med højere kontekstuel relevans. Du kan gemme emnemodelleringsoutput fra Amazon Comprehend i dets råformat i Amazon S3.

Amazon Rekognition objektetiketten API registrerer etiketter i billeder

Du analyserer hvert billede udtrukket fra alle websider ved hjælp af Amazon Rekognition DetectLabels operation. For hvert billede giver operationen et JSON-svar med alle etiketter, der er registreret i billedet, kombineret med en konfidensscore for hver. Til vores brugssag vælger vi vilkårligt en konfidensscore på 60 % eller højere som tærskelværdien for objektetiketter til brug i næste trin. Du gemmer objektetiketter i deres råformat i Amazon S3. Se følgende kode:

"""
Create a function to extract object labels from a given image using Amazon Rekognition
"""

def get_image_labels(image_loc):
    labels = []
    with fs.open(image_loc, "rb") as im:
        response = rekognition_client.detect_labels(Image={"Bytes": im.read()})
    
    for label in response["Labels"]:
        if label["Confidence"] >= 60:   #change to desired confidence score threshold, value between [0,100]:
            object_label = label["Name"]
            labels.append(object_label)
    return labels

CITM kortlægger indhold til en standard taksonomi

CITM sammenligner udtrukne indholdsmetadata (emner fra tekst og etiketter fra billeder) med nøgleord på IAB-taksonomien og kortlægger derefter indholdets metadata til nøgleord fra taksonomien, der er semantisk relaterede. Til denne opgave udfører CITM følgende tre trin:

1. Generer neurale indlejringer til indholdstaksonomien, emnesøgeord og billedetiketter ved hjælp af Hugging Faces BERT-sætningstransformer. Vi tilgår sætningstransformatormodellen fra Amazon SageMaker. I dette indlæg bruger vi parafrase-MiniLM-L6-v2 model, som kortlægger nøgleord og etiketter til et 384 dimensionelt tæt vektorrum.
2. Beregn cosinus-lighedsscoren mellem taksonomisøgeord og emnesøgeord ved hjælp af deres indlejringer. Det beregner også cosinus-ligheden mellem taksonominøgleordene og billedobjektetiketterne. Vi bruger cosinus-lighed som en scoringsmekanisme til at finde semantisk lignende match mellem indholdets metadata og taksonomien. Se følgende kode:

def compute_similarity(entity_embeddings, entity_terms, taxonomy_embeddings, taxonomy_terms):
    """
    Compute cosine scores between entity embeddings and taxonomy embeddings
    
    Parameters (input):
    ----------
    entity_embeddings : Embeddings for either topic keywords from Amazon Comprehend or image labels from Amazon Rekognition
    entity_terms : Terms for topic keywords or image labels
    taxonomy_embeddings : Embeddings for the content taxonomy
    taxonomy_terms : Terms for the taxonomy keywords

    Returns (output):
    -------
    mapping_df : Dataframe that matches each entity keyword to each taxonomy keyword and their cosine similarity score
    """
    
    #calculate cosine score, pairing each entity embedding with each taxonomy keyword embedding
    cosine_scores = util.pytorch_cos_sim(entity_embeddings, taxonomy_embeddings)
    pairs = []
    for i in range(len(cosine_scores)-1):
        for j in range(0, cosine_scores.shape[1]):
            pairs.append({'index': [i, j], 'score': cosine_scores[i][j]})
    
    #Sort cosine similarity scores in decreasing order
    pairs = sorted(pairs, key=lambda x: x['score'], reverse=True)
    rows = []
    for pair in pairs:
        i, j = pair['index']
        rows.append([entity_terms[i], taxonomy_terms[j], pair['score']])
    
    #move sorted values to a dataframe
    mapping_df= pd.DataFrame(rows, columns=["term", "taxonomy_keyword","cosine_similarity"])
    mapping_df['cosine_similarity'] = mapping_df['cosine_similarity'].astype('float')
    mapping_df= mapping_df.sort_values(by=['term','cosine_similarity'], ascending=False)
    drop_dups= mapping_df.drop_duplicates(subset=['term'], keep='first')
    mapping_df = drop_dups.sort_values(by=['cosine_similarity'], ascending=False).reset_index(drop=True)
    return mapping_df
                                               
#compute cosine_similairty score between topic keywords and content taxonomy keywords using BERT embeddings                                               
text_taxonomy_mapping=compute_similarity(keyword_embeddings, topic_keywords, taxonomy_embeddings, taxonomy_terms)

3. Identificer parringer med lighedsscore, der er over en brugerdefineret tærskel, og brug dem til at kortlægge indholdet til semantisk relaterede søgeord på indholdstaksonomien. I vores test udvælger vi alle søgeord fra parringer, der har en cosinus-lighedsscore på 0.5 eller højere. Se følgende kode:

#merge text and image keywords mapped to content taxonomy
rtb_keywords=pd.concat([text_taxonomy_mapping[["term","taxonomy_keyword","cosine_similarity"]],image_taxonomy_mapping]).sort_values(by='cosine_similarity',ascending=False).reset_index(drop=True)

#select keywords with a cosine_similarity score greater than your desired threshold ( the value should be from 0 to 1)
rtb_keywords[rtb_keywords["cosine_similarity"]> 50] # change to desired threshold for cosine score, value between [0,100]:

En almindelig udfordring, når du arbejder med sprogrepræsentation på internetskala (som i denne use case) er, at du har brug for en model, der kan passe til det meste af indholdet – i dette tilfælde ord på det engelske sprog. Hugging Faces BERT-transformator er blevet fortrænet ved at bruge et stort korpus af Wikipedia-indlæg på det engelske sprog til at repræsentere den semantiske betydning af ord i forhold til hinanden. Du finjusterer den fortrænede model ved hjælp af dit specifikke datasæt med emnenøgleord, billedetiketter og taksonominøgleord. Når du placerer alle indlejringer i det samme funktionsrum og visualiserer dem, ser du, at BERT logisk repræsenterer semantisk lighed mellem termer.

Følgende eksempel visualiserer IAB-indholdstaksonominøgleord for klassen Automotive repræsenteret som vektorer ved hjælp af BERT. BERT placerer automotive søgeord fra taksonomien tæt på semantisk lignende termer.

Funktionsvektorerne gør det muligt for CITM at sammenligne metadataetiketter og taksonominøgleord i det samme funktionsrum. I dette funktionsrum beregner CITM cosinus-ligheden mellem hver featurevektor for taksonominøgleord og hver featurevektor for emnenøgleord. I et separat trin sammenligner CITM taksonomifunktionsvektorer og funktionsvektorer for billedetiketter. Parringer med cosinusscore tættest på 1 identificeres som semantisk ens. Bemærk, at en parring enten kan være et emnenøgleord og et taksonominøgleord eller en objektetiket og et taksonominøgleord.

Følgende skærmbillede viser eksempler på parringer af emnenøgleord og taksonominøgleord ved hjælp af cosinus-lighed beregnet med BERT-indlejringer.

For at kortlægge indhold til taksonominøgleord vælger CITM nøgleord fra parringer med cosinusscore, der opfylder en brugerdefineret tærskel. Dette er de søgeord, der vil blive brugt på realtidsbudgivningsplatforme til at vælge annoncer til websidens beholdning. Resultatet er en rig kortlægning af onlineindhold til taksonomien.

Gem eventuelt indhold til taksonomikortlægning i et metadatalager

Når du har identificeret kontekstuelt lignende taksonomiudtryk fra CITM, har du brug for en måde, hvorpå API'er med lav latens kan få adgang til disse oplysninger. I programmatisk budgivning for annoncer spiller lav responstid og høj samtidighed en vigtig rolle i at tjene penge på indholdet. Skemaet for datalageret skal være fleksibelt for at kunne rumme yderligere metadata, når det er nødvendigt for at berige budanmodninger. Amazon DynamoDB kan matche dataadgangsmønstrene og driftskravene til en sådan tjeneste.

Konklusion

I dette indlæg lærte du, hvordan du bygger en taksonomi-baseret kontekstmålretningsløsning ved hjælp af Contextual Intelligence Taxonomy Mapper (CITM). Du lærte, hvordan du bruger Amazon Comprehend og Amazon Rekognition til at udtrække granulære metadata fra dine medieaktiver. Ved hjælp af CITM kortlagde du derefter aktiverne til en branchestandardtaksonomi for at lette programmatisk annoncebudgivning for kontekstuelt relaterede annoncer. Du kan anvende denne ramme til andre use cases, der kræver brug af en standard taksonomi for at øge værdien af ​​eksisterende medieaktiver.

For at eksperimentere med CITM kan du få adgang til dens kodelager og brug det med et tekst- og billeddatasæt efter eget valg.

Vi anbefaler at lære mere om løsningskomponenterne introduceret i dette indlæg. Opdag mere om AWS Media Intelligence at udtrække metadata fra medieindhold. Lær også mere om, hvordan du bruger Hugging Face-modeller til NLP ved hjælp af Amazon SageMaker.

Om forfatterne

Aramid Kehinde er en Sr. Partner Solution Architect hos AWS i Machine Learning og AI. Hendes karriererejse har spændt over områderne Business Intelligence og Advanced Analytics på tværs af flere brancher. Hun arbejder for at gøre det muligt for partnere at bygge løsninger med AWS AI/ML-tjenester, der tjener kundernes behov for innovation. Hun nyder også at bygge skæringspunktet mellem kunstig intelligens og kreative arenaer og tilbringe tid med sin familie.

Anuj Gupta er en Principal Solutions Architect, der arbejder med hypervækstvirksomheder på deres cloud-native-rejse. Han brænder for at bruge teknologi til at løse udfordrende problemer og har arbejdet sammen med kunder om at bygge meget distribuerede applikationer med lav latency. Han bidrager til open source serverløse og maskinlæringsløsninger. Uden for arbejdet elsker han at rejse med sin familie og skrive digte og filosofiske blogs.