Amazon Comprehendi abil saate arvustustest parema ülevaate

"85% ostjatest usaldavad veebiarvustusi sama palju kui isiklikku soovitust" - Gartner

Tarbijad suhtlevad ettevõtetega üha enam digitaalsete pindade ja mitmete puutepunktide kaudu. Statistika näitab, et enamik ostjaid kasutab arvustusi, et otsustada, milliseid tooteid osta ja milliseid teenuseid kasutada. Kohta Spiegeli uurimiskeskus, on viie arvustusega toote ostutõenäosus 270% suurem kui arvustusteta toote ostmise tõenäosus. Arvustused võivad mõjutada tarbija otsuseid ja tugevdada brändi väärtust.

Selles postituses kasutame Amazoni mõistmine tooteülevaadetest sisulise teabe hankimiseks, analüüsimiseks, et mõista, kuidas erineva demograafilise rühma kasutajad toodetele reageerivad, ja koondteavet kasutajate seotuse kohta tootega. Amazon Comprehend on täielikult hallatav ja pidevalt koolitatud loomuliku keele töötlemise (NLP) teenus, mis võimaldab saada ülevaate dokumendi või teksti sisust.

Lahenduse ülevaade

Tänapäeval saavad kliendid arvustusi esitada mitmel viisil, näiteks tärnide, vaba teksti või loomuliku keele või sotsiaalmeedia jagamise kaudu. Vaba teksti või loomulikus keeles arvustused aitavad usaldust luua, kuna see on tarbijate sõltumatu arvamus. Tootetiimid kasutavad seda sageli klientidega suhtlemiseks arvustuskanalite kaudu. On tõestatud tõsiasi, et kui kliendid tunnevad end ära kuulatuna, paraneb nende tunne brändi suhtes. Kui tärnide reitinguid või sotsiaalmeedias jagamisi on suhteliselt lihtsam analüüsida, siis loomulikus keeles või vaba tekstiga arvustused esitavad mitmeid väljakutseid, nagu märksõnade või fraaside, teemade või mõistete ning sentimentide või olemitaseme tunnete tuvastamine. Väljakutse on peamiselt tingitud kirjaliku teksti pikkuse varieeruvusest ja nii signaalide kui ka müra usutavast olemasolust. Lisaks võib teave olla väga selge ja selge (näiteks märksõnade ja võtmefraasidega) või ebaselge ja kaudne (abstraktsed teemad ja mõisted). Veelgi keerulisem on mõista erinevat tüüpi tundeid ja seostada neid sobivate toodete ja teenustega. Sellegipoolest on ülimalt oluline mõista seda teavet ja tekstilisi signaale, et pakkuda hõõrdumatut kliendikogemust.

Selles postituses kasutame avalikult kättesaadavat NLP – fast.ai andmestik, et analüüsida klientide esitatud tootearvustusi. Alustuseks kasutame järelevalveta masinõppe (ML) tehnikat, mida tuntakse teemade modelleerimisena. See on populaarne järelevalveta tehnika, mis avastab abstraktsed teemad, mis tekstiülevaate kogus esineda võivad. Teemade modelleerimine on rühmitamise probleem, mis on järelevalveta, mis tähendab, et mudelitel pole teadmisi võimalike sihtmuutujate kohta (nt ülevaate teemad). Teemad on esindatud klastritena. Sageli otsustatakse klastrite arv dokumendikorpuses valdkonnaekspertide abiga või mõne standardse statistilise analüüsi abil. Mudeli väljunditel on üldiselt kolm komponenti: nummerdatud klastrid (teema 0, teema 1 ja nii edasi), iga klastriga seotud märksõnad ja iga dokumendi (või meie puhul ülevaate) tüüpilised klastrid. Oma olemuselt ei loo teemamudelid klastritele või teemadele inimloetavaid silte, mis on levinud eksiarvamus. Teemade modelleerimisel üldiselt tasub tähele panna, et see on segatüüpi liikmelisuse mudel – mudeli igal dokumendil võib olla sarnasust iga teemaga. Teemamudel õpib iteratiivse Bayesi protsessi käigus määrama tõenäosuse, et iga dokument on seotud antud teema või teemaga. Mudeli väljund sõltub teemade arvu optimaalsest valikust. Väike teemade arv võib põhjustada liiga laiaulatuslikke teemasid ja suurem teemade arv võib põhjustada üleliigseid või sarnaseid teemasid. Teemamudelite hindamiseks on mitu võimalust:

