Dapatkan wawasan yang lebih baik dari ulasan menggunakan Amazon Comprehend

“85% pembeli memercayai ulasan online seperti halnya rekomendasi pribadi” – Gartner

Konsumen semakin terlibat dengan bisnis melalui permukaan digital dan berbagai titik kontak. Statistik menunjukkan bahwa sebagian besar pembeli menggunakan ulasan untuk menentukan produk apa yang akan dibeli dan layanan mana yang akan digunakan. sesuai Pusat Penelitian Spiegel, kemungkinan pembelian produk dengan lima ulasan adalah 270% lebih besar daripada kemungkinan pembelian produk tanpa ulasan. Ulasan memiliki kekuatan untuk mempengaruhi keputusan konsumen dan memperkuat nilai merek.

Dalam posting ini, kami menggunakan Amazon Comprehend untuk mengekstrak informasi yang berarti dari ulasan produk, menganalisisnya untuk memahami bagaimana pengguna dari berbagai demografi bereaksi terhadap produk, dan menemukan informasi agregat tentang minat pengguna terhadap suatu produk. Amazon Comprehend adalah layanan pemrosesan bahasa alami (NLP) yang terkelola sepenuhnya dan terus dilatih yang dapat mengekstrak wawasan tentang konten dokumen atau teks.

Ikhtisar solusi

Saat ini, ulasan dapat diberikan oleh pelanggan dengan berbagai cara, seperti peringkat bintang, teks bebas atau bahasa alami, atau berbagi media sosial. Teks gratis atau ulasan bahasa alami membantu membangun kepercayaan, karena ini merupakan opini independen dari konsumen. Ini sering digunakan oleh tim produk untuk berinteraksi dengan pelanggan melalui saluran ulasan. Ini adalah fakta yang terbukti bahwa ketika pelanggan merasa didengar, perasaan mereka tentang merek meningkat. Meskipun relatif lebih mudah untuk menganalisis peringkat bintang atau berbagi media sosial, bahasa alami atau ulasan teks bebas menimbulkan banyak tantangan, seperti mengidentifikasi kata kunci atau frasa, topik atau konsep, dan sentimen atau sentimen tingkat entitas. Tantangannya terutama karena variabilitas panjang dalam teks tertulis dan kemungkinan adanya sinyal dan noise. Selain itu, informasinya bisa sangat jelas dan eksplisit (misalnya, dengan kata kunci dan frasa kunci) atau tidak jelas dan implisit (topik dan konsep abstrak). Yang lebih menantang adalah memahami berbagai jenis sentimen dan menghubungkannya dengan produk dan layanan yang sesuai. Namun demikian, sangat penting untuk memahami informasi dan sinyal tekstual ini untuk memberikan pengalaman pelanggan yang lancar.

Dalam posting ini, kami menggunakan yang tersedia untuk umum NLP – cepat.ai dataset untuk menganalisis review produk yang diberikan oleh pelanggan. Kami mulai dengan menggunakan teknik pembelajaran mesin (ML) tanpa pengawasan yang dikenal sebagai pemodelan topik. Ini adalah teknik populer tanpa pengawasan yang menemukan topik abstrak yang dapat muncul dalam kumpulan ulasan teks. Pemodelan topik adalah masalah pengelompokan yang tidak diawasi, artinya model tidak memiliki pengetahuan tentang variabel target yang mungkin (seperti topik dalam ulasan). Topik direpresentasikan sebagai cluster. Seringkali, jumlah cluster dalam kumpulan dokumen ditentukan dengan bantuan pakar domain atau dengan menggunakan beberapa analisis statistik standar. Output model umumnya memiliki tiga komponen: cluster bernomor (topik 0, topik 1, dan seterusnya), kata kunci yang terkait dengan setiap cluster, dan cluster representatif untuk setiap dokumen (atau ulasan dalam kasus kami). Dengan sifatnya yang inheren, model topik tidak menghasilkan label yang dapat dibaca manusia untuk kluster atau topik, yang merupakan kesalahpahaman umum. Yang perlu diperhatikan tentang pemodelan topik secara umum adalah model keanggotaan campuran—setiap dokumen dalam model mungkin memiliki kemiripan dengan setiap topik. Model topik belajar dalam proses Bayesian berulang untuk menentukan probabilitas bahwa setiap dokumen dikaitkan dengan tema atau topik tertentu. Keluaran model tergantung pada pemilihan jumlah topik secara optimal. Sejumlah kecil topik dapat menyebabkan topik menjadi terlalu luas, dan sejumlah besar topik dapat menghasilkan topik yang berlebihan atau topik dengan kesamaan. Ada beberapa cara untuk mengevaluasi model topik:

