“85% ของผู้ซื้อเชื่อถือรีวิวออนไลน์มากพอๆ กับคำแนะนำส่วนตัว” – Gartner
ผู้บริโภคมีส่วนร่วมกับธุรกิจมากขึ้นผ่านพื้นผิวดิจิทัลและจุดสัมผัสที่หลากหลาย สถิติแสดงให้เห็นว่าผู้ซื้อส่วนใหญ่ใช้บทวิจารณ์เพื่อกำหนดผลิตภัณฑ์ที่จะซื้อและบริการที่จะใช้ ตามที่ ศูนย์วิจัยสปีเกลโอกาสในการซื้อผลิตภัณฑ์ที่มีบทวิจารณ์ห้ารายการนั้นสูงกว่าโอกาสในการซื้อของผลิตภัณฑ์ที่ไม่มีบทวิจารณ์ถึง 270% บทวิจารณ์มีอำนาจในการโน้มน้าวการตัดสินใจของผู้บริโภคและเสริมสร้างคุณค่าของแบรนด์
ในโพสต์นี้เราใช้ เข้าใจ Amazon เพื่อดึงข้อมูลที่มีความหมายจากการตรวจทานผลิตภัณฑ์ วิเคราะห์เพื่อทำความเข้าใจว่าผู้ใช้ของกลุ่มประชากรต่างๆ มีปฏิกิริยาอย่างไรต่อผลิตภัณฑ์ และค้นหาข้อมูลโดยรวมเกี่ยวกับความสัมพันธ์ของผู้ใช้ที่มีต่อผลิตภัณฑ์ Amazon Comprehend เป็นบริการประมวลผลภาษาธรรมชาติ (NLP) ที่ได้รับการจัดการเต็มรูปแบบและได้รับการฝึกอบรมอย่างต่อเนื่อง ซึ่งสามารถดึงข้อมูลเชิงลึกเกี่ยวกับเนื้อหาของเอกสารหรือข้อความได้
ภาพรวมโซลูชัน
วันนี้ ลูกค้าสามารถให้ความเห็นได้หลายวิธี เช่น การให้คะแนนดาว ข้อความฟรีหรือภาษาที่เป็นธรรมชาติ หรือการแชร์บนโซเชียลมีเดีย บทวิจารณ์แบบข้อความหรือภาษาที่เป็นธรรมชาติช่วยสร้างความไว้วางใจ เนื่องจากเป็นความคิดเห็นที่เป็นอิสระจากผู้บริโภค ทีมผลิตภัณฑ์มักใช้เพื่อโต้ตอบกับลูกค้าผ่านช่องทางการตรวจทาน เป็นข้อเท็จจริงที่พิสูจน์แล้วว่าเมื่อลูกค้ารู้สึกว่าได้ยิน ความรู้สึกของพวกเขาเกี่ยวกับแบรนด์ก็ดีขึ้น ในขณะที่การวิเคราะห์การให้คะแนนดาวหรือการแชร์บนโซเชียลมีเดียทำได้ง่ายกว่า ภาษาธรรมชาติหรือการตรวจสอบข้อความอิสระทำให้เกิดความท้าทายหลายประการ เช่น การระบุคำหลักหรือวลี หัวข้อหรือแนวคิด และความรู้สึกหรือความรู้สึกในระดับเอนทิตี ความท้าทายส่วนใหญ่เกิดจากความแปรปรวนของความยาวในข้อความที่เป็นลายลักษณ์อักษรและการมีอยู่ของสัญญาณและสัญญาณรบกวน นอกจากนี้ ข้อมูลอาจมีความชัดเจนและชัดเจนมาก (เช่น ด้วยคำหลักและวลีสำคัญ) หรือไม่ชัดเจนและโดยปริยาย (หัวข้อและแนวคิดที่เป็นนามธรรม) ความท้าทายยิ่งกว่านั้นคือการทำความเข้าใจความรู้สึกประเภทต่างๆ และเชื่อมโยงกับผลิตภัณฑ์และบริการที่เหมาะสม อย่างไรก็ตาม การทำความเข้าใจข้อมูลนี้และสัญญาณที่เป็นข้อความเป็นสิ่งสำคัญอย่างยิ่ง เพื่อมอบประสบการณ์ลูกค้าที่ราบรื่น
ในโพสต์นี้เราใช้แบบสาธารณะ NLP – fast.ai ชุดข้อมูลเพื่อวิเคราะห์รีวิวผลิตภัณฑ์จากลูกค้า เราเริ่มต้นด้วยการใช้เทคนิคการเรียนรู้ของเครื่อง (ML) แบบไม่มีผู้ดูแลที่เรียกว่าการสร้างแบบจำลองหัวข้อ นี่เป็นเทคนิคยอดนิยมที่ไม่มีผู้ดูแลซึ่งค้นพบหัวข้อที่เป็นนามธรรมที่อาจเกิดขึ้นในคอลเล็กชันการตรวจทานข้อความ การสร้างแบบจำลองหัวข้อเป็นปัญหาการจัดกลุ่มที่ไม่ได้รับการดูแล หมายความว่าแบบจำลองไม่มีความรู้เกี่ยวกับตัวแปรเป้าหมายที่เป็นไปได้ (เช่น หัวข้อในการทบทวน) หัวข้อจะแสดงเป็นกลุ่ม บ่อยครั้ง จำนวนของคลัสเตอร์ในคลังเอกสารจะถูกตัดสินใจด้วยความช่วยเหลือของผู้เชี่ยวชาญโดเมนหรือโดยการใช้การวิเคราะห์ทางสถิติมาตรฐานบางอย่าง ผลลัพธ์ของโมเดลโดยทั่วไปมีสามองค์ประกอบ: คลัสเตอร์ที่มีหมายเลข (หัวข้อ 0, หัวข้อ 1 และอื่นๆ) คีย์เวิร์ดที่เกี่ยวข้องกับแต่ละคลัสเตอร์ และคลัสเตอร์ตัวแทนสำหรับแต่ละเอกสาร (หรือทบทวนในกรณีของเรา) โดยธรรมชาติแล้ว โมเดลหัวข้อจะไม่สร้างป้ายกำกับที่มนุษย์อ่านได้สำหรับคลัสเตอร์หรือหัวข้อ ซึ่งเป็นความเข้าใจผิดที่พบบ่อย สิ่งที่ควรทราบเกี่ยวกับการสร้างแบบจำลองหัวข้อโดยทั่วไปคือ เป็นรูปแบบการเป็นสมาชิกแบบผสม เอกสารทุกฉบับในแบบจำลองอาจมีความคล้ายคลึงกับทุกหัวข้อ โมเดลหัวข้อเรียนรู้ในกระบวนการแบบเบย์แบบวนซ้ำเพื่อกำหนดความน่าจะเป็นที่แต่ละเอกสารเชื่อมโยงกับธีมหรือหัวข้อที่กำหนด ผลลัพธ์ของแบบจำลองขึ้นอยู่กับการเลือกจำนวนหัวข้ออย่างเหมาะสมที่สุด หัวข้อจำนวนน้อยอาจทำให้หัวข้อกว้างเกินไป และหัวข้อจำนวนมากขึ้นอาจส่งผลให้หัวข้อซ้ำซ้อนหรือหัวข้อที่มีความคล้ายคลึงกัน มีหลายวิธีในการประเมินแบบจำลองหัวข้อ:
- การตัดสินของมนุษย์ - อิงจากการสังเกต อิงการตีความ
- เมตริกเชิงปริมาณ – ความฉงนสนเท่ห์ การคำนวณที่สอดคล้องกัน
- วิธีการแบบผสม – การผสมผสานระหว่างวิธีการที่ใช้ดุลยพินิจและเชิงปริมาณ
ความฉงนสนเท่ห์คำนวณโดยแบ่งชุดข้อมูลออกเป็นสองส่วน—ชุดการฝึกและชุดทดสอบ ความน่าจะเป็นมักจะถูกคำนวณเป็นลอการิทึม ดังนั้น เมตริกนี้บางครั้งเรียกว่าความน่าจะเป็นในการล็อกเอาต์ ความฉงนสนเท่ห์เป็นตัวชี้วัดการทำนาย โดยจะประเมินความสามารถของโมเดลหัวข้อในการทำนายชุดทดสอบหลังจากผ่านการฝึกอบรมในชุดการฝึกแล้ว ข้อบกพร่องประการหนึ่งของความฉงนสนเท่ห์คือไม่จับบริบท หมายความว่าไม่จับความสัมพันธ์ระหว่างคำในหัวข้อหรือหัวข้อในเอกสาร อย่างไรก็ตาม แนวคิดเรื่องบริบทเชิงความหมายมีความสำคัญต่อความเข้าใจของมนุษย์ มาตรการต่างๆ เช่น ความน่าจะเป็นแบบมีเงื่อนไขของการเกิดขึ้นร่วมของคำในหัวข้ออาจเป็นประโยชน์ วิธีการเหล่านี้เรียกรวมกันว่าการเชื่อมโยงกัน สำหรับโพสต์นี้ เราเน้นที่วิธีการตัดสินของมนุษย์ (ตามการสังเกต) คือการสังเกตคำ n อันดับแรกในหัวข้อ
การแก้ปัญหาประกอบด้วยขั้นตอนระดับสูงดังต่อไปนี้:
- ตั้งค่าไฟล์ อเมซอน SageMaker ตัวอย่างโน้ตบุ๊ก
- สร้างสมุดบันทึก
- ดำเนินการวิเคราะห์ข้อมูลเชิงสำรวจ
- เรียกใช้งานการสร้างแบบจำลองหัวข้อ Amazon Comprehend ของคุณ
- สร้างหัวข้อและเข้าใจความรู้สึก
- ใช้ อเมซอน QuickSight เพื่อแสดงภาพข้อมูลและสร้างรายงาน
คุณสามารถใช้โซลูชันนี้ในภูมิภาค AWS ใดก็ได้ แต่คุณต้องตรวจสอบให้แน่ใจว่า Amazon Comprehend API และ SageMaker อยู่ในภูมิภาคเดียวกัน สำหรับโพสต์นี้ เราใช้ Region US East (N. Virginia)
ตั้งค่าอินสแตนซ์สมุดบันทึก SageMaker ของคุณ
คุณสามารถโต้ตอบกับ Amazon Comprehend ผ่านทาง คอนโซลการจัดการ AWS, อินเทอร์เฟซบรรทัดคำสั่ง AWS (AWS CLI)หรือ Amazon Comprehend API สำหรับข้อมูลเพิ่มเติม โปรดดูที่ เริ่มต้นใช้งาน Amazon Comprehend. เราใช้โน้ตบุ๊ก SageMaker และโค้ด Python (Boto3) ตลอดทั้งโพสต์นี้เพื่อโต้ตอบกับ Amazon Comprehend API
- บนคอนโซล Amazon SageMaker ภายใต้ Notebook ในบานหน้าต่างนำทาง ให้เลือก
อินสแตนซ์โน้ตบุ๊ก - เลือกสร้างอินสแตนซ์สมุดบันทึก
- ระบุชื่ออินสแตนซ์โน้ตบุ๊กและตั้งค่าประเภทอินสแตนซ์เป็น ml.r5.2xlarge
- ปล่อยให้การตั้งค่าเริ่มต้นที่เหลือ
- สร้าง AWS Identity และการจัดการการเข้าถึง (IAM) บทบาทกับ
AmazonSageMakerFullAccessและเข้าถึงความจำเป็นต่างๆ บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) บัคเก็ตและ Amazon Comprehend API - เลือกสร้างอินสแตนซ์สมุดบันทึก
หลังจากนั้นไม่กี่นาที อินสแตนซ์สมุดบันทึกของคุณก็พร้อม - ในการเข้าถึง Amazon Comprehend จากอินสแตนซ์โน้ตบุ๊ก คุณต้องแนบ
ComprehendFullAccessนโยบายสำหรับบทบาท IAM ของคุณ
สำหรับภาพรวมความปลอดภัยของ Amazon Comprehend โปรดดูที่ ความปลอดภัยใน Amazon Comprehend.
หลังจากที่คุณเปิดอินสแตนซ์โน้ตบุ๊กที่คุณจัดเตรียมไว้ บนคอนโซล Jupyter ให้เลือก ใหม่ จากนั้นเลือก Python 3 (วิทยาศาสตร์ข้อมูล) หรือคุณสามารถเข้าถึงไฟล์โค้ดตัวอย่างใน repo GitHub. คุณสามารถอัปโหลดไฟล์ไปยังอินสแตนซ์โน้ตบุ๊กเพื่อเรียกใช้โดยตรงหรือโคลนได้
GitHub repo มีโน้ตบุ๊กสามตัว:
data_processing.ipynbmodel_training.ipynbtopic_mapping_sentiment_generation.ipynb
ดำเนินการวิเคราะห์ข้อมูลเชิงสำรวจ
เราใช้โน้ตบุ๊กตัวแรก (data_processing.ipynb) เพื่อสำรวจและประมวลผลข้อมูล เราเริ่มต้นด้วยการโหลดข้อมูลจากบัคเก็ต S3 ลงใน 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)ในส่วนต่อไปนี้ เราทำการวิเคราะห์ข้อมูลเชิงสำรวจ (EDA) เพื่อทำความเข้าใจข้อมูล เราเริ่มต้นด้วยการสำรวจรูปร่างของข้อมูลและข้อมูลเมตา เพื่อความถูกต้อง เราใช้รีวิวที่ผ่านการตรวจสอบแล้วเท่านั้น
# 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())เราสำรวจจำนวนของแต่ละหมวดหมู่เพิ่มเติม และดูว่ามีข้อมูลที่ซ้ำกันหรือไม่
# 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()])เมื่อเราพอใจกับผลลัพธ์แล้ว เราจะไปยังขั้นตอนถัดไปของการประมวลผลข้อมูลล่วงหน้า Amazon Comprehend แนะนำให้จัดเตรียมเอกสารอย่างน้อย 1,000 ฉบับในงานสร้างแบบจำลองหัวข้อแต่ละงาน โดยแต่ละเอกสารมีความยาวอย่างน้อยสามประโยค เอกสารต้องอยู่ในไฟล์ข้อความรูปแบบ UTF-8 ในขั้นตอนต่อไปนี้ เราตรวจสอบให้แน่ใจว่าข้อมูลอยู่ในรูปแบบ UTF-8 ที่แนะนำ และอินพุตแต่ละรายการมีขนาดไม่เกิน 5,000 ไบต์
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)จากนั้นเราจะบันทึกข้อมูลไปยัง Amazon S3 และเก็บสำเนาในเครื่องไว้ในอินสแตนซ์โน้ตบุ๊ก
# 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}
เสร็จสิ้นขั้นตอนการประมวลผลข้อมูลของเรา
เรียกใช้งานการสร้างแบบจำลองหัวข้อ Amazon Comprehend
จากนั้นเราจะย้ายไปยังขั้นตอนถัดไป ซึ่งเราใช้ข้อมูลที่ประมวลผลล่วงหน้าเพื่อเรียกใช้งานการสร้างแบบจำลองหัวข้อโดยใช้ Amazon Comprehend ในขั้นตอนนี้ คุณสามารถใช้สมุดบันทึกที่สอง (model_training.ipynb) หรือใช้คอนโซล Amazon Comprehend เพื่อเรียกใช้งานการสร้างแบบจำลองหัวข้อ สำหรับคำแนะนำในการใช้คอนโซล โปรดดูที่ การรันงานวิเคราะห์โดยใช้คอนโซล. หากคุณใช้โน้ตบุ๊ก คุณสามารถเริ่มต้นด้วยการสร้างไคลเอ็นต์ Amazon Comprehend โดยใช้ Boto3 ดังที่แสดงในตัวอย่างต่อไปนี้
# 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)คุณสามารถส่งเอกสารสำหรับการสร้างแบบจำลองหัวข้อได้สองวิธี: หนึ่งเอกสารต่อไฟล์ หรือหนึ่งเอกสารต่อบรรทัด
เราเริ่มต้นด้วย 5 หัวข้อ (k-number) และใช้หนึ่งเอกสารต่อบรรทัด ไม่มีวิธีที่ดีที่สุดวิธีเดียวในการเลือก k หรือจำนวนหัวข้อ คุณอาจลองใช้ค่า k ที่แตกต่างกัน และเลือกค่าที่มีโอกาสเป็นไปได้มากที่สุด
# 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"งานสร้างแบบจำลองหัวข้อ Amazon Comprehend ของเรากำหนดให้คุณต้องผ่าน InputDataConfig วัตถุพจนานุกรมด้วย S3 InputFormatและ DocumentReadAction ตามพารามิเตอร์ที่จำเป็น ในทำนองเดียวกัน คุณต้องจัดเตรียม OutputDataConfig วัตถุที่มี S3 และ DataAccessRoleArn ตามพารามิเตอร์ที่จำเป็น สำหรับข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบ Boto3 สำหรับ 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,
}จากนั้น คุณสามารถเริ่มงานการตรวจหาหัวข้อแบบอะซิงโครนัสโดยส่งจำนวนหัวข้อ ออบเจ็กต์การกำหนดค่าอินพุต อ็อบเจ็กต์การกำหนดค่าเอาต์พุต และบทบาท IAM ตามที่แสดงในตัวอย่างต่อไปนี้
# 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)คุณสามารถติดตามสถานะปัจจุบันของงานได้โดยโทรไปที่ DescribeTopicDetectionJob การดำเนินการ. สถานะของงานสามารถเป็นอย่างใดอย่างหนึ่งต่อไปนี้:
- ส่งแล้ว – ได้รับงานแล้วและอยู่ในคิวสำหรับการประมวลผล
- IN_PROGRESS – Amazon Comprehend กำลังประมวลผลงาน
- เสร็จสิ้น – งานเสร็จสมบูรณ์และผลลัพธ์พร้อมใช้งาน
- FAILED – งานไม่เสร็จ
# 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)เมื่องานเสร็จสมบูรณ์ จะส่งคืนไฟล์บีบอัดที่มีไฟล์สองไฟล์: topic-terms.csv และ doc-topics.csv ไฟล์เอาต์พุตแรก topic-terms.csvเป็นรายการหัวข้อในคอลเล็กชัน สำหรับแต่ละหัวข้อ รายการจะรวมคำศัพท์ยอดนิยมตามหัวข้อตามน้ำหนักตามค่าเริ่มต้น ไฟล์ที่สอง doc-topics.csvแสดงรายการเอกสารที่เกี่ยวข้องกับหัวข้อและสัดส่วนของเอกสารที่เกี่ยวข้องกับหัวข้อนั้น เพราะเรากำหนด ONE_DOC_PER_LINE ก่อนหน้าใน input_doc_format ตัวแปร เอกสารจะถูกระบุโดยชื่อไฟล์และหมายเลขบรรทัดที่จัดทำดัชนี 0 ภายในไฟล์ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการสร้างแบบจำลองหัวข้อ โปรดดูที่ การสร้างแบบจำลองหัวข้อ.
ผลลัพธ์ของ Amazon Comprehend จะถูกคัดลอกในเครื่องสำหรับขั้นตอนต่อไปของเรา
# 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()เนื่องจากจำนวนหัวข้อมีน้อยกว่าคำศัพท์ที่เกี่ยวข้องกับการรวบรวมเอกสารมาก การแสดงพื้นที่หัวข้อจึงสามารถมองเป็นกระบวนการลดมิติได้เช่นกัน คุณสามารถใช้การแสดงพื้นที่หัวข้อนี้ของเอกสารเพื่อดำเนินการจัดกลุ่ม ในทางกลับกัน คุณสามารถวิเคราะห์ความถี่ของคำในแต่ละคลัสเตอร์เพื่อกำหนดหัวข้อที่เกี่ยวข้องกับแต่ละคลัสเตอร์ สำหรับโพสต์นี้ เราไม่ใช้เทคนิคอื่นๆ เช่น การจัดกลุ่ม
เราใช้สมุดบันทึกเล่มที่สาม (topic_mapping_sentiment_generation.ipynb) เพื่อค้นหาว่าผู้ใช้ในกลุ่มประชากรต่างๆ มีปฏิกิริยาอย่างไรต่อผลิตภัณฑ์ และวิเคราะห์ข้อมูลโดยรวมเกี่ยวกับความชอบของผู้ใช้ที่มีต่อผลิตภัณฑ์หนึ่งๆ
เราสามารถรวมเอาท์พุตจากสมุดบันทึกก่อนหน้าเพื่อรับหัวข้อและข้อกำหนดที่เกี่ยวข้องสำหรับแต่ละหัวข้อ อย่างไรก็ตาม หัวข้อมีการกำหนดหมายเลขและอาจอธิบายไม่ชัดเจน ดังนั้นเราจึงต้องการใช้ Human-in-the-loop ที่มีความรู้ด้านโดเมนและความเชี่ยวชาญในหัวข้อที่เพียงพอในการตั้งชื่อหัวข้อโดยดูจากเงื่อนไขที่เกี่ยวข้อง กระบวนการนี้ถือได้ว่าเป็นการแมปจากหมายเลขหัวข้อไปยังชื่อหัวข้อ อย่างไรก็ตาม เป็นที่น่าสังเกตว่ารายการคำศัพท์สำหรับหัวข้อสามารถรวมเข้าด้วยกันได้ ดังนั้นจึงอาจสร้างการแมปหลายรายการ มนุษย์ที่อยู่ในวงควรทำการแม็พตามบริบทของกรณีการใช้งาน มิฉะนั้น ประสิทธิภาพดาวน์สตรีมอาจได้รับผลกระทบ
เราเริ่มต้นด้วยการประกาศตัวแปร สำหรับแต่ละรีวิว อาจมีหลายหัวข้อ เรานับความถี่และเลือกหัวข้อที่พบบ่อยที่สุดสามหัวข้อ หัวข้อเหล่านี้ได้รับการรายงานเป็นหัวข้อที่เป็นตัวแทนของบทวิจารณ์ ขั้นแรก เรากำหนดตัวแปร TOP_TOPICS เพื่อให้มีจำนวนหัวข้อที่เป็นตัวแทนสูงสุด ประการที่สอง เรากำหนดและตั้งค่าเป็น language_code เพื่อรองรับพารามิเตอร์ภาษาที่จำเป็นของ Amazon Comprehend ในที่สุด เราก็สร้าง topicMapsซึ่งเป็นพจนานุกรมที่จับคู่หมายเลขหัวข้อกับชื่อหัวข้อ
# 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',
}
ต่อไป เราใช้ไฟล์ topic-terms.csv ที่สร้างโดย Amazon Comprehend เพื่อเชื่อมต่อเงื่อนไขเฉพาะที่เกี่ยวข้องกับแต่ละหัวข้อ จากนั้น โดยการใช้พจนานุกรมการแมปกับความสัมพันธ์ระหว่างหัวข้อกับคำศัพท์ เราจะเชื่อมโยงคำศัพท์เฉพาะกับชื่อหัวข้อ
# 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)การแมปนี้ช่วยปรับปรุงความสามารถในการอ่านและการอธิบายของหัวข้อที่สร้างโดย Amazon Comprehend ดังที่เราเห็นใน DataFrame ต่อไปนี้
นอกจากนี้เรายังรวมหมายเลขหัวข้อ เงื่อนไข และชื่อเข้ากับข้อมูลป้อนเข้าเริ่มต้น ดังที่แสดงในขั้นตอนต่อไปนี้
ส่งคืนเงื่อนไขหัวข้อและชื่อที่สอดคล้องกับบทวิจารณ์แต่ละรายการ หมายเลขหัวข้อและข้อกำหนดจะเข้าร่วมในการตรวจทานแต่ละครั้ง จากนั้นจึงรวมกลับมาที่ DataFrame เดิมที่เราบันทึกไว้ในสมุดบันทึกเล่มแรก
# 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()เราสร้างความรู้สึกสำหรับข้อความรีวิวโดยใช้ detect_sentiment. โดยจะตรวจสอบข้อความและส่งคืนการอนุมานของความเชื่อมั่นที่มีอยู่ (บวก เป็นกลาง ผสม หรือเชิงลบ)
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)ทั้งหัวข้อและความรู้สึกควบคู่ไปกับบทวิจารณ์ เนื่องจากเราจะรวบรวมหัวข้อและความรู้สึกในระดับผลิตภัณฑ์ เราจึงต้องสร้างคีย์ผสมโดยการรวมหัวข้อและความรู้สึกที่สร้างโดย 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']หลังจากนั้น เรารวบรวมที่ระดับผลิตภัณฑ์และนับคอมโพสิตคีย์สำหรับแต่ละผลิตภัณฑ์
ขั้นตอนสุดท้ายนี้ช่วยให้เราเข้าใจรายละเอียดของรีวิวต่อผลิตภัณฑ์และจัดหมวดหมู่ตามหัวข้อในลักษณะโดยรวมได้ดียิ่งขึ้น ตัวอย่างเช่น เราสามารถพิจารณาค่าที่แสดงสำหรับหัวข้อDF DataFrame สำหรับผลิตภัณฑ์แรก จากการรีวิวทั้งหมด โดยรวมแล้วลูกค้ามีประสบการณ์ที่ดีในการคืนสินค้า ขนาด และความสะดวกสบาย สำหรับผลิตภัณฑ์ที่สอง ลูกค้าส่วนใหญ่มีประสบการณ์แบบผสมถึงบวกในการคืนสินค้าและประสบการณ์เชิงบวกในด้านขนาดผลิตภัณฑ์
# 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 สุดท้ายของเราประกอบด้วยข้อมูลหัวข้อนี้และข้อมูลความรู้สึกที่รวมกลับไปยัง DataFrame สุดท้ายที่ชื่อว่า feedbackTopics ที่เราบันทึกไว้ใน Amazon S3 ในโน้ตบุ๊กเครื่องแรกของเรา
# 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)ใช้ Amazon QuickSight เพื่อแสดงภาพข้อมูล
คุณสามารถใช้ QuickSight เพื่อแสดงภาพข้อมูลและสร้างรายงาน QuickSight เป็นบริการข่าวกรองธุรกิจ (BI) ที่คุณสามารถใช้เพื่อใช้ข้อมูลจากแหล่งต่างๆ มากมายและสร้างแดชบอร์ดอัจฉริยะ ในตัวอย่างนี้ เราสร้างการวิเคราะห์ QuickSight โดยใช้ชุดข้อมูลสุดท้ายที่เราสร้างขึ้น ดังที่แสดงในการแสดงภาพตัวอย่างต่อไปนี้
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Amazon QuickSight โปรดดูที่ เริ่มต้นใช้งาน Amazon Quicksight.
ทำความสะอาด
ในตอนท้าย เราต้องปิดอินสแตนซ์โน้ตบุ๊กที่เราใช้ในการทดลองนี้จากคอนโซล AWS
สรุป
ในโพสต์นี้ เราสาธิตวิธีใช้ Amazon Comprehend เพื่อวิเคราะห์บทวิจารณ์ผลิตภัณฑ์และค้นหาหัวข้อยอดนิยมโดยใช้การสร้างแบบจำลองหัวข้อเป็นเทคนิค การสร้างแบบจำลองหัวข้อช่วยให้คุณดูหัวข้อต่างๆ และจัดระเบียบ ทำความเข้าใจ และสรุปในขนาดต่างๆ ได้ คุณสามารถค้นพบรูปแบบที่ซ่อนอยู่ซึ่งปรากฏอยู่ในข้อมูลได้อย่างรวดเร็วและง่ายดาย จากนั้นใช้ข้อมูลเชิงลึกนั้นเพื่อตัดสินใจโดยใช้ข้อมูลเป็นหลัก คุณสามารถใช้การสร้างแบบจำลองหัวข้อเพื่อแก้ปัญหาทางธุรกิจมากมาย เช่น การติดแท็กตั๋วการสนับสนุนลูกค้าโดยอัตโนมัติ การกำหนดเส้นทางการสนทนาไปยังทีมที่เหมาะสมตามหัวข้อ การตรวจจับความเร่งด่วนของตั๋วการสนับสนุน การได้รับข้อมูลเชิงลึกที่ดีขึ้นจากการสนทนา การสร้างแผนที่ขับเคลื่อนด้วยข้อมูล การสร้างปัญหา -เน้นเนื้อหา ปรับปรุงกลยุทธ์การขาย และระบุปัญหาของลูกค้าและความขัดแย้ง
นี่เป็นเพียงตัวอย่างบางส่วน แต่คุณสามารถนึกถึงปัญหาทางธุรกิจอีกมากมายที่คุณเผชิญในองค์กรของคุณในแต่ละวัน และวิธีที่คุณสามารถใช้การสร้างแบบจำลองหัวข้อกับเทคนิค ML อื่นๆ เพื่อแก้ปัญหาเหล่านั้น
เกี่ยวกับผู้เขียน
gurpreet เป็นนักวิทยาศาสตร์ข้อมูลที่มี AWS Professional Services ซึ่งตั้งอยู่ในแคนาดา เธอหลงใหลในการช่วยลูกค้าสร้างสรรค์นวัตกรรมด้วยการเรียนรู้ของเครื่องและเทคโนโลยีปัญญาประดิษฐ์เพื่อดึงมูลค่าทางธุรกิจและข้อมูลเชิงลึกจากข้อมูล ในเวลาว่าง เธอชอบเดินป่ากลางแจ้งและอ่านหนังสือi
รัชดี ชามส์ เป็นนักวิทยาศาสตร์ข้อมูลกับ AWS Professional Services ประเทศแคนาดา เขาสร้างผลิตภัณฑ์แมชชีนเลิร์นนิงสำหรับลูกค้า AWS เขาชอบอ่านและเขียนนิยายวิทยาศาสตร์
Wrick ตะลักดาร์ เป็นสถาปนิกอาวุโสกับทีมงาน Amazon Comprehend Service เขาทำงานร่วมกับลูกค้า AWS เพื่อช่วยให้พวกเขานำแมชชีนเลิร์นนิงมาใช้ในวงกว้าง นอกเวลางาน เขาชอบอ่านหนังสือและถ่ายภาพ
- AI
- ไอ อาร์ต
- เครื่องกำเนิดไออาร์ท
- หุ่นยนต์ไอ
- AI / ML
- เข้าใจ Amazon
- อเมซอน QuickSight
- อเมซอน SageMaker
- ปัญญาประดิษฐ์
- ใบรับรองปัญญาประดิษฐ์
- ปัญญาประดิษฐ์ในการธนาคาร
- หุ่นยนต์ปัญญาประดิษฐ์
- หุ่นยนต์ปัญญาประดิษฐ์
- ซอฟต์แวร์ปัญญาประดิษฐ์
- AWS Machine Learning AWS
- blockchain
- การประชุม blockchain ai
- เหรียญอัจฉริยะ
- ปัญญาประดิษฐ์สนทนา
- การประชุม crypto ai
- ดัล-อี
- การเรียนรู้ลึก ๆ
- google ai
- เรียนรู้เครื่อง
- ประมวลผลภาษาธรรมชาติ
- เพลโต
- เพลโตไอ
- เพลโตดาต้าอินเทลลิเจนซ์
- เกมเพลโต
- เพลโตดาต้า
- เพลโตเกม
- ขนาดไอ
- วากยสัมพันธ์
- ลมทะเล