• Inimese hinnang – vaatluspõhine, tõlgenduspõhine
• Kvantitatiivsed mõõdikud – Hämmelduse, sidususe arvutused
• Segalähenemine – otsustuspõhiste ja kvantitatiivsete lähenemisviiside kombinatsioon

Hämmastus arvutatakse, jagades andmestiku kaheks osaks – treeningkomplektiks ja testikomplektiks. Tõenäosus arvutatakse tavaliselt logaritmina, seetõttu nimetatakse seda mõõdikut mõnikord väljalükatud logaritmi tõenäosuseks. Hämmeldus on ennustav mõõdik. See hindab teemamudeli võimet ennustada testikomplekti pärast koolituskomplekti läbimist. Üks segaduse puudusi on see, et see ei taba konteksti, mis tähendab, et see ei jäädvusta suhet teemas sisalduvate sõnade või dokumendi teemade vahel. Semantilise konteksti idee on aga inimese mõistmiseks oluline. Abiks võivad olla sellised meetmed nagu sõnade samaaegse esinemise tingimuslik tõenäosus teemas. Neid lähenemisviise nimetatakse ühiselt sidususeks. Selle postituse puhul keskendume inimlikule (vaatluspõhisele) hinnangule, nimelt teema n kõige populaarsema sõna jälgimisele.

Lahendus koosneb järgmistest kõrgetasemelistest sammudest:

1. Seadistage Amazon SageMaker märkmiku eksemplar.
2. Loo märkmik.
3. Tehke uurimuslik andmete analüüs.
4. Käivitage oma Amazon Comprehendi teemamodelleerimise töö.
5. Looge teemasid ja mõistke meeleolu.
6. Kasutama Amazon QuickSight andmete visualiseerimiseks ja aruannete genereerimiseks.

Saate seda lahendust kasutada mis tahes AWS-i piirkonnas, kuid peate veenduma, et Amazon Comprehend API-d ja SageMaker asuvad samas piirkonnas. Selle postituse jaoks kasutame USA idapiirkonda (N. Virginia).

Seadistage oma SageMakeri märkmiku eksemplar

Amazon Comprehendiga saate suhelda selle kaudu AWS-i juhtimiskonsool, AWS-i käsurealiides (AWS-i CLI)või Amazon Comprehend API. Lisateabe saamiseks vaadake Amazon Comprehendiga alustamine. Kasutame selles postituses SageMakeri sülearvutit ja Pythoni (Boto3) koodi, et suhelda Amazon Comprehend API-dega.

1. Valige Amazon SageMakeri konsooli navigeerimispaani jaotises Märkmik
   Märkmiku eksemplarid.
2. Valige Loo märkmiku eksemplar.
3. Määrake märkmiku eksemplari nimi ja määrake eksemplari tüübiks ml.r5.2xlarge.
4. Jätke ülejäänud vaikeseaded.
5. Loo AWS-i identiteedi ja juurdepääsu haldus (IAM) rolli koos AmazonSageMakerFullAccess ja juurdepääs kõigele vajalikule Amazon Simple Storage Service (Amazon S3) ämbrid ja Amazon Comprehend API-d.
6. Valige Loo märkmiku eksemplar.
   Mõne minuti pärast on teie märkmiku eksemplar valmis.
7. Amazon Comprehendile juurdepääsuks sülearvuti eksemplari kaudu peate lisama ComprehendFullAccess teie IAM-i rolli poliitika.

Amazon Comprehendi turbeülevaate saamiseks vaadake Turvalisus Amazon Comprehendis.

Pärast ette valmistatud märkmiku eksemplari avamist valige Jupyteri konsoolis Uus ja seejärel Python 3 (Data Science). Teise võimalusena pääsete juurde ka näidiskoodifailile GitHub repo. Saate faili üles laadida märkmiku eksemplari, et seda otse käitada või kloonida.

GitHubi repo sisaldab kolme sülearvutit:

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

Tehke uurimuslik andmete analüüs

Kasutame esimest märkmikku (data_processing.ipynb) andmete uurimiseks ja töötlemiseks. Alustame lihtsalt andmete laadimisega S3 ämbrist DataFrame'i.

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

Järgmises jaotises teostame andmete mõistmiseks uurimuslikku andmeanalüüsi (EDA). Alustuseks uurime andmete ja metaandmete kuju. Autentsuse tagamiseks kasutame ainult kinnitatud arvustusi.

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

Uurime täiendavalt iga kategooria arvu ja vaatame, kas esineb dubleerivaid andmeid.

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

Kui oleme tulemustega rahul, liigume andmete eeltöötluse järgmise etapi juurde. Amazon Comprehend soovitab igas teemamodelleerimistöös esitada vähemalt 1,000 dokumenti, kusjuures iga dokument on vähemalt kolm lauset pikk. Dokumendid peavad olema UTF-8 vormingus tekstifailides. Järgmises etapis veendume, et andmed on soovitatud UTF-8 vormingus ja iga sisendi suurus ei ületa 5,000 baiti.

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)

Seejärel salvestame andmed Amazon S3-sse ja hoiame sülearvuti eksemplaris ka kohalikku koopiat.

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

See lõpetab meie andmetöötlusetapi.

Tehke Amazon Comprehendi teemamodelleerimistööd

Seejärel liigume järgmisse faasi, kus kasutame eeltöödeldud andmeid teemade modelleerimise töö tegemiseks Amazon Comprehendi abil. Selles etapis saate kasutada kas teist märkmikku (model_training.ipynb) või kasutage teemamodelleerimistöö käitamiseks Amazon Comprehendi konsooli. Konsooli kasutamise juhised leiate aadressilt Analüüsitööde käitamine konsooli abil. Kui kasutate sülearvutit, võite alustada Amazon Comprehendi kliendi loomisest Boto3 abil, nagu on näidatud järgmises näites.

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

Teema modelleerimiseks saate dokumente esitada kahel viisil: üks dokument faili kohta või üks dokument rea kohta.

Alustame 5 teemaga (k-arv) ja kasutame ühte dokumenti rea kohta. K või teemade arvu valimiseks pole tavapärast parimat viisi. Võite proovida erinevaid k väärtusi ja valida suurima tõenäosusega.

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

Meie Amazon Comprehendi teemamodelleerimistöö nõuab, et läbiksite a InputDataConfig sõnastikuobjekt koos S3-ga, InputFormatja DocumentReadAction nõutavate parameetritena. Samamoodi peate esitama OutputDataConfig objekt S3-ga ja DataAccessRoleArn nõutavate parameetritena. Lisateabe saamiseks vaadake Boto3 dokumentatsiooni 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,
}

Seejärel saate käivitada asünkroonse teematuvastustöö, edastades teemade arvu, sisendkonfiguratsiooniobjekti, väljundi konfiguratsiooniobjekti ja IAM-i rolli, nagu on näidatud järgmises näites.

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

Töö hetkeseisu saate jälgida helistades DescribeTopicDetectionJob operatsiooni. Töö staatus võib olla üks järgmistest:

• ESITATUD – töö on vastu võetud ja on töötlemise järjekorras
• IN_PROGRESS – Amazon Comprehend töötleb tööd
• LÕPETUD – töö lõpetati edukalt ja väljund on saadaval
• EBAÕNNESTUS – tööd ei lõpetatud

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

Kui töö on edukalt lõpule viidud, tagastab see tihendatud arhiivi, mis sisaldab kahte faili: topic-terms.csv ja doc-topics.csv. Esimene väljundfail, topic-terms.csv, on kogumiku teemade loend. Iga teema kohta sisaldab loend vaikimisi populaarseimaid termineid teemade kaupa vastavalt nende kaalule. Teine fail, doc-topics.csv, loetleb teemaga seotud dokumendid ja teemaga seotud dokumendi osakaalu. Sest me täpsustasime ONE_DOC_PER_LINE varem input_doc_format muutuja, identifitseeritakse dokument failinime ja failis oleva 0-indeksiga reanumbri järgi. Teema modelleerimise kohta lisateabe saamiseks vaadake Teema modelleerimine.
Amazon Comprehendi väljundid kopeeritakse meie järgmiste sammude jaoks kohapeal.

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

Kuna teemade arv on palju väiksem kui dokumendikoguga seotud sõnavara, võib teemaruumi esitust vaadelda ka mõõtmete vähendamise protsessina. Klastrite loomiseks võite kasutada seda dokumentide teemaruumi esitust. Teisest küljest saate analüüsida sõnade sagedust igas klastris, et määrata iga klastriga seotud teema. Selle postituse puhul ei kasuta me muid tehnikaid, näiteks rühmitamist.

Kasutame kolmandat märkmikku (topic_mapping_sentiment_generation.ipynb).

Saame kombineerida eelmise märkmiku väljundeid, et saada iga teema jaoks teemad ja seotud terminid. Teemad on aga nummerdatud ja neil võib puududa seletatavus. Seetõttu eelistame teemade nimetamiseks nendega seotud termineid vaadates kasutada in-the-loop inimest, kellel on piisavalt domeeniteadmisi ja asjatundlikkust. Seda protsessi võib käsitleda kui teemade numbrite ja teemade nimede vastendamist. Siiski on tähelepanuväärne, et teemade individuaalne terminite loend võib olla üksteist hõlmav ja seetõttu võib see luua mitu vastendust. In-the-loop peaks vormistama vastendused kasutusjuhtumi konteksti alusel. Vastasel juhul võib see mõjutada allavoolu jõudlust.

Alustame muutujate deklareerimisega. Iga arvustuse jaoks võib olla mitu teemat. Loendame nende sagedust ja valime välja maksimaalselt kolm kõige sagedamini esinevat teemat. Need teemad on kajastatud ülevaateteemadena. Esiteks määratleme muutuja TOP_TOPICS hoida maksimaalselt esinduslikke teemasid. Teiseks määratleme ja määrame väärtused language_code muutuja, mis toetab Amazon Comprehendi nõutavat keeleparameetrit. Lõpuks loome topicMaps, mis on sõnastik, mis kaardistab teemade numbrid teemade nimedega.

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

Järgmisena kasutame iga teemaga seotud ainulaadsete terminite ühendamiseks Amazon Comprehendi loodud faili topic-terms.csv. Seejärel, rakendades sellele teema-termini seosele kaardistamissõnastikku, ühendame kordumatud terminid teemade nimedega.

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

See kaardistamine parandab Amazon Comprehendi loodud teemade loetavust ja seletatavust, nagu näeme järgmises DataFrame'is.

Lisaks ühendame teema numbri, terminid ja nimed algsete sisendandmetega, nagu on näidatud järgmistes sammudes.

See tagastab igale arvustusele vastavad teematerminid ja nimed. Teemade numbrid ja terminid liidetakse iga ülevaatega ning seejärel taasühendatakse algse DataFrame'iga, mille me esimesse märkmikku salvestasime.

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

Loome arvustuse teksti suhtes sentimenti kasutades detect_sentiment. See kontrollib teksti ja annab järelduse valitsevast meeleolust (POSITIIVNE, NEUTRAALNE, SEGANE või NEGATIIVNE).

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)

Nii teemad kui ka tunded on arvustustega tihedalt seotud. Kuna me koondame teemasid ja tundeid toote tasemel, peame Amazon Comprehendi loodud teemade ja emotsioonide kombineerimise teel looma liitvõtme.

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

Seejärel koondame toote tasemel ja loendame iga toote liitvõtmed.

See viimane samm aitab meil paremini mõista arvustuste detailsust toote kohta ja neid koondpõhiselt teemade kaupa liigitada. Näiteks võime arvestada teemaDF DataFrame jaoks näidatud väärtustega. Esimese toote kohta, kõigist selle kohta antud arvustustest, oli klientidel üldiselt positiivne kogemus toote tagastamise, suuruse ja mugavuse osas. Teise toote puhul olid klientidel enamasti erinevad ja positiivsed kogemused toote tagastamisel ja positiivsed kogemused toote suuruse osas.

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

Meie lõplik DataFrame koosneb selle teema teabest ja meeleoluteabest, mis on ühendatud lõpliku nimega DataFrame'iga feedbackTopics mille salvestasime oma esimesse sülearvutisse Amazon S3-le.

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

Kasutage andmete visualiseerimiseks Amazon QuickSighti

QuickSighti saate kasutada andmete visualiseerimiseks ja aruannete loomiseks. QuickSight on ärianalüüsi (BI) teenus, mida saate kasutada paljudest erinevatest allikatest pärit andmete tarbimiseks ja intelligentsete armatuurlaudade loomiseks. Selles näites loome QuickSighti analüüsi, kasutades meie loodud lõplikku andmekogumit, nagu on näidatud järgmistes visualiseerimisnäidetes.

Amazon QuickSighti kohta lisateabe saamiseks vaadake Amazon Quicksightiga alustamine.

Korista ära

Lõpuks peame selles katses kasutatud sülearvuti eksemplari AWS-i konsoolist sulgema.

Järeldus

Selles postituses demonstreerisime, kuidas kasutada Amazon Comprehendi tootearvustuste analüüsimiseks ja parimate teemade leidmiseks, kasutades teemade modelleerimist. Teemade modelleerimine võimaldab teil vaadata läbi mitu teemat ning korraldada, mõista ja kokkuvõtteid teha. Saate kiiresti ja hõlpsalt avastada andmetes esinevad peidetud mustrid ning seejärel kasutada seda teavet andmepõhiste otsuste tegemiseks. Teemade modelleerimist saate kasutada paljude äriprobleemide lahendamiseks, nagu klienditoe piletite automaatne sildistamine, vestluste suunamine teema alusel õigetesse meeskondadesse, tugipiletite kiireloomulisuse tuvastamine, vestlustest parema ülevaate saamine, andmepõhiste plaanide loomine, probleemide loomine. - keskendunud sisu, müügistrateegia parandamine ning klientide probleemide ja hõõrumiste tuvastamine.

Need on vaid mõned näited, kuid võite mõelda veel paljudele äriprobleemidele, millega teie organisatsioonis igapäevaselt kokku puutute, ja kuidas saate nende lahendamiseks kasutada teemade modelleerimist koos teiste ML-tehnikatega.

---

Autoritest

Gurpreet on Kanadast pärit AWS-i professionaalsete teenuste andmeteadlane. Ta on kirglik aidata klientidel masinõppe ja tehisintellekti tehnoloogiate abil uuendusi teha, et saada andmetest äriväärtust ja teadmisi. Vabal ajal meeldib talle õues matkata ja raamatuid lugeda.i

Rushdi Shams on andmeteadlane AWS Professional Servicesis, Kanadas. Ta ehitab AWS-i klientidele masinõppetooteid. Talle meeldib lugeda ja ulmet kirjutada.

Wrick Talukdar on Amazon Comprehend Service meeskonna vanemarhitekt. Ta teeb koostööd AWS-i klientidega, et aidata neil masinõpet laialdaselt kasutusele võtta. Väljaspool tööd meeldib talle lugeda ja pildistada.