Szerezzen jobb betekintést az értékelésekből az Amazon Comprehend használatával

„A vásárlók 85%-a annyira bízik az online véleményekben, mint a személyes ajánlásokban” – Gartner

A fogyasztók egyre inkább kapcsolatba lépnek a vállalkozásokkal digitális felületeken és több érintkezési ponton keresztül. A statisztikák azt mutatják, hogy a vásárlók többsége értékelések alapján dönti el, milyen termékeket vásároljon, és milyen szolgáltatásokat vegyen igénybe. Szerint Spiegel Kutatóközpont, az öt véleményt tartalmazó termék vásárlási valószínűsége 270%-kal nagyobb, mint egy értékelés nélküli termék vásárlási valószínűsége. A vélemények befolyásolhatják a fogyasztói döntéseket és erősíthetik a márka értékét.

Ebben a bejegyzésben használjuk Amazon Comprehend A termékismertetőkből érdemi információk kinyerése, elemzése annak megértése érdekében, hogy a különböző demográfiai csoportokhoz tartozó felhasználók hogyan reagálnak a termékekre, és összesített információkat fedezhet fel a felhasználók termék iránti affinitásáról. Az Amazon Comprehend egy teljesen felügyelt és folyamatosan képzett természetes nyelvi feldolgozási (NLP) szolgáltatás, amely képes betekintést nyerni egy dokumentum vagy szöveg tartalmába.

Megoldás áttekintése

Manapság az ügyfelek különféle módokon adhatnak véleményeket, például csillagozással, szabad szöveges vagy természetes nyelvezetekkel, vagy közösségi média megosztásokkal. A szabad szöveges vagy természetes nyelvű vélemények segítenek a bizalomépítésben, mivel ez a fogyasztók független véleménye. A termékcsapatok gyakran használják, hogy véleményezési csatornákon keresztül lépjenek kapcsolatba az ügyfelekkel. Bizonyított tény, hogy amikor a vásárlók úgy érzik, hogy meghallják, javul a márkával kapcsolatos érzésük. Míg a csillagos értékelések vagy a közösségi médiában való megosztások elemzése viszonylag egyszerűbb, a természetes nyelvű vagy szabad szövegű vélemények számos kihívást jelentenek, például kulcsszavak vagy kifejezések, témák vagy fogalmak azonosítása, valamint a hangulat- vagy entitásszintű érzelmek meghatározása. A kihívást elsősorban az írott szöveg hosszának változékonysága és a jelek és a zaj valószínű jelenléte okozza. Ezenkívül az információ lehet nagyon világos és egyértelmű (például kulcsszavakkal és kulcskifejezésekkel), vagy nem egyértelmű és implicit (absztrakt témák és fogalmak). Még nagyobb kihívást jelent a különféle érzelmek megértése és a megfelelő termékekkel és szolgáltatásokkal való összekapcsolása. Mindazonáltal rendkívül fontos megérteni ezeket az információkat és szöveges jeleket, hogy súrlódásmentes vásárlói élményt nyújthassunk.

Ebben a bejegyzésben egy nyilvánosan elérhető NLP – fast.ai adatkészlet a vásárlók termékértékeléseinek elemzéséhez. Kezdjük egy felügyelet nélküli gépi tanulási (ML) technikával, amelyet témamodellezésként ismerünk. Ez egy népszerű, felügyelet nélküli technika, amely olyan elvont témákat fedez fel, amelyek egy szöveges áttekintés gyűjteményében előfordulhatnak. A témamodellezés olyan klaszterezési probléma, amely nem felügyelt, ami azt jelenti, hogy a modellek nem ismerik a lehetséges célváltozókat (például az áttekintésben szereplő témákat). A témák klaszterekként jelennek meg. A klaszterek számát egy dokumentumkorpusban gyakran szakterületi szakértők segítségével, vagy valamilyen szokásos statisztikai elemzéssel határozzák meg. A modellkimenetek általában három összetevőből állnak: számozott klaszterek (0. témakör, 1. témakör és így tovább), az egyes klaszterekhez társított kulcsszavak és minden dokumentumhoz (vagy esetünkben áttekintéshez) tartozó reprezentatív klaszterek. A témamodellek eredendő természetüknél fogva nem generálnak ember által olvasható címkéket a klaszterekhez vagy témákhoz, ami általános tévhit. A témamodellezéssel kapcsolatban általában meg kell jegyeznünk, hogy ez egy vegyes tagsági modell – a modellben található minden dokumentum hasonlóságot mutathat minden témával. A témamodell egy iteratív bayesi folyamat során tanul meg annak meghatározására, hogy az egyes dokumentumok egy adott témához vagy témához kapcsolódnak. A modell kimenete a témakörök számának optimális kiválasztásától függ. Kis témakör esetén a témakörök túl tágak lehetnek, nagyobb számú téma pedig redundáns vagy hasonló témákat eredményezhet. A témamodellek értékelésének számos módja van:

