Bangun penargetan kontekstual berbasis taksonomi menggunakan AWS Media Intelligence dan Hugging Face BERT

Karena peraturan privasi data baru seperti GDPR (Peraturan Perlindungan Data Umum, 2017) mulai berlaku, pelanggan berada di bawah tekanan yang meningkat untuk memonetisasi aset media sambil mematuhi aturan baru. Memonetisasi media sambil menghormati peraturan privasi memerlukan kemampuan untuk mengekstrak metadata granular secara otomatis dari aset seperti file teks, gambar, video, dan audio pada skala internet. Ini juga membutuhkan cara yang terukur untuk memetakan aset media ke taksonomi industri yang memfasilitasi penemuan dan monetisasi konten. Kasus penggunaan ini sangat penting bagi industri periklanan karena aturan privasi data menyebabkan pergeseran dari penargetan perilaku menggunakan cookie pihak ketiga.

Cookie pihak ketiga membantu mengaktifkan iklan yang dipersonalisasi untuk pengguna web, dan memungkinkan pengiklan menjangkau audiens yang mereka tuju. Solusi tradisional untuk menayangkan iklan tanpa cookie pihak ketiga adalah iklan kontekstual, yang menempatkan iklan di halaman web berdasarkan konten yang dipublikasikan di halaman tersebut. Namun, iklan kontekstual menimbulkan tantangan untuk mengekstrak konteks dari aset media dalam skala besar, dan juga menggunakan konteks itu untuk memonetisasi aset.

Dalam posting ini, kami membahas bagaimana Anda dapat membangun solusi pembelajaran mesin (ML) yang kami sebut Contextual Intelligence Taxonomy Mapper (CITM) untuk mengekstrak konteks dari konten digital dan memetakannya ke taksonomi standar untuk menghasilkan nilai. Meskipun kami menerapkan solusi ini untuk iklan kontekstual, Anda dapat menggunakannya untuk menyelesaikan kasus penggunaan lainnya. Misalnya, perusahaan teknologi pendidikan dapat menggunakannya untuk memetakan konten mereka ke taksonomi industri untuk memfasilitasi pembelajaran adaptif yang memberikan pengalaman belajar yang dipersonalisasi berdasarkan kebutuhan individu siswa.

Ikhtisar solusi

Solusinya terdiri dari dua komponen: Intelijen Media AWS (AWS MI) kemampuan untuk ekstraksi konteks dari konten di halaman web, dan CITM untuk pemetaan konten yang cerdas ke taksonomi industri. Anda dapat mengakses solusi repositori kode untuk tampilan terperinci tentang bagaimana kami mengimplementasikan komponennya.

Intelijen Media AWS

Kemampuan AWS MI memungkinkan ekstraksi metadata secara otomatis yang memberikan pemahaman kontekstual tentang konten halaman web. Anda dapat menggabungkan teknik ML seperti visi komputer, ucapan ke teks, dan pemrosesan bahasa alami (NLP) untuk secara otomatis menghasilkan metadata dari teks, video, gambar, dan file audio untuk digunakan dalam pemrosesan hilir. Layanan AI terkelola seperti Rekognisi Amazon, Amazon Transkripsikan, Amazon Comprehend, dan Teks Amazon membuat teknik ML ini dapat diakses menggunakan panggilan API. Ini menghilangkan overhead yang diperlukan untuk melatih dan membangun model ML dari awal. Dalam posting ini, Anda melihat bagaimana menggunakan Amazon Comprehend dan Amazon Rekognition untuk kecerdasan media memungkinkan ekstraksi metadata dalam skala besar.

Pemeta Taksonomi Kecerdasan Kontekstual

Setelah mengekstrak metadata dari konten media, Anda memerlukan cara untuk memetakan metadata tersebut ke taksonomi industri untuk memfasilitasi penargetan kontekstual. Untuk melakukan ini, Anda membangun Contextual Intelligence Taxonomy Mapper (CITM), yang didukung oleh transformator kalimat BERT dari Hugging Face.

