Bygg taksonomibasert kontekstmålretting ved å bruke AWS Media Intelligence og Hugging Face BERT

Etter hvert som nye personvernforskrifter som GDPR (General Data Protection Regulation, 2017) har trådt i kraft, er kunder under økt press for å tjene penger på mediemidler mens de overholder de nye reglene. Å tjene penger på media mens personvernregler respekteres krever muligheten til automatisk å trekke ut granulære metadata fra eiendeler som tekst, bilder, video og lydfiler på internettskala. Det krever også en skalerbar måte å kartlegge medieressurser til bransjetaksonomier som letter oppdagelse og inntektsgenerering av innhold. Denne brukstilfellet er spesielt viktig for reklamebransjen ettersom regler for personvern forårsaker et skifte fra atferdsmålretting ved bruk av tredjeparts informasjonskapsler.

Tredjeparts cookies bidra til å aktivere personlig tilpassede annonser for nettbrukere, og tillate annonsører å nå sin tiltenkte målgruppe. En tradisjonell løsning for å vise annonser uten tredjeparts informasjonskapsler er kontekstuell annonsering, som plasserer annonser på nettsider basert på innholdet som er publisert på sidene. Imidlertid utgjør kontekstuell annonsering utfordringen med å trekke ut kontekst fra medieressurser i stor skala, og på samme måte bruke den konteksten til å tjene penger på eiendelene.

I dette innlegget diskuterer vi hvordan du kan bygge en maskinlæringsløsning (ML) som vi kaller Contextual Intelligence Taxonomy Mapper (CITM) for å trekke ut kontekst fra digitalt innhold og kartlegge det til standard taksonomier for å generere verdi. Selv om vi bruker denne løsningen på kontekstuell annonsering, kan du bruke den til å løse andre brukstilfeller. For eksempel kan utdanningsteknologiselskaper bruke det til å kartlegge innholdet til bransjetaksonomier for å legge til rette for adaptiv læring som gir personlige læringsopplevelser basert på elevenes individuelle behov.

Løsningsoversikt

Løsningen består av to komponenter: AWS Media Intelligence (AWS MI)-funksjoner for kontekstutvinning fra innhold på nettsider, og CITM for intelligent kartlegging av innhold til en bransjetaksonomi. Du kan få tilgang til løsningen kodelager for en detaljert oversikt over hvordan vi implementerer komponentene.

AWS Media Intelligence

AWS MI-funksjoner muliggjør automatisk utvinning av metadata som gir kontekstuell forståelse av en nettsides innhold. Du kan kombinere ML-teknikker som datasyn, tale til tekst og naturlig språkbehandling (NLP) for automatisk å generere metadata fra tekst, videoer, bilder og lydfiler for bruk i nedstrømsbehandling. Administrerte AI-tjenester som f.eks Amazon-anerkjennelse, Amazon Transcribe, Amazon Comprehendog amazontekst gjøre disse ML-teknikkene tilgjengelige ved hjelp av API-kall. Dette eliminerer overheaden som trengs for å trene og bygge ML-modeller fra bunnen av. I dette innlegget ser du hvordan bruk av Amazon Comprehend og Amazon Rekognition for medieintelligens muliggjør utvinning av metadata i stor skala.

Kartlegger for kontekstuell intelligenstaksonomi

Etter at du har hentet ut metadata fra medieinnhold, trenger du en måte å kartlegge disse metadataene til en bransjetaksonomi for å lette innholdsmålretting. For å gjøre dette bygger du Contextual Intelligence Taxonomy Mapper (CITM), som drives av en BERT-setningstransformator fra Hugging Face.

BERT-setningstransformatoren gjør det mulig for CITM å kategorisere nettinnhold med kontekstuelt relaterte nøkkelord. For eksempel kan den kategorisere en nettartikkel om sunn livsstil med nøkkelord fra bransjetaksonomien, for eksempel "Sunn matlaging og spising", "Løping og jogging" og mer, basert på teksten som er skrevet og bildene som brukes i artikkelen. CITM gir også muligheten til å velge de kartlagte taksonomivilkårene som skal brukes for annonsebudgivningsprosessen basert på kriteriene dine.

Følgende diagram illustrerer det konseptuelle synet på arkitekturen med CITM.

IAB (Interactive Advertising Bureau) innholdstaksonomi

For dette innlegget bruker vi IAB Tech Labs innholdstaksonomi som bransjestandardtaksonomien for kontekstuell annonsering. Ved utforming hjelper IAB-taksonomien innholdsskapere mer nøyaktig med å beskrive innholdet sitt, og det gir et felles språk for alle parter i den programmatiske annonseringsprosessen. Bruken av en felles terminologi er avgjørende fordi valget av annonser for en nettside en bruker besøker må skje innen millisekunder. IAB-taksonomien fungerer som en standardisert måte å kategorisere innhold fra ulike kilder, samtidig som den er en bransjeprotokoll som sanntidsbudgivningsplattformer bruker for annonsevalg. Den har en hierarkisk struktur, som gir granularitet av taksonomitermer og forbedret kontekst for annonsører.