• Emberi megítélés – Megfigyelésen alapuló, értelmezésen alapuló
• Kvantitatív mérőszámok – Zavar, koherencia számítások
• Vegyes megközelítés – Az ítéleten alapuló és a kvantitatív megközelítések kombinációja

A zavartságot úgy számítják ki, hogy egy adatkészletet két részre osztanak – egy tanítókészletre és egy tesztkészletre. A valószínűséget általában logaritmusként számítják ki, ezért ezt a mérőszámot néha kitartott log-likelihoodnak nevezik. A zavarodottság egy prediktív mérőszám. Felméri a témamodell azon képességét, hogy megjósolja a tesztkészletet, miután egy képzési sorozaton betanították. A zavartság egyik hiányossága, hogy nem ragadja meg a kontextust, vagyis nem ragadja meg a témában szereplő szavak vagy a dokumentumban szereplő témák közötti kapcsolatot. A szemantikai kontextus gondolata azonban fontos az emberi megértés szempontjából. Hasznosak lehetnek az olyan intézkedések, mint a szavak egyidejű előfordulásának feltételes valószínűsége egy témában. Ezeket a megközelítéseket összefoglalóan koherenciának nevezzük. Ebben a bejegyzésben az emberi megítélés (megfigyelés-alapú) megközelítésre összpontosítunk, nevezetesen a téma legjobb n szójának megfigyelésére.

A megoldás a következő magas szintű lépésekből áll:

1. Állítson be egy Amazon SageMaker notebook példány.
2. Hozzon létre egy jegyzetfüzetet.
3. Végezzen feltáró adatelemzést.
4. Futtassa az Amazon Comprehend témamodellezési feladatát.
5. Generáljon témákat és értse meg a hangulatot.
6. Felhasználás Amazon QuickSight adatok megjelenítésére és jelentések készítésére.

Ezt a megoldást bármely AWS-régióban használhatja, de meg kell győződnie arról, hogy az Amazon Comprehend API-k és a SageMaker ugyanabban a régióban vannak. Ehhez a bejegyzéshez az US East régiót (N. Virginia) használjuk.

Állítsa be a SageMaker notebook példányát

Az Amazon Comprehend szolgáltatással kapcsolatba léphet a AWS felügyeleti konzol, AWS parancssori interfész (AWS CLI)vagy Amazon Comprehend API. További információkért lásd: Az Amazon Comprehend használatának első lépései. Ebben a bejegyzésben SageMaker notebookot és Python (Boto3) kódot használunk az Amazon Comprehend API-kkal való interakcióhoz.

1. Az Amazon SageMaker konzolon a navigációs panel Jegyzetfüzet részében válassza a lehetőséget
   Notebook példányok.
2. Válassza a Jegyzetfüzetpéldány létrehozása lehetőséget.
3. Adja meg a notebook példány nevét, és állítsa be a példánytípust ml.r5.2xlarge értékre.
4. Hagyja a többi alapértelmezett beállítást.
5. Létrehozása AWS Identity and Access Management (IAM) szereppel AmazonSageMakerFullAccess és hozzáférjen minden szükségeshez Amazon Simple Storage Service (Amazon S3) vödrök és Amazon Comprehend API-k.
6. Válassza a Jegyzetfüzetpéldány létrehozása lehetőséget.
   Néhány perc múlva a notebook példánya készen áll.
7. Az Amazon Comprehend notebook példányból való eléréséhez csatolnia kell a ComprehendFullAccess az Ön IAM-szerepére.