• Penilaian manusia – Berbasis observasi, berbasis interpretasi
• Metrik kuantitatif – Kebingungan, perhitungan koherensi
• Pendekatan campuran – Kombinasi pendekatan berbasis penilaian dan kuantitatif

Kebingungan dihitung dengan membagi set data menjadi dua bagian—set pelatihan dan set pengujian. Kemungkinan biasanya dihitung sebagai logaritma, sehingga metrik ini terkadang disebut sebagai kemungkinan log yang ditahan. Kebingungan adalah metrik prediktif. Ini menilai kemampuan model topik untuk memprediksi set tes setelah dilatih di set pelatihan. Salah satu kekurangan dari kebingungan adalah tidak menangkap konteks, artinya tidak menangkap hubungan antar kata dalam suatu topik atau topik dalam dokumen. Namun, gagasan tentang konteks semantik penting untuk pemahaman manusia. Langkah-langkah seperti kemungkinan bersyarat dari kemunculan kata-kata dalam suatu topik dapat membantu. Pendekatan ini secara kolektif disebut sebagai koherensi. Untuk postingan kali ini, kami fokus pada pendekatan penilaian manusia (berbasis observasi), yaitu mengamati n kata teratas dalam suatu topik.

Solusinya terdiri dari langkah-langkah tingkat tinggi berikut:

1. Siapkan Amazon SageMaker contoh buku catatan.
2. Buat buku catatan.
3. Lakukan analisis data eksplorasi.
4. Jalankan pekerjaan pemodelan topik Amazon Comprehend Anda.
5. Hasilkan topik dan pahami sentimen.
6. penggunaan Amazon QuickSight untuk memvisualisasikan data dan menghasilkan laporan.

Anda dapat menggunakan solusi ini di Wilayah AWS mana pun, tetapi Anda perlu memastikan bahwa Amazon Comprehend API dan SageMaker berada di Wilayah yang sama. Untuk posting ini, kami menggunakan Region US East (N. Virginia).

Siapkan instans notebook SageMaker Anda

Anda dapat berinteraksi dengan Amazon Comprehend melalui Konsol Manajemen AWS, Antarmuka Baris Perintah AWS (AWS CLI), atau Amazon Comprehend API. Untuk informasi lebih lanjut, lihat Memulai dengan Amazon Comprehend. Kami menggunakan buku catatan SageMaker dan kode Python (Boto3) di seluruh postingan ini untuk berinteraksi dengan API Amazon Comprehend.

1. Di konsol Amazon SageMaker, di bawah Notebook di panel navigasi, pilih
   Contoh buku catatan.
2. Pilih Buat instance notebook.
3. Tentukan nama instance notebook dan setel jenis instance sebagai ml.r5.2xlarge.
4. Biarkan sisa pengaturan default.
5. Buat Identitas dan Manajemen Akses AWS (IAM) peran dengan AmazonSageMakerFullAccess dan akses ke semua yang diperlukan Layanan Penyimpanan Sederhana Amazon (Amazon S3) bucket dan Amazon Comprehend API.
6. Pilih Buat instance notebook.
   Setelah beberapa menit, instans notebook Anda sudah siap.
7. Untuk mengakses Amazon Comprehend dari instans notebook, Anda harus melampirkan ComprehendFullAccess kebijakan untuk peran IAM Anda.

Untuk ikhtisar keamanan Amazon Comprehend, lihat Keamanan di Amazon Comprehend.

Setelah Anda membuka instans notebook yang Anda sediakan, di konsol Jupyter, pilih Baru, lalu Python 3 (Ilmu Data). Atau, Anda dapat mengakses file kode sampel di GitHub repo. Anda dapat mengunggah file ke instance notebook untuk menjalankannya secara langsung atau mengkloningnya.

Repo GitHub berisi tiga buku catatan:

• data_processing.ipynb
• model_training.ipynb
• topic_mapping_sentiment_generation.ipynb

Lakukan analisis data eksplorasi

Kami menggunakan buku catatan pertama (data_processing.ipynb) untuk mengeksplorasi dan mengolah data. Kita mulai dengan hanya memuat data dari bucket S3 ke dalam DataFrame.