Løsningsarbeidsflyt

Følgende diagram illustrerer arbeidsflyten.

Trinnene er som følger:

1. Amazon enkel lagringstjeneste (Amazon S3) lagrer IAB-innholdstaksonomien og uttrukket nettinnhold.
2. Amazon Comprehend utfører emnemodellering for å trekke ut vanlige temaer fra artikkelsamlingen.
3. Amazonas anerkjennelse objektetikett API oppdager etiketter i bilder.
4. CITM kartlegger innhold til en standard taksonomi.
5. Eventuelt kan du lagre innhold til taksonomikartlegging i et metadatalager.

I de følgende avsnittene går vi gjennom hvert trinn i detalj.

Amazon S3 lagrer IAB-innholdstaksonomien og uttrukket nettinnhold

Vi lagrer uttrukket tekst og bilder fra en samling av nettartikler i en S3-bøtte. Vi lagrer også IAB-innholdstaksonomien. Som et første skritt setter vi sammen ulike nivåer på taksonomien for å lage kombinerte taksonomitermer. Denne tilnærmingen bidrar til å opprettholde taksonomiens hierarkiske struktur når BERT-setningstransformatoren oppretter innbygginger for hvert nøkkelord. 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 kombinerte nivåer.

Amazon Comprehend utfører emnemodellering for å trekke ut vanlige temaer fra artikkelsamlingen

Med Amazon Comprehend topic modeling API analyserer du alle artikkeltekstene ved å bruke Latent Dirichlet Allocation (LDA)-modellen. Modellen undersøker hver artikkel i korpuset og grupperer nøkkelord i samme emne basert på konteksten og frekvensen de vises i i hele artikkelsamlingen. For å sikre at LDA-modellen oppdager svært sammenhengende emner, utfører du et forhåndsbehandlingstrinn før du kaller opp Amazon Comprehend API. Du kan bruke gensim bibliotekets CoherenceModel for å bestemme det optimale antallet emner å oppdage fra samlingen av 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)

Etter at du har fått det optimale antallet emner, bruker du den verdien for Amazon Comprehend-emnemodelleringsjobben. Oppgi forskjellige verdier for NumberOfTopics-parameteren i Amazon Comprehend StartTopicsDetectionJob-operasjon resulterer i en variasjon i fordelingen av søkeord plassert i hver emnegruppe. En optimalisert verdi for NumberOfTopics-parameteren representerer antallet emner som gir den mest sammenhengende grupperingen av søkeord med høyere kontekstuell relevans. Du kan lagre emnemodelleringsutdata fra Amazon Comprehend i sitt råformat i Amazon S3.

Amazon Rekognition objektetikett-API oppdager etiketter i bilder

Du analyserer hvert bilde hentet fra alle nettsider ved å bruke Amazon Rekognition DetectLabels-operasjon. For hvert bilde gir operasjonen et JSON-svar med alle etiketter som er oppdaget i bildet, kombinert med en konfidenspoengsum for hver. For vår brukssituasjon velger vi vilkårlig en konfidenspoengsum på 60 % eller høyere som terskelen for objektetiketter som skal brukes i neste trinn. Du lagrer 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 kartlegger innhold til en standard taksonomi

CITM sammenligner utvunnet innholdsmetadata (emner fra tekst og etiketter fra bilder) med nøkkelord på IAB-taksonomien, og kartlegger deretter innholdsmetadataene til nøkkelord fra taksonomien som er semantisk relatert. For denne oppgaven fullfører CITM følgende tre trinn:

1. Generer nevrale innbygginger for innholdstaksonomien, emnenøkkelord og bildeetiketter ved å bruke Hugging Faces BERT-setningstransformator. Vi får tilgang til setningstransformatormodellen fra Amazon SageMaker. I dette innlegget bruker vi parafrase-MiniLM-L6-v2 modell, som kartlegger nøkkelord og etiketter til et 384 dimensjonalt tett vektorrom.
2. Beregn cosinuslikhetspoengene mellom taksonomisøkeord og emnenøkkelord ved å bruke deres innebygging. Den beregner også cosinuslikheten mellom taksonominøkkelordene og bildeobjektetikettene. Vi bruker cosinuslikhet som en scoringsmekanisme for å finne semantisk like samsvar mellom innholdsmetadataene 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. Identifiser sammenkoblinger med likhetspoeng som er over en brukerdefinert terskel og bruk dem til å kartlegge innholdet til semantisk relaterte søkeord i innholdstaksonomien. I testen vår velger vi alle søkeord fra sammenkoblinger som har en cosinuslikhetspoeng på 0.5 eller høyere. 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 vanlig utfordring når du arbeider med språkrepresentasjon på internettskala (som i denne brukssaken) er at du trenger en modell som kan passe til det meste av innholdet – i dette tilfellet ord på engelsk. Hugging Faces BERT-transformator har blitt forhåndsopplært ved å bruke et stort korpus av Wikipedia-innlegg på engelsk for å representere den semantiske betydningen av ord i forhold til hverandre. Du finjusterer den forhåndstrente modellen ved å bruke ditt spesifikke datasett med emnenøkkelord, bildeetiketter og taksonominøkkelord. Når du plasserer alle innbygginger i samme funksjonsrom og visualiserer dem, ser du at BERT logisk representerer semantisk likhet mellom termer.