Az Amazon Comprehend biztonsági áttekintését lásd: Biztonság az Amazon Comprehendben.

Miután megnyitotta a kiépített jegyzetfüzet-példányt, a Jupyter-konzolon válassza az Új, majd a Python 3 (Data Science) lehetőséget. Alternatív megoldásként elérheti a mintakódfájlt a GitHub repo. Feltöltheti a fájlt a jegyzetfüzet-példányra, és közvetlenül futtathatja, vagy klónozhatja.

A GitHub repo három notebookot tartalmaz:

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

Végezzen feltáró adatelemzést

Az első notebookot használjuk (data_processing.ipynb) az adatok feltárására és feldolgozására. Kezdjük azzal, hogy egyszerűen betöltjük az adatokat egy S3 vödörből egy DataFrame-be.

# 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)

A következő részben feltáró adatelemzést (EDA) végzünk az adatok megértése érdekében. Kezdjük az adatok és a metaadatok alakjának feltárásával. A hitelesség érdekében csak ellenőrzött véleményeket használunk.

# 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())

Tovább vizsgáljuk az egyes kategóriák számát, és megnézzük, vannak-e ismétlődő adatok.

# 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()])

Ha elégedettek vagyunk az eredménnyel, áttérünk az adatok előfeldolgozásának következő lépésére. Az Amazon Comprehend azt javasolja, hogy minden témamodellezési feladathoz legalább 1,000 dokumentumot adjon meg, és minden dokumentum legalább három mondatos legyen. A dokumentumoknak UTF-8 formátumú szövegfájlokban kell lenniük. A következő lépésben megbizonyosodunk arról, hogy az adatok az ajánlott UTF-8 formátumban vannak, és az egyes bemenetek mérete nem haladja meg az 5,000 bájtot.

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)

Ezután mentjük az adatokat az Amazon S3-ba, és egy helyi másolatot is tárolunk a notebook példányban.

# 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}

Ezzel lezárult az adatfeldolgozási szakaszunk.

Futtasson egy Amazon Comprehend témamodellező munkát

Ezután áttérünk a következő fázisra, ahol az előfeldolgozott adatok segítségével témamodellezési feladatot futtatunk az Amazon Comprehend segítségével. Ebben a szakaszban használhatja a második jegyzetfüzetet (model_training.ipynb), vagy használja az Amazon Comprehend konzolt a témamodellezési feladat futtatásához. A konzol használatára vonatkozó utasításokat lásd: Elemzési feladatok futtatása a konzol segítségével. Ha a notebookot használja, először létrehozhat egy Amazon Comprehend klienst a Boto3 használatával, ahogy az a következő példában látható.

# 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)

Dokumentumait témamodellezéshez kétféleképpen küldheti be: fájlonként egy dokumentumot vagy soronként egy dokumentumot.

5 témával kezdünk (k-szám), és soronként egy dokumentumot használunk. Nincs egyetlen legjobb módszer a k vagy a témák számának kiválasztására. Kipróbálhatja k különböző értékeit, és kiválaszthatja azt, amelyiknek a legnagyobb a valószínűsége.

# 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"

Az Amazon Comprehend témamodellezési munkánk során teljesíteni kell egy InputDataConfig szótár objektum S3-mal, InputFormatés DocumentReadAction mint szükséges paraméterek. Hasonlóképpen meg kell adnia a OutputDataConfig objektum S3 és DataAccessRoleArn mint szükséges paraméterek. További információkért tekintse meg a Boto3 dokumentációját 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,
}

Ezután elindíthat egy aszinkron témaészlelési feladatot a témakörök számának, a bemeneti konfigurációs objektumnak, a kimeneti konfigurációs objektumnak és egy IAM-szerepnek a megadásával, a következő példában látható módon.

# 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)

A munka aktuális állapotát a telefonszámon követheti nyomon DescribeTopicDetectionJob művelet. A munka állapota a következők egyike lehet:

• ELKÜLDVE – A feladat érkezett, és feldolgozásra várakozik
• IN_PROGRESS – Az Amazon Comprehend feldolgozza a munkát
• BEFEJEZETT – A feladat sikeresen befejeződött, és a kimenet elérhető
• SIKERTELEN – A feladat nem fejeződött be