# Bucket containing the data
BUCKET = 'clothing-shoe-jewel-tm-blog'

# Item ratings and metadata
S3_DATA_FILE = 'Clothing_Shoes_and_Jewelry.json.gz' # Zip
S3_META_FILE = 'meta_Clothing_Shoes_and_Jewelry.json.gz' # Zip

S3_DATA = 's3://' + BUCKET + '/' + S3_DATA_FILE
S3_META = 's3://' + BUCKET + '/' + S3_META_FILE

# Transformed review, input for Comprehend
LOCAL_TRANSFORMED_REVIEW = os.path.join('data', 'TransformedReviews.txt')
S3_OUT = 's3://' + BUCKET + '/out/' + 'TransformedReviews.txt'

# Final dataframe where topics and sentiments are going to be joined
S3_FEEDBACK_TOPICS = 's3://' + BUCKET + '/out/' + 'FinalDataframe.csv'

def convert_json_to_df(path):
    """Reads a subset of a json file in a given path in chunks, combines, and returns
    """
    # Creating chunks from 500k data points each of chunk size 10k
    chunks = pd.read_json(path, orient='records', 
                                lines=True, 
                                nrows=500000, 
                                chunksize=10000, 
                                compression='gzip')
    # Creating a single dataframe from all the chunks
    load_df = pd.DataFrame()
    for chunk in chunks:
        load_df = pd.concat([load_df, chunk], axis=0)
    return load_df

# Review data
original_df = convert_json_to_df(S3_DATA)

# Metadata
original_meta = convert_json_to_df(S3_META)

Pada bagian berikut, kami melakukan analisis data eksplorasi (EDA) untuk memahami data. Kita mulai dengan mengeksplorasi bentuk data dan metadata. Untuk keaslian, kami hanya menggunakan ulasan terverifikasi.

# Shape of reviews and metadata
print('Shape of review data: ', original_df.shape)
print('Shape of metadata: ', original_meta.shape)

# We are interested in verified reviews only
# Also checking the amount of missing values in the review data
print('Frequency of verified/non verified review data: ', original_df['verified'].value_counts())
print('Frequency of missing values in review data: ', original_df.isna().sum())

Kami mengeksplorasi lebih lanjut jumlah setiap kategori, dan melihat apakah ada data duplikat.

# Count of each categories for EDA.
print('Frequncy of different item categories in metadata: ', original_meta['category'].value_counts())

# Checking null values for metadata
print('Frequency of missing values in metadata: ', original_meta.isna().sum())

# Checking if there are duplicated data. There are indeed duplicated data in the dataframe.
print('Duplicate items in metadata: ', original_meta[original_meta['asin'].duplicated()])

Ketika kami puas dengan hasilnya, kami pindah ke langkah berikutnya dari pra-pemrosesan data. Amazon Comprehend merekomendasikan untuk menyediakan setidaknya 1,000 dokumen dalam setiap pekerjaan pemodelan topik, dengan setiap dokumen setidaknya terdiri dari tiga kalimat. Dokumen harus dalam file teks berformat UTF-8. Pada langkah berikut, kami memastikan bahwa data dalam format UTF-8 yang direkomendasikan dan setiap input berukuran tidak lebih dari 5,000 byte.

def clean_text(df):
    """Preprocessing review text.
    The text becomes Comprehend compatible as a result.
    This is the most important preprocessing step.
    """
    # Encode and decode reviews
    df['reviewText'] = df['reviewText'].str.encode("utf-8", "ignore")
    df['reviewText'] = df['reviewText'].str.decode('ascii')

    # Replacing characters with whitespace
    df['reviewText'] = df['reviewText'].replace(r'r+|n+|t+|u2028',' ', regex=True)

    # Replacing punctuations
    df['reviewText'] = df['reviewText'].str.replace('[^ws]','', regex=True)

    # Lowercasing reviews
    df['reviewText'] = df['reviewText'].str.lower()
    return df

def prepare_input_data(df):
    """Encoding and getting reviews in byte size.
    Review gets encoded to utf-8 format and getting the size of the reviews in bytes. 
    Comprehend requires each review input to be no more than 5000 Bytes
    """
    df['review_size'] = df['reviewText'].apply(lambda x:len(x.encode('utf-8')))
    df = df[(df['review_size'] > 0) & (df['review_size'] < 5000)]
    df = df.drop(columns=['review_size'])
    return df