Følgende eksempel visualiserer IAB-innholdstaksonominøkkelord for klassen Automotive representert som vektorer ved bruk av BERT. BERT plasserer Automotive-søkeord fra taksonomien nær semantisk lignende termer.

Funksjonsvektorene lar CITM sammenligne metadataetiketter og taksonominøkkelord i samme funksjonsrom. I dette funksjonsområdet beregner CITM cosinuslikhet mellom hver funksjonsvektor for taksonominøkkelord og hver funksjonsvektor for emnenøkkelord. I et eget trinn sammenligner CITM taksonomifunksjonsvektorer og funksjonsvektorer for bildeetiketter. Paringer med cosinus-skåre nærmest 1 identifiseres som semantisk like. Merk at en sammenkobling enten kan være et emnenøkkelord og et taksonominøkkelord, eller en objektetikett og et taksonominøkkelord.

Følgende skjermbilde viser eksempler på sammenkoblinger av emnenøkkelord og taksonominøkkelord ved bruk av cosinuslikhet beregnet med BERT-innbygginger.

For å kartlegge innhold til taksonominøkkelord, velger CITM nøkkelord fra sammenkoblinger med cosinusscore som oppfyller en brukerdefinert terskel. Dette er søkeordene som vil bli brukt på sanntidsbudgivningsplattformer for å velge annonser for nettsidens beholdning. Resultatet er en rik kartlegging av nettinnhold til taksonomien.

Lagre eventuelt innhold til taksonomikartlegging i et metadatalager

Etter at du har identifisert kontekstuelt lignende taksonomitermer fra CITM, trenger du en måte for APIer med lav latens for å få tilgang til denne informasjonen. I programmatisk budgivning for annonser spiller lav responstid og høy samtidighet en viktig rolle for å tjene penger på innholdet. Skjemaet for datalageret må være fleksibelt for å imøtekomme ytterligere metadata når det er nødvendig for å berike budforespørsler. Amazon DynamoDB kan matche datatilgangsmønstrene og driftskravene for en slik tjeneste.

konklusjonen

I dette innlegget lærte du hvordan du bygger en taksonomibasert kontekstmålrettingsløsning ved å bruke Contextual Intelligence Taxonomy Mapper (CITM). Du lærte hvordan du bruker Amazon Comprehend og Amazon Rekognition for å trekke ut granulære metadata fra mediemidlene dine. Deretter, ved hjelp av CITM, tilordnet du aktivaene til en bransjestandardtaksonomi for å lette programmatisk annonsebudgivning for kontekstuelt relaterte annonser. Du kan bruke dette rammeverket på andre brukstilfeller som krever bruk av en standard taksonomi for å øke verdien av eksisterende medieressurser.

For å eksperimentere med CITM kan du få tilgang til den kodelager og bruk den med et tekst- og bildedatasett etter eget valg.

Vi anbefaler å lære mer om løsningskomponentene introdusert i dette innlegget. Finn ut mer om AWS Media Intelligence å trekke ut metadata fra medieinnhold. Lær også mer om hvordan du bruker Hugging Face-modeller for NLP ved hjelp av Amazon SageMaker.

Om forfatterne

Aramid Kehinde er Sr. Partner Solution Architect hos AWS innen maskinlæring og kunstig intelligens. Hennes karrierereise har spennet over områdene Business Intelligence og Advanced Analytics på tvers av flere bransjer. Hun jobber for å gjøre det mulig for partnere å bygge løsninger med AWS AI/ML-tjenester som betjener kundenes behov for innovasjon. Hun liker også å bygge skjæringspunktet mellom AI og kreative arenaer og tilbringe tid med familien.

Anuj Gupta er en Principal Solutions Architect som jobber med hypervekstbedrifter på deres skybaserte reise. Han brenner for å bruke teknologi for å løse utfordrende problemer og har jobbet med kunder for å bygge svært distribuerte applikasjoner med lav latens. Han bidrar til åpen kildekode serverløse og maskinlæringsløsninger. Utenom jobben elsker han å reise med familien og skrive dikt og filosofiske blogger.