# 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)

Amikor a feladat sikeresen befejeződött, egy tömörített archívumot ad vissza, amely két fájlt tartalmaz: topic-terms.csv és doc-topics.csv. Az első kimeneti fájl, topic-terms.csv, a gyűjtemény témáinak listája. A lista alapértelmezés szerint minden témakörhöz tartalmazza a legfontosabb kifejezéseket, súlyuk szerint. A második fájl, doc-topics.csv, felsorolja a témához kapcsolódó dokumentumokat és a dokumentumnak a témával kapcsolatos arányát. Mert megadtuk ONE_DOC_PER_LINE korábban a input_doc_format változó, a dokumentumot a fájl neve és a fájlon belüli 0 indexű sorszám azonosítja. A témamodellezéssel kapcsolatos további információkért lásd: Témamodellezés.
Az Amazon Comprehend kimeneteit helyileg másoljuk a következő lépéseinkhez.

# 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()

Mivel a témák száma jóval kevesebb, mint a dokumentumgyűjteményhez tartozó szókincs, a tématér-reprezentáció egy dimenziócsökkentő folyamatként is felfogható. A dokumentumok e témakör-ábrázolását használhatja fürtözés végrehajtására. Másrészt elemezheti a szavak gyakoriságát az egyes klaszterekben, hogy meghatározza az egyes fürtökhöz tartozó témákat. Ebben a bejegyzésben nem hajtunk végre semmilyen más technikát, például klaszterezést.

A harmadik jegyzetfüzetet használjuk (topic_mapping_sentiment_generation.ipynb).

Kombinálhatjuk az előző jegyzetfüzet kimeneteit, hogy témaköröket és kapcsolódó kifejezéseket kapjunk az egyes témákhoz. A témák azonban meg vannak számozva, és előfordulhat, hogy nem magyarázható. Ezért előnyben részesítjük a megfelelő tartományismerettel és szakértelemmel rendelkező embert a témakörben ahhoz, hogy a kapcsolódó kifejezések alapján elnevezzük a témákat. Ez a folyamat a témaszámok és a témanevek közötti leképezésnek tekinthető. Figyelemre méltó azonban, hogy a témákhoz tartozó kifejezések egyéni listája kölcsönösen magában foglalhatja, és ezért több leképezést is létrehozhat. A hurokban lévő embernek formalizálnia kell a leképezéseket a használati eset kontextusa alapján. Ellenkező esetben hatással lehet a downstream teljesítményre.

Kezdjük a változók deklarálásával. Minden értékeléshez több téma is tartozhat. Számoljuk gyakoriságukat, és legfeljebb három leggyakoribb témát választunk ki. Ezek a témák az áttekintés reprezentatív témáiként jelennek meg. Először definiálunk egy változót TOP_TOPICS a maximális számú reprezentatív téma megtartására. Másodszor, meghatározzuk és beállítjuk az értékeket a language_code változó támogatja az Amazon Comprehend szükséges nyelvi paraméterét. Végül alkotunk topicMaps, amely egy szótár, amely a témaszámokat témanevekre képezi le.

# 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',
}

Ezután az Amazon Comprehend által generált topic-terms.csv fájlt használjuk az egyes témákhoz társított egyedi kifejezések összekapcsolására. Ezután a leképezési szótár segítségével erre a témakifejezés-társításra az egyedi kifejezéseket a témanevekhez kapcsoljuk.

# 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)

Ez a leképezés javítja az Amazon Comprehend által generált témák olvashatóságát és magyarázhatóságát, amint azt a következő DataFrame-ben láthatjuk.

Továbbá a témaszámot, a kifejezéseket és a neveket összekapcsoljuk a kezdeti bemeneti adatokkal, a következő lépések szerint.

Ez visszaadja az egyes véleményeknek megfelelő témakifejezéseket és -neveket. A témaszámokat és kifejezéseket minden áttekintésnél összekapcsoljuk, majd visszacsatoljuk az eredeti DataFrame-hez, amelyet az első jegyzetfüzetbe mentettünk.

# 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()