# Only data points with a verified review will be selected and the review must not be missing
filter = (original_df['verified'] == True) & (~original_df['reviewText'].isna())
filtered_df = original_df[filter]

# Only a subset of fields are selected in this experiment. 
filtered_df = filtered_df[['asin', 'reviewText', 'summary', 'unixReviewTime', 'overall', 'reviewerID']]

# Just in case, once again, dropping data points with missing review text
filtered_df = filtered_df.dropna(subset=['reviewText'])
print('Shape of review data: ', filtered_df.shape)

# Dropping duplicate items from metadata
original_meta = original_meta.drop_duplicates(subset=['asin'])

# Only a subset of fields are selected in this experiment. 
original_meta = original_meta[['asin', 'category', 'title', 'description', 'brand', 'main_cat']]

# Clean reviews using text cleaning pipeline
df = clean_text(filtered_df)

# Dataframe where Comprehend outputs (topics and sentiments) will be added
df = prepare_input_data(df)

Kami kemudian menyimpan data ke Amazon S3 dan juga menyimpan salinan lokal di instance notebook.

# Saving dataframe on S3 df.to_csv(S3_FEEDBACK_TOPICS, index=False) 

# Reviews are transformed per Comprehend guideline- one review per line
# The txt file will be used as input for Comprehend
# We first save the input file locally
with open(LOCAL_TRANSFORMED_REVIEW, "w") as outfile:
    outfile.write("n".join(df['reviewText'].tolist()))

# Transferring the transformed review (input to Comprehend) to S3
!aws s3 mv {LOCAL_TRANSFORMED_REVIEW} {S3_OUT}

Ini melengkapi fase pemrosesan data kami.

Jalankan pekerjaan pemodelan topik Amazon Comprehend

Kami kemudian pindah ke fase berikutnya, di mana kami menggunakan data yang telah diproses sebelumnya untuk menjalankan pekerjaan pemodelan topik menggunakan Amazon Comprehend. Pada tahap ini, Anda dapat menggunakan notebook kedua (model_training.ipynb) atau gunakan konsol Amazon Comprehend untuk menjalankan tugas pemodelan topik. Untuk petunjuk penggunaan konsol, lihat Menjalankan tugas analisis menggunakan konsol. Jika Anda menggunakan buku catatan, Anda dapat memulai dengan membuat klien Amazon Comprehend menggunakan Boto3, seperti yang ditunjukkan pada contoh berikut.

# Client and session information
session = boto3.Session()
s3 = boto3.resource('s3')

# Account id. Required downstream.
account_id = boto3.client('sts').get_caller_identity().get('Account')

# Initializing Comprehend client
comprehend = boto3.client(service_name='comprehend', 
                          region_name=session.region_name)

Anda dapat mengirimkan dokumen Anda untuk pemodelan topik dengan dua cara: satu dokumen per file, atau satu dokumen per baris.

Kami mulai dengan 5 topik (angka-k), dan menggunakan satu dokumen per baris. Tidak ada satu cara terbaik sebagai praktik standar untuk memilih k atau jumlah topik. Anda dapat mencoba nilai k yang berbeda, dan memilih salah satu yang memiliki kemungkinan terbesar.

# Number of topics set to 5 after having a human-in-the-loop
# This needs to be fully aligned with topicMaps dictionary in the third script 
NUMBER_OF_TOPICS = 5

# Input file format of one review per line
input_doc_format = "ONE_DOC_PER_LINE"

# Role arn (Hard coded, masked)
data_access_role_arn = "arn:aws:iam::XXXXXXXXXXXX:role/service-role/AmazonSageMaker-ExecutionRole-XXXXXXXXXXXXXXX"

Pekerjaan pemodelan topik Amazon Comprehend kami mengharuskan Anda untuk lulus InputDataConfig objek kamus dengan S3, InputFormat, dan DocumentReadAction sebagai parameter yang diperlukan. Demikian pula, Anda perlu memberikan OutputDataConfig objek dengan S3 dan DataAccessRoleArn sebagai parameter yang diperlukan. Untuk informasi lebih lanjut, lihat dokumentasi Boto3 untuk start_topics_detection_job.

# Constants for S3 bucket and input data file
BUCKET = 'clothing-shoe-jewel-tm-blog'
input_s3_url = 's3://' + BUCKET + '/out/' + 'TransformedReviews.txt'
output_s3_url = 's3://' + BUCKET + '/out/' + 'output/'