Transformator kalimat BERT memungkinkan CITM untuk mengkategorikan konten web dengan kata kunci yang terkait secara kontekstual. Misalnya, dapat mengkategorikan artikel web tentang hidup sehat dengan kata kunci dari taksonomi industri, seperti “Masakan dan Makan Sehat”, “Lari dan Jogging”, dan banyak lagi, berdasarkan teks yang ditulis dan gambar yang digunakan dalam artikel. CITM juga menyediakan kemampuan untuk memilih istilah taksonomi yang dipetakan untuk digunakan dalam proses penawaran iklan Anda berdasarkan kriteria Anda.

Diagram berikut menggambarkan tampilan konseptual arsitektur dengan CITM.

Taksonomi Konten IAB (Biro Periklanan Interaktif)

Untuk posting ini, kami menggunakan Taksonomi Konten IAB Tech Lab sebagai taksonomi standar industri untuk kasus penggunaan periklanan kontekstual. Secara desain, taksonomi IAB membantu pembuat konten mendeskripsikan konten mereka secara lebih akurat, dan menyediakan bahasa yang sama untuk semua pihak dalam proses periklanan terprogram. Penggunaan istilah umum sangat penting karena pemilihan iklan untuk laman web yang dikunjungi pengguna harus dilakukan dalam milidetik. Taksonomi IAB berfungsi sebagai cara standar untuk mengkategorikan konten dari berbagai sumber sekaligus menjadi protokol industri yang digunakan platform penawaran waktu nyata untuk pemilihan iklan. Ini memiliki struktur hierarkis, yang memberikan perincian istilah taksonomi dan konteks yang ditingkatkan untuk pengiklan.

Alur kerja solusi

Diagram berikut mengilustrasikan alur kerja solusi.

Langkah-langkahnya adalah sebagai berikut:

1. Layanan Penyimpanan Sederhana Amazon (Amazon S3) menyimpan taksonomi konten IAB dan mengekstrak konten web.
2. Amazon Comprehend melakukan pemodelan topik untuk mengekstrak tema umum dari kumpulan artikel.
3. Pengakuan Amazon API label objek mendeteksi label dalam gambar.
4. CITM memetakan konten ke taksonomi standar.
5. Secara opsional, Anda dapat menyimpan konten ke pemetaan taksonomi di penyimpanan metadata.

Di bagian berikut, kami menelusuri setiap langkah secara detail.

Amazon S3 menyimpan taksonomi konten IAB dan mengekstrak konten web

Kami menyimpan teks dan gambar yang diekstraksi dari kumpulan artikel web dalam ember S3. Kami juga menyimpan taksonomi konten IAB. Sebagai langkah pertama, kami menggabungkan tingkatan yang berbeda pada taksonomi untuk membuat istilah taksonomi gabungan. Pendekatan ini membantu menjaga struktur hierarki taksonomi ketika trafo kalimat BERT membuat embeddings untuk setiap kata kunci. Lihat kode berikut:

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)

Diagram berikut mengilustrasikan taksonomi konteks IAB dengan tingkatan gabungan.

Amazon Comprehend melakukan pemodelan topik untuk mengekstrak tema umum dari kumpulan artikel

Dengan API pemodelan topik Amazon Comprehend, Anda menganalisis semua teks artikel menggunakan model Latent Dirichlet Allocation (LDA). Model tersebut memeriksa setiap artikel dalam korpus dan mengelompokkan kata kunci ke dalam topik yang sama berdasarkan konteks dan frekuensi kemunculannya di seluruh kumpulan artikel. Untuk memastikan model LDA mendeteksi topik yang sangat koheren, Anda melakukan langkah prapemrosesan sebelum memanggil Amazon Comprehend API. Anda dapat menggunakan perpustakaan gensim CoherenceModel untuk menentukan jumlah topik yang optimal untuk dideteksi dari kumpulan artikel atau file teks. Lihat kode berikut:

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)