A vélemény szövegéhez hangulatot generálunk a használatával detect_sentiment. Megvizsgálja a szöveget, és következtetést ad vissza az uralkodó hangulatról (POZITÍV, SEMMILYEN, VEGYES vagy NEGATÍV).

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)

Mind a témák, mind az érzések szorosan párosulnak az értékelésekkel. Mivel a témákat és a véleményeket termékszinten fogjuk összesíteni, összetett kulcsot kell létrehoznunk az Amazon Comprehend által generált témák és érzések kombinálásával.

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

Ezt követően termékszinten összesítjük, és minden egyes termékhez megszámoljuk az összetett kulcsokat.

Ez az utolsó lépés segít abban, hogy jobban megértsük a vélemények termékenkénti részletességét, és témánként összesített módon kategorizáljuk őket. Például figyelembe vehetjük a topicDF DataFrame értékét. Az első termékről, a rá vonatkozó összes vélemény közül, a vásárlók összességében pozitív tapasztalatokat szereztek a termék visszavételével, méretével és kényelmével kapcsolatban. A második termék esetében a vásárlók többnyire vegyes-pozitív tapasztalattal rendelkeztek a termékvisszaküldésről és pozitív tapasztalatokról a termékméretről.

# 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()

A végső DataFrame-ünk ebből a témakörből és a hangulati információkból áll, amelyek vissza vannak kapcsolva a végső DataFrame-hez. feedbackTopics amit az Amazon S3-ra mentettünk az első notebookunkba.

# 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)

Az adatok megjelenítéséhez használja az Amazon QuickSight-ot

A QuickSight segítségével megjelenítheti az adatokat és jelentéseket készíthet. A QuickSight egy üzleti intelligencia (BI) szolgáltatás, amellyel számos különböző forrásból származó adatokat fogyaszthat, és intelligens irányítópultokat hozhat létre. Ebben a példában egy QuickSight-elemzést hozunk létre az általunk készített végső adatkészlet felhasználásával, amint azt a következő példa-vizualizációk mutatják.

Ha többet szeretne megtudni az Amazon QuickSightról, tekintse meg a Az Amazon Quicksight első lépései.

Razzia

A végén le kell zárnunk a kísérletben használt notebook példányt az AWS konzolról.

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan használható az Amazon Comprehend termékértékelések elemzésére és a témamodellezés technikájával a legfontosabb témák megtalálására. A témamodellezés lehetővé teszi, hogy több témát nézzen át, és azokat nagy méretekben rendezze, megértse és összefoglalja. Gyorsan és egyszerűen felfedezheti az adatokban jelenlévő rejtett mintákat, majd felhasználhatja ezt a betekintést adatvezérelt döntések meghozatalához. A témamodellezés segítségével számos üzleti probléma megoldható, mint például az ügyfélszolgálati jegyek automatikus címkézése, a beszélgetések téma alapján a megfelelő csapatokhoz való irányítása, a támogatási jegyek sürgősségének észlelése, jobb betekintés a beszélgetésekből, adatvezérelt tervek létrehozása, probléma létrehozása. - fókuszált tartalom, az értékesítési stratégia javítása, valamint az ügyfelekkel kapcsolatos problémák és súrlódások azonosítása.

Ez csak néhány példa, de gondolhat még sok üzleti probléma, amellyel a szervezetében naponta szembesül, és hogyan használhatja a témamodellezést más ML technikákkal ezek megoldására.

---

A szerzőkről

Gurpreet a kanadai székhelyű AWS Professional Services adattudós. Szenvedélyesen támogatja ügyfeleit a gépi tanulás és a mesterséges intelligencia technológiákkal történő innovációban, hogy üzleti értéket és betekintést nyerhessenek az adatokból. Szabadidejében szívesen túrázik a szabadban és könyveket olvas.i

Rushdi Shams az AWS Professional Services adatkutatója, Kanada. Gépi tanulási termékeket készít az AWS-ügyfelek számára. Szeret sci-fi-ket olvasni és írni.

Wrick Talukdar vezető építész az Amazon Comprehend Service csapatánál. Együttműködik az AWS-ügyfelekkel, hogy segítse őket a gépi tanulás széles körben történő alkalmazásában. Munkán kívül szeret olvasni és fotózni.