# Final dataframe where we will join Comprehend outputs later
S3_FEEDBACK_TOPICS = 's3://' + BUCKET + '/out/' + 'FinalDataframe.csv'

# Local copy of Comprehend output
LOCAL_COMPREHEND_OUTPUT_DIR = os.path.join('comprehend_out', '')
LOCAL_COMPREHEND_OUTPUT_FILE = os.path.join(LOCAL_COMPREHEND_OUTPUT_DIR, 'output.tar.gz')

INPUT_CONFIG={
    # The S3 URI where Comprehend input is placed.
    'S3Uri':    input_s3_url,
    # Document format
    'InputFormat': input_doc_format,
}
OUTPUT_CONFIG={
    # The S3 URI where Comprehend output is placed.
    'S3Uri':    output_s3_url,
}

Anda kemudian dapat memulai tugas deteksi topik asinkron dengan meneruskan jumlah topik, objek konfigurasi input, objek konfigurasi output, dan peran IAM, seperti yang ditunjukkan dalam contoh berikut.

# Reading the Comprehend input file just to double check if number of reviews 
# and the number of lines in the input file have an exact match.
obj = s3.Object(input_s3_url)
comprehend_input = obj.get()['Body'].read().decode('utf-8')
comprehend_input_lines = len(comprehend_input.split('n'))

# Reviews where Comprehend outputs will be merged
df = pd.read_csv(S3_FEEDBACK_TOPICS)
review_df_length = df.shape[0]

# The two lengths must be equal
assert comprehend_input_lines == review_df_length

# Start Comprehend topic modelling job.
# Specifies the number of topics, input and output config and IAM role ARN 
# that grants Amazon Comprehend read access to data.
start_topics_detection_job_result = comprehend.start_topics_detection_job(
                                                    NumberOfTopics=NUMBER_OF_TOPICS,
                                                    InputDataConfig=INPUT_CONFIG,
                                                    OutputDataConfig=OUTPUT_CONFIG,
                                                    DataAccessRoleArn=data_access_role_arn)

print('start_topics_detection_job_result: ' + json.dumps(start_topics_detection_job_result))

# Job ID is required downstream for extracting the Comprehend results
job_id = start_topics_detection_job_result["JobId"]
print('job_id: ', job_id)

Anda dapat melacak status pekerjaan saat ini dengan menghubungi DescribeTopicDetectionJob operasi. Status pekerjaan dapat berupa salah satu dari berikut ini:

• SUBMITTED – Pekerjaan telah diterima dan sedang dalam antrian untuk diproses
• IN_PROGRESS – Amazon Comprehend sedang memproses pekerjaan
• SELESAI – Pekerjaan berhasil diselesaikan dan hasilnya tersedia
• GAGAL – Pekerjaan tidak selesai

# Topic detection takes a while to complete. 
# We can track the current status by calling Use the DescribeTopicDetectionJob operation.
# Keeping track if Comprehend has finished its job
description = comprehend.describe_topics_detection_job(JobId=job_id)

topic_detection_job_status = description['TopicsDetectionJobProperties']["JobStatus"]
print(topic_detection_job_status)
while topic_detection_job_status not in ["COMPLETED", "FAILED"]:
    time.sleep(120)
    topic_detection_job_status = comprehend.describe_topics_detection_job(JobId=job_id)['TopicsDetectionJobProperties']["JobStatus"]
    print(topic_detection_job_status)

topic_detection_job_status = comprehend.describe_topics_detection_job(JobId=job_id)['TopicsDetectionJobProperties']["JobStatus"]
print(topic_detection_job_status)

Ketika pekerjaan berhasil diselesaikan, ia mengembalikan arsip terkompresi yang berisi dua file: topic-terms.csv dan doc-topics.csv. File keluaran pertama, topic-terms.csv, adalah daftar topik dalam koleksi. Untuk setiap topik, daftar tersebut secara default menyertakan istilah teratas berdasarkan topik menurut bobotnya. Berkas kedua, doc-topics.csv, daftar dokumen yang terkait dengan topik dan proporsi dokumen yang berkaitan dengan topik. Karena kami menentukan ONE_DOC_PER_LINE sebelumnya di input_doc_format variabel, dokumen diidentifikasi dengan nama file dan nomor baris yang diindeks 0 di dalam file. Untuk informasi lebih lanjut tentang pemodelan topik, lihat Pemodelan topik.
Keluaran Amazon Comprehend disalin secara lokal untuk langkah selanjutnya.

# Bucket prefix where model artifacts are stored
prefix = f'{account_id}-TOPICS-{job_id}'

# Model artifact zipped file
artifact_file = 'output.tar.gz'

# Location on S3 where model artifacts are stored
target = f's3://{BUCKET}/out/output/{prefix}/{artifact_file}'

# Copy Comprehend output from S3 to local notebook instance
! aws s3 cp {target}  ./comprehend-out/

# Unzip the Comprehend output file. 
# Two files are now saved locally- 
#       (1) comprehend-out/doc-topics.csv and 
#       (2) comprehend-out/topic-terms.csv

comprehend_tars = tarfile.open(LOCAL_COMPREHEND_OUTPUT_FILE)
comprehend_tars.extractall(LOCAL_COMPREHEND_OUTPUT_DIR)
comprehend_tars.close()

Karena jumlah topik jauh lebih sedikit daripada kosakata yang terkait dengan kumpulan dokumen, representasi ruang topik dapat dilihat sebagai proses pengurangan dimensi juga. Anda dapat menggunakan representasi ruang topik ini dari dokumen untuk melakukan pengelompokan. Di sisi lain, Anda dapat menganalisis frekuensi kata di setiap cluster untuk menentukan topik yang terkait dengan setiap cluster. Untuk posting ini, kami tidak melakukan teknik lain seperti clustering.

Kami menggunakan buku catatan ketiga (topic_mapping_sentiment_generation.ipynb) untuk menemukan bagaimana reaksi pengguna dari demografi yang berbeda terhadap produk, dan juga menganalisis informasi gabungan tentang minat pengguna terhadap produk tertentu.

Kita dapat menggabungkan output dari notebook sebelumnya untuk mendapatkan topik dan istilah terkait untuk setiap topik. Namun, topik diberi nomor dan mungkin kurang dapat dijelaskan. Oleh karena itu, kami lebih suka menggunakan human-in-the-loop dengan pengetahuan domain yang cukup dan keahlian materi pelajaran untuk menamai topik dengan melihat istilah terkait. Proses ini dapat dianggap sebagai pemetaan dari nomor topik ke nama topik. Namun, perlu diperhatikan bahwa daftar istilah individu untuk topik dapat saling inklusif dan oleh karena itu dapat membuat beberapa pemetaan. Human-in-the-loop harus memformalkan pemetaan berdasarkan konteks use case. Jika tidak, kinerja hilir mungkin terpengaruh.

Kita mulai dengan mendeklarasikan variabel. Untuk setiap ulasan, bisa ada beberapa topik. Kami menghitung frekuensinya dan memilih maksimal tiga topik yang paling sering. Topik-topik ini dilaporkan sebagai topik yang mewakili ulasan. Pertama, kita mendefinisikan variabel TOP_TOPICS untuk memegang jumlah maksimum topik representatif. Kedua, kami mendefinisikan dan menetapkan nilai ke language_code variabel untuk mendukung parameter bahasa yang diperlukan dari Amazon Comprehend. Akhirnya, kami membuat topicMaps, yang merupakan kamus yang memetakan nomor topik ke nama topik.

# boto3 session to access service
session = boto3.Session()
comprehend = boto3.client(  'comprehend',
                            region_name=session.region_name)

# S3 bucket
BUCKET = 'clothing-shoe-jewel-tm-blog'

# Local copy of doc-topic file
DOC_TOPIC_FILE = os.path.join('comprehend-out', 'doc-topics.csv')

# Final dataframe where we will join Comprehend outputs later
S3_FEEDBACK_TOPICS = 's3://' + BUCKET + '/out/' + 'FinalDataframe.csv'

# Final output
S3_FINAL_OUTPUT = 's3://' + BUCKET + '/out/' + 'reviewTopicsSentiments.csv'

# Top 3 topics per product will be aggregated
TOP_TOPICS = 3

# Working on English language only. 
language_code = 'en'

# Topic names for 5 topics created by human-in-the-loop or SME feed
topicMaps = {
    0: 'Product comfortability',
    1: 'Product Quality and Price',
    2: 'Product Size',
    3: 'Product Color',
    4: 'Product Return',
}

Selanjutnya, kami menggunakan file topic-terms.csv yang dihasilkan oleh Amazon Comprehend untuk menghubungkan istilah unik yang terkait dengan setiap topik. Kemudian, dengan menerapkan kamus pemetaan pada asosiasi istilah topik ini, kami menghubungkan istilah unik dengan nama topik.

# Loading documents and topics assigned to each of them by Comprehend
docTopics = pd.read_csv(DOC_TOPIC_FILE)
docTopics.head()

# Creating a field with doc number. 
# This doc number is the line number of the input file to Comprehend.
docTopics['doc'] = docTopics['docname'].str.split(':').str[1]
docTopics['doc'] = docTopics['doc'].astype(int)
docTopics.head()

# Load topics and associated terms
topicTerms = pd.read_csv(DOC_TOPIC_FILE)

# Consolidate terms for each topic
aggregatedTerms = topicTerms.groupby('topic')['term'].aggregate(lambda term: term.unique().tolist()).reset_index()

# Sneak peek
aggregatedTerms.head(10)

Pemetaan ini meningkatkan keterbacaan dan keterjelasan topik yang dihasilkan oleh Amazon Comprehend, seperti yang dapat kita lihat di DataFrame berikut.

Selanjutnya, kita gabungkan nomor topik, istilah, dan nama ke data input awal, seperti yang ditunjukkan pada langkah-langkah berikut.

Ini mengembalikan istilah dan nama topik yang sesuai dengan setiap ulasan. Nomor topik dan istilah digabungkan dengan setiap ulasan dan kemudian digabungkan kembali ke DataFrame asli yang kami simpan di buku catatan pertama.

# Load final dataframe where Comprehend results will be merged to 
feedbackTopics = pd.read_csv(S3_FEEDBACK_TOPICS)

# Joining topic numbers to main data
# The index of feedbackTopics is referring to doc field of docTopics dataframe
feedbackTopics = pd.merge(feedbackTopics, 
                          docTopics, 
                          left_index=True, 
                          right_on='doc', 
                          how='left')

# Reviews will now have topic numbers, associated terms and topics names
feedbackTopics = feedbackTopics.merge(aggregatedTerms, 
                                      on='topic', 
                                      how='left')
feedbackTopics.head()

Kami menghasilkan sentimen untuk teks ulasan menggunakan detect_sentiment. Ini memeriksa teks dan mengembalikan kesimpulan dari sentimen yang berlaku (POSITIF, NETRAL, CAMPURAN, atau NEGATIF).

def detect_sentiment(text, language_code):
    """Detects sentiment for a given text and language
    """
    comprehend_json_out = comprehend.detect_sentiment(Text=text, LanguageCode=language_code)
    return comprehend_json_out

# Comprehend output for sentiment in raw json 
feedbackTopics['comprehend_sentiment_json_out'] = feedbackTopics['reviewText'].apply(lambda x: detect_sentiment(x, language_code))

# Extracting the exact sentiment from raw Comprehend Json
feedbackTopics['sentiment'] = feedbackTopics['comprehend_sentiment_json_out'].apply(lambda x: x['Sentiment'])

# Sneak peek
feedbackTopics.head(2)

Baik topik dan sentimen terkait erat dengan ulasan. Karena kita akan menggabungkan topik dan sentimen di tingkat produk, kita perlu membuat kunci komposit dengan menggabungkan topik dan sentimen yang dihasilkan oleh Amazon Comprehend.

# Creating a composite key of topic name and sentiment.
# This is because we are counting frequency of this combination.
feedbackTopics['TopicSentiment'] = feedbackTopics['TopicNames'] + '_' + feedbackTopics['sentiment']

Setelah itu, kami mengagregasi pada tingkat produk dan menghitung kunci komposit untuk setiap produk.

Langkah terakhir ini membantu kami lebih memahami perincian ulasan per produk dan mengkategorikannya per topik secara agregat. Misalnya, kita dapat mempertimbangkan nilai yang ditampilkan untuk topicDF DataFrame. Untuk produk pertama, dari semua review yang ada, secara keseluruhan pelanggan memiliki pengalaman positif terhadap pengembalian produk, ukuran, dan kenyamanan. Untuk produk kedua, sebagian besar pelanggan memiliki pengalaman campuran-ke-positif pada pengembalian produk dan pengalaman positif pada ukuran produk.

# Create product id group
asinWiseDF = feedbackTopics.groupby('asin')

# Each product now has a list of topics and sentiment combo (topics can appear multiple times)
topicDF = asinWiseDF['TopicSentiment'].apply(lambda x:list(x)).reset_index()

# Count appreances of topics-sentiment combo for product
topicDF['TopTopics'] = topicDF['TopicSentiment'].apply(Counter)

# Sorting topics-sentiment combo based on their appearance
topicDF['TopTopics'] = topicDF['TopTopics'].apply(lambda x: sorted(x, key=x.get, reverse=True))

# Select Top k topics-sentiment combo for each product/review
topicDF['TopTopics'] = topicDF['TopTopics'].apply(lambda x: x[:TOP_TOPICS])

# Sneak peek
topicDF.head()

DataFrame akhir kami terdiri dari informasi topik ini dan informasi sentimen yang digabungkan kembali ke DataFrame akhir bernama feedbackTopics yang kami simpan di Amazon S3 di notebook pertama kami.

# Adding the topic-sentiment combo back to product metadata
finalDF = S3_FEEDBACK_TOPICS.merge(topicDF, on='asin', how='left')

# Only selecting a subset of fields
finalDF = finalDF[['asin', 'TopTopics', 'category', 'title']]

# Saving the final output locally
finalDF.to_csv(S3_FINAL_OUTPUT, index=False)

Gunakan Amazon QuickSight untuk memvisualisasikan data

Anda dapat menggunakan QuickSight untuk memvisualisasikan data dan menghasilkan laporan. QuickSight adalah layanan intelijen bisnis (BI) yang dapat Anda gunakan untuk menggunakan data dari berbagai sumber dan membuat dasbor cerdas. Dalam contoh ini, kami menghasilkan analisis QuickSight menggunakan dataset akhir yang kami hasilkan, seperti yang ditunjukkan pada contoh visualisasi berikut.

Untuk mempelajari lebih lanjut tentang Amazon QuickSight, lihat Memulai dengan Amazon Quicksight.

Membersihkan

Pada akhirnya, kita perlu mematikan instance notebook yang telah kita gunakan dalam eksperimen ini dari AWS Console.

Kesimpulan

Dalam posting ini, kami menunjukkan cara menggunakan Amazon Comprehend untuk menganalisis ulasan produk dan menemukan topik teratas menggunakan pemodelan topik sebagai teknik. Pemodelan topik memungkinkan Anda untuk melihat berbagai topik dan mengatur, memahami, dan meringkasnya dalam skala besar. Anda dapat dengan cepat dan mudah menemukan pola tersembunyi yang ada di seluruh data, lalu menggunakan wawasan tersebut untuk membuat keputusan berdasarkan data. Anda dapat menggunakan pemodelan topik untuk memecahkan banyak masalah bisnis, seperti menandai tiket dukungan pelanggan secara otomatis, mengarahkan percakapan ke tim yang tepat berdasarkan topik, mendeteksi urgensi tiket dukungan, mendapatkan wawasan yang lebih baik dari percakapan, membuat rencana berbasis data, menciptakan masalah -konten yang terfokus, meningkatkan strategi penjualan, dan mengidentifikasi masalah dan friksi pelanggan.

Ini hanyalah beberapa contoh, tetapi Anda dapat memikirkan lebih banyak masalah bisnis yang Anda hadapi di organisasi Anda setiap hari, dan bagaimana Anda dapat menggunakan pemodelan topik dengan teknik ML lainnya untuk menyelesaikannya.

---

Tentang Penulis

Gurpreet adalah Ilmuwan Data dengan Layanan Profesional AWS yang berbasis di Kanada. Dia bersemangat membantu pelanggan berinovasi dengan teknologi Pembelajaran Mesin dan Kecerdasan Buatan untuk memanfaatkan nilai bisnis dan wawasan dari data. Di waktu luangnya, dia menikmati hiking di luar ruangan dan membaca buku

Rusdi Syams adalah Ilmuwan Data dengan AWS Professional Services, Kanada. Dia membangun produk pembelajaran mesin untuk pelanggan AWS. Dia suka membaca dan menulis fiksi ilmiah.

Wrick Talukdar adalah Arsitek Senior dengan tim Amazon Comprehend Service. Dia bekerja dengan pelanggan AWS untuk membantu mereka mengadopsi pembelajaran mesin dalam skala besar. Di luar pekerjaan, dia suka membaca dan fotografi.