Setelah Anda mendapatkan jumlah topik yang optimal, Anda menggunakan nilai tersebut untuk pekerjaan pemodelan topik Amazon Comprehend. Memberikan nilai yang berbeda untuk parameter NumberOfTopics di Amazon Comprehend StartTopicsDetectionOperasi pekerjaan menghasilkan variasi dalam distribusi kata kunci yang ditempatkan di setiap grup topik. Nilai yang dioptimalkan untuk parameter NumberOfTopics menunjukkan jumlah topik yang memberikan pengelompokan kata kunci yang paling koheren dengan relevansi kontekstual yang lebih tinggi. Anda dapat menyimpan output pemodelan topik dari Amazon Comprehend dalam format mentahnya di Amazon S3.

API label objek Amazon Rekognition mendeteksi label dalam gambar

Anda menganalisis setiap gambar yang diekstraksi dari semua halaman web menggunakan Operasi Amazon Rekognition DetectLabels. Untuk setiap gambar, operasi memberikan respons JSON dengan semua label yang terdeteksi di dalam gambar, ditambah dengan skor kepercayaan untuk masing-masing. Untuk kasus penggunaan kami, kami secara sewenang-wenang memilih skor kepercayaan 60% atau lebih tinggi sebagai ambang batas untuk label objek untuk digunakan pada langkah berikutnya. Anda menyimpan label objek dalam format mentahnya di Amazon S3. Lihat kode berikut:

"""
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 memetakan konten ke taksonomi standar

CITM membandingkan metadata konten yang diekstraksi (topik dari teks dan label dari gambar) dengan kata kunci pada taksonomi IAB, dan kemudian memetakan metadata konten ke kata kunci dari taksonomi yang terkait secara semantik. Untuk tugas ini, CITM menyelesaikan tiga langkah berikut:

1. Hasilkan penyematan saraf untuk taksonomi konten, kata kunci topik, dan label gambar menggunakan trafo kalimat BERT Hugging Face. Kami mengakses model transformator kalimat dari Amazon SageMaker. Dalam posting ini, kami menggunakan parafrase-MiniLM-L6-v2 model, yang memetakan kata kunci dan label ke ruang vektor padat 384 dimensi.
2. Hitung skor kesamaan kosinus antara kata kunci taksonomi dan kata kunci topik menggunakan penyematannya. Ini juga menghitung kesamaan kosinus antara kata kunci taksonomi dan label objek gambar. Kami menggunakan kesamaan kosinus sebagai mekanisme penilaian untuk menemukan kecocokan semantik yang serupa antara metadata konten dan taksonomi. Lihat kode berikut:

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. Identifikasi pasangan dengan skor kesamaan yang berada di atas ambang batas yang ditentukan pengguna dan gunakan untuk memetakan konten ke kata kunci yang terkait secara semantik pada taksonomi konten. Dalam pengujian kami, kami memilih semua kata kunci dari pasangan yang memiliki skor kesamaan kosinus 0.5 atau lebih tinggi. Lihat kode berikut:

#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]:

Tantangan umum saat bekerja dengan representasi bahasa skala internet (seperti dalam kasus penggunaan ini) adalah Anda memerlukan model yang dapat memuat sebagian besar konten—dalam hal ini, kata-kata dalam bahasa Inggris. Transformator BERT Hugging Face telah dilatih sebelumnya menggunakan kumpulan besar posting Wikipedia dalam bahasa Inggris untuk mewakili makna semantik kata-kata dalam kaitannya satu sama lain. Anda menyempurnakan model yang telah dilatih sebelumnya menggunakan kumpulan data spesifik kata kunci topik, label gambar, dan kata kunci taksonomi. Ketika Anda menempatkan semua embeddings di ruang fitur yang sama dan memvisualisasikannya, Anda melihat bahwa BERT secara logis mewakili kesamaan semantik antar istilah.

Contoh berikut memvisualisasikan kata kunci taksonomi konten IAB untuk kelas Otomotif yang direpresentasikan sebagai vektor menggunakan BERT. BERT menempatkan kata kunci Otomotif dari taksonomi dekat dengan istilah yang mirip secara semantik.

Vektor fitur memungkinkan CITM untuk membandingkan label metadata dan kata kunci taksonomi dalam ruang fitur yang sama. Dalam ruang fitur ini, CITM menghitung kesamaan kosinus antara setiap vektor fitur untuk kata kunci taksonomi dan setiap vektor fitur untuk kata kunci topik. Dalam langkah terpisah, CITM membandingkan vektor fitur taksonomi dan vektor fitur untuk label gambar. Pasangan dengan skor kosinus yang paling dekat dengan 1 diidentifikasi serupa secara semantik. Perhatikan bahwa pasangan dapat berupa kata kunci topik dan kata kunci taksonomi, atau label objek dan kata kunci taksonomi.

Tangkapan layar berikut menunjukkan contoh pasangan kata kunci topik dan kata kunci taksonomi menggunakan kesamaan kosinus yang dihitung dengan penyematan BERT.

Untuk memetakan konten ke kata kunci taksonomi, CITM memilih kata kunci dari pasangan dengan skor kosinus yang memenuhi ambang batas yang ditentukan pengguna. Ini adalah kata kunci yang akan digunakan pada platform penawaran waktu nyata untuk memilih iklan untuk inventaris halaman web. Hasilnya adalah pemetaan konten online yang kaya ke taksonomi.

Secara opsional, simpan konten ke pemetaan taksonomi di penyimpanan metadata

Setelah Anda mengidentifikasi istilah taksonomi yang serupa secara kontekstual dari CITM, Anda memerlukan cara agar API berlatensi rendah dapat mengakses informasi ini. Dalam penawaran terprogram untuk iklan, waktu respons yang rendah dan konkurensi yang tinggi memainkan peran penting dalam memonetisasi konten. Skema penyimpanan data harus fleksibel untuk mengakomodasi metadata tambahan bila diperlukan untuk memperkaya permintaan tawaran. Amazon DynamoDB dapat mencocokkan pola akses data dan persyaratan operasional untuk layanan tersebut.

Kesimpulan

Dalam posting ini, Anda mempelajari cara membuat solusi penargetan kontekstual berbasis taksonomi menggunakan Contextual Intelligence Taxonomy Mapper (CITM). Anda telah mempelajari cara menggunakan Amazon Comprehend dan Amazon Rekognition untuk mengekstrak metadata granular dari aset media Anda. Kemudian, menggunakan CITM, Anda memetakan aset ke taksonomi standar industri untuk memfasilitasi penawaran iklan terprogram untuk iklan yang terkait secara kontekstual. Anda dapat menerapkan kerangka kerja ini ke kasus penggunaan lain yang memerlukan penggunaan taksonomi standar untuk meningkatkan nilai aset media yang ada.

Untuk bereksperimen dengan CITM, Anda dapat mengaksesnya repositori kode dan gunakan dengan kumpulan data teks dan gambar pilihan Anda.

Kami merekomendasikan untuk mempelajari lebih lanjut tentang komponen solusi yang diperkenalkan dalam posting ini. Temukan lebih banyak tentang Intelijen Media AWS untuk mengekstrak metadata dari konten media. Juga, pelajari lebih lanjut tentang cara menggunakan Memeluk model Wajah untuk NLP menggunakan Amazon SageMaker.

Tentang Penulis

Aramide Kehinde adalah Arsitek Solusi Mitra Senior di AWS dalam Pembelajaran Mesin dan AI. Perjalanan karirnya telah mencakup bidang Business Intelligence dan Advanced Analytics di berbagai industri. Dia bekerja untuk memungkinkan mitra membangun solusi dengan layanan AWS AI/ML yang melayani kebutuhan pelanggan akan inovasi. Dia juga senang membangun persimpangan AI dan arena kreatif dan menghabiskan waktu bersama keluarganya.

Anuj Gupta adalah Arsitek Solusi Utama yang bekerja dengan perusahaan yang berkembang pesat dalam perjalanan asli cloud mereka. Dia bersemangat menggunakan teknologi untuk memecahkan masalah yang menantang dan telah bekerja dengan pelanggan untuk membangun aplikasi yang sangat terdistribusi dan latensi rendah. Dia berkontribusi pada solusi Tanpa Server dan Pembelajaran Mesin sumber terbuka. Di luar pekerjaan, dia suka bepergian dengan keluarganya dan menulis puisi dan blog filosofis.