Få bedre innsikt fra anmeldelser ved å bruke Amazon Comprehend

"85 % av kjøperne stoler like mye på nettanmeldelser som en personlig anbefaling" - Gartner

Forbrukere engasjerer seg i økende grad med bedrifter gjennom digitale overflater og flere kontaktpunkter. Statistikk viser at flertallet av kunder bruker anmeldelser for å finne ut hvilke produkter de skal kjøpe og hvilke tjenester de skal bruke. Som pr Spiegel forskningssenter, er kjøpssannsynligheten for et produkt med fem anmeldelser 270 % større enn kjøpssannsynligheten for et produkt uten anmeldelser. Anmeldelser har makt til å påvirke forbrukernes beslutninger og styrke merkevareverdien.

I dette innlegget bruker vi Amazon Comprehend å trekke ut meningsfull informasjon fra produktanmeldelser, analysere den for å forstå hvordan brukere av ulike demografiske grupper reagerer på produkter, og oppdage samlet informasjon om brukertilhørighet til et produkt. Amazon Comprehend er en fullstendig administrert og kontinuerlig trent NLP-tjeneste (natural language processing) som kan trekke ut innsikt om innholdet i et dokument eller en tekst.

Løsningsoversikt

I dag kan anmeldelser gis av kunder på ulike måter, for eksempel stjernerangeringer, fritekst eller naturlig språk, eller delinger i sosiale medier. Fritekst eller naturspråklige anmeldelser bidrar til å bygge tillit, siden det er en uavhengig mening fra forbrukerne. Den brukes ofte av produktteam for å samhandle med kunder gjennom gjennomgangskanaler. Det er et bevist faktum at når kundene føler seg hørt, blir følelsen deres om merkevaren bedre. Mens det er relativt enklere å analysere stjernerangeringer eller delinger på sosiale medier, utgjør naturlig språk eller fritekstanmeldelser flere utfordringer, som å identifisere nøkkelord eller fraser, emner eller konsepter, og følelser på enhetsnivå. Utfordringen skyldes hovedsakelig variasjonen av lengde i skrevet tekst og plausibel tilstedeværelse av både signaler og støy. Videre kan informasjonen enten være veldig tydelig og eksplisitt (for eksempel med nøkkelord og nøkkelfraser) eller uklar og implisitt (abstrakte emner og begreper). Enda mer utfordrende er å forstå ulike typer følelser og knytte dem til passende produkter og tjenester. Likevel er det svært viktig å forstå denne informasjonen og tekstsignalene for å gi en friksjonsfri kundeopplevelse.

I dette innlegget bruker vi en offentlig tilgjengelig NLP – fast.ai datasett for å analysere produktanmeldelser levert av kunder. Vi starter med å bruke en unsupervised machine learning (ML)-teknikk kjent som emnemodellering. Dette er en populær uovervåket teknikk som oppdager abstrakte emner som kan forekomme i en tekstanmeldelsessamling. Emnemodellering er et klyngeproblem som ikke er overvåket, noe som betyr at modellene ikke har kunnskap om mulige målvariabler (som temaer i en gjennomgang). Temaene er representert som klynger. Ofte bestemmes antallet klynger i et korpus av dokumenter ved hjelp av domeneeksperter eller ved å bruke en standard statistisk analyse. Modellutdataene har generelt tre komponenter: nummererte klynger (emne 0, emne 1, og så videre), nøkkelord knyttet til hver klynge, og representative klynger for hvert dokument (eller gjennomgang i vårt tilfelle). Av sin iboende natur genererer ikke emnemodeller menneskelesbare etiketter for klyngene eller emnene, noe som er en vanlig misforståelse. Noe å merke seg om emnemodellering generelt er at det er en blandet medlemskapsmodell – hvert dokument i modellen kan ha en likhet med hvert emne. Temamodellen lærer i en iterativ Bayesiansk prosess å bestemme sannsynligheten for at hvert dokument er assosiert med et gitt tema eller emne. Modellutgangen avhenger av å velge antall emner optimalt. Et lite antall emner kan føre til at emnene blir for brede, og et større antall emner kan resultere i overflødige emner eller emner med likhet. Det er en rekke måter å evaluere emnemodeller på:

• Menneskelig dømmekraft – Observasjonsbasert, tolkningsbasert
• Kvantitative beregninger – Forvirring, koherensberegninger
• Blandet tilnærming – En kombinasjon av vurderingsbaserte og kvantitative tilnærminger

Forvirring beregnes ved å dele et datasett i to deler – et treningssett og et testsett. Sannsynlighet beregnes vanligvis som en logaritme, så denne beregningen blir noen ganger referert til som den holdt ut log-sannsynligheten. Forvirring er en prediktiv beregning. Den vurderer en emnemodells evne til å forutsi et testsett etter å ha blitt trent på et treningssett. En av manglene ved forvirring er at den ikke fanger kontekst, noe som betyr at den ikke fanger forholdet mellom ord i et emne eller emner i et dokument. Imidlertid er ideen om semantisk kontekst viktig for menneskelig forståelse. Tiltak som betinget sannsynlighet for samtidig forekomst av ord i et emne kan være nyttige. Disse tilnærmingene blir samlet referert til som koherens. For dette innlegget fokuserer vi på den menneskelige dømmekraften (observasjonsbasert) tilnærmingen, nemlig å observere de n beste ordene i et emne.

Løsningen består av følgende trinn på høyt nivå:

1. Sett opp en Amazon SageMaker notatbokforekomst.
2. Lag en notatbok.
3. Utfør utforskende dataanalyse.
4. Kjør Amazon Comprehend-emnemodelleringsjobben din.
5. Generer emner og forstå følelser.
6. Bruk Amazon QuickSight å visualisere data og generere rapporter.

Du kan bruke denne løsningen i hvilken som helst AWS-region, men du må sørge for at Amazon Comprehend API-ene og SageMaker er i samme region. For dette innlegget bruker vi regionen US East (N. Virginia).

Sett opp SageMaker notatbokforekomsten

Du kan samhandle med Amazon Comprehend via AWS-administrasjonskonsoll, AWS Command Line Interface (AWS CLI), eller Amazon Comprehend API. For mer informasjon, se Komme i gang med Amazon Comprehend. Vi bruker en SageMaker-notisbok og Python (Boto3)-kode gjennom dette innlegget for å samhandle med Amazon Comprehend API-ene.

1. På Amazon SageMaker-konsollen, under Notebook i navigasjonsruten, velg
   Notebook-forekomster.
2. Velg Opprett notatbokforekomst.
3. Spesifiser et navn på en notatbokforekomst og sett forekomsttypen til ml.r5.2xlarge.
4. La resten av standardinnstillingene stå.
5. Lag en AWS Identity and Access Management (IAM) rolle med AmazonSageMakerFullAccess og tilgang til nødvendig Amazon Simple Storage Service (Amazon S3) bøtter og Amazon Comprehend APIer.
6. Velg Opprett notatbokforekomst.
   Etter noen minutter er den bærbare forekomsten klar.
7. For å få tilgang til Amazon Comprehend fra den bærbare forekomsten, må du legge ved ComprehendFullAccess politikk for din IAM-rolle.

For en sikkerhetsoversikt over Amazon Comprehend, se Sikkerhet i Amazon Comprehend.

Etter at du har åpnet den bærbare forekomsten du klargjorde, velger du Ny på Jupyter-konsollen og deretter Python 3 (Data Science). Alternativt kan du få tilgang til eksempelkodefilen i GitHub repo. Du kan laste opp filen til notatbokforekomsten for å kjøre den direkte eller klone den.

GitHub-repoen inneholder tre notatbøker:

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

Utfør utforskende dataanalyse

Vi bruker den første notatboken (data_processing.ipynb) for å utforske og behandle dataene. Vi starter med ganske enkelt å laste inn dataene fra en S3-bøtte inn i en 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)

I den følgende delen utfører vi utforskende dataanalyse (EDA) for å forstå dataene. Vi starter med å utforske formen på dataene og metadataene. For autentisitet bruker vi kun bekreftede anmeldelser.

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

Vi utforsker tellingen av hver kategori videre, og ser om noen dupliserte data er tilstede.

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

Når vi er fornøyde med resultatene, går vi til neste trinn med å forhåndsbehandle dataene. Amazon Comprehend anbefaler å gi minst 1,000 dokumenter i hver emnemodelleringsjobb, med hvert dokument minst tre setninger langt. Dokumenter må være i UTF-8-formaterte tekstfiler. I det følgende trinnet sørger vi for at data er i det anbefalte UTF-8-formatet og at hver inngang ikke er mer enn 5,000 byte stor.

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)

Vi lagrer deretter dataene til Amazon S3 og beholder også en lokal kopi i den bærbare forekomsten.

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

Dette fullfører vår databehandlingsfase.

Kjør en Amazon Comprehend-emnemodelleringsjobb

Vi går deretter til neste fase, hvor vi bruker de forhåndsbehandlede dataene til å kjøre en emnemodelleringsjobb ved å bruke Amazon Comprehend. På dette stadiet kan du enten bruke den andre notatboken (model_training.ipynb) eller bruk Amazon Comprehend-konsollen til å kjøre emnemodelleringsjobben. For instruksjoner om bruk av konsollen, se Kjøre analysejobber ved hjelp av konsollen. Hvis du bruker den bærbare datamaskinen, kan du starte med å opprette en Amazon Comprehend-klient ved å bruke Boto3, som vist i følgende eksempel.

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

Du kan sende inn dokumentene dine for emnemodellering på to måter: ett dokument per fil, eller ett dokument per linje.

Vi starter med 5 emner (k-nummer), og bruker ett dokument per linje. Det er ingen enkelt beste måte som standard praksis for å velge k eller antall emner. Du kan prøve ut forskjellige verdier av k, og velge den som har størst sannsynlighet.

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

Vår Amazon Comprehend-emnemodelleringsjobb krever at du består en InputDataConfig ordbokobjekt med S3, InputFormatog DocumentReadAction som nødvendige parametere. På samme måte må du gi OutputDataConfig objekt med S3 og DataAccessRoleArn som nødvendige parametere. For mer informasjon, se Boto3-dokumentasjonen for 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,
}

Du kan deretter starte en asynkron emnedeteksjonsjobb ved å sende antall emner, inndatakonfigurasjonsobjekt, utgangskonfigurasjonsobjekt og en IAM-rolle, som vist i følgende eksempel.

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

Du kan spore gjeldende status for jobben ved å ringe DescribeTopicDetectionJob operasjon. Statusen til jobben kan være en av følgende:

• SENDT – Jobben er mottatt og står i kø for behandling
• IN_PROGRESS – Amazon Comprehend behandler jobben
• FULLFØRT – Jobben ble fullført og utdataene er tilgjengelige
• MISLYKKES – Jobben ble ikke fullført

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

Når jobben er fullført, returnerer den et komprimert arkiv som inneholder to filer: topic-terms.csv og doc-topics.csv. Den første utdatafilen, topic-terms.csv, er en liste over emner i samlingen. For hvert emne inkluderer listen, som standard, de øverste termene etter emne i henhold til deres vekt. Den andre filen, doc-topics.csv, viser dokumentene knyttet til et emne og andelen av dokumentet som er opptatt av emnet. Fordi vi spesifiserte ONE_DOC_PER_LINE tidligere i input_doc_format variabel, identifiseres dokumentet av filnavnet og det 0-indekserte linjenummeret i filen. For mer informasjon om emnemodellering, se Temamodellering.
Utdataene fra Amazon Comprehend kopieres lokalt for våre neste trinn.

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

Fordi antallet emner er mye mindre enn vokabularet knyttet til dokumentsamlingen, kan emneromsrepresentasjonen også sees på som en dimensjonsreduksjonsprosess. Du kan bruke denne emneplassrepresentasjonen av dokumenter for å utføre gruppering. På den annen side kan du analysere frekvensen av ord i hver klynge for å bestemme emnet knyttet til hver klynge. For dette innlegget utfører vi ingen andre teknikker som clustering.

Vi bruker den tredje notatboken (topic_mapping_sentiment_generation.ipynb) for å finne hvordan brukere av ulike demografier reagerer på produkter, og også analysere samlet informasjon om brukertilhørighet til et bestemt produkt.

Vi kan kombinere utdataene fra forrige notatbok for å få emner og tilhørende termer for hvert emne. Emnene er imidlertid nummererte og kan mangle forklaringsmuligheter. Derfor foretrekker vi å bruke et menneske-i-løkken med nok domenekunnskap og fagkompetanse til å navngi emnene ved å se på de tilhørende termene. Denne prosessen kan betraktes som en kartlegging fra emnenummer til emnenavn. Det er imidlertid verdt å merke seg at den individuelle listen over termer for emnene kan være gjensidig inkluderende og derfor kan skape flere tilordninger. Mennesket-i-løkken bør formalisere kartleggingene basert på konteksten til brukssaken. Ellers kan nedstrømsytelsen bli påvirket.

Vi starter med å deklarere variablene. For hver anmeldelse kan det være flere emner. Vi teller frekvensen deres og velger maksimalt tre mest hyppige emner. Disse emnene rapporteres som de representative emnene for en anmeldelse. Først definerer vi en variabel TOP_TOPICS for å inneholde maksimalt antall representative emner. For det andre definerer og setter vi verdier til language_code variabel for å støtte den nødvendige språkparameteren til Amazon Comprehend. Til slutt skaper vi topicMaps, som er en ordbok som tilordner emnenummer til emnenavn.

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

Deretter bruker vi topic-terms.csv-filen generert av Amazon Comprehend for å koble sammen de unike termene knyttet til hvert emne. Deretter, ved å bruke kartordboken på denne emne-term assosiasjonen, kobler vi de unike termene til emnenavnene.

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

Denne kartleggingen forbedrer lesbarheten og forklarbarheten til emnene generert av Amazon Comprehend, som vi kan se i følgende DataFrame.

Videre kobler vi emnenummeret, termene og navnene til de første inndataene, som vist i de følgende trinnene.

Dette returnerer emneord og navn som tilsvarer hver anmeldelse. Emnenumrene og begrepene er slått sammen med hver anmeldelse og deretter slått sammen tilbake til den originale DataFrame vi lagret i den første notatboken.

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

Vi genererer sentiment for anmeldelsesteksten ved hjelp av detect_sentiment. Den inspiserer tekst og returnerer en slutning om den rådende følelsen (POSITIV, NØYTRAL, BLANDET eller NEGATIV).

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)

Både emner og følelser er tett koblet med anmeldelser. Fordi vi skal samle emner og følelser på produktnivå, må vi lage en sammensatt nøkkel ved å kombinere emnene og følelsene generert av 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']

Etterpå aggregerer vi på produktnivå og teller de sammensatte nøklene for hvert produkt.

Dette siste trinnet hjelper oss å bedre forstå granulariteten til vurderingene per produkt og kategorisere dem per emne på en aggregert måte. For eksempel kan vi vurdere verdiene som vises for topicDF DataFrame. For det første produktet, av alle anmeldelsene for det, hadde kundene totalt sett en positiv opplevelse på produktretur, størrelse og komfort. For det andre produktet hadde kundene stort sett en blandet til positiv opplevelse av produktretur og en positiv opplevelse av produktstørrelse.

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

Vår endelige DataFrame består av denne emneinformasjonen og sentimentinformasjon koblet tilbake til den endelige DataFrame som heter feedbackTopics som vi lagret på Amazon S3 i vår første bærbare.

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

Bruk Amazon QuickSight til å visualisere dataene

Du kan bruke QuickSight til å visualisere dataene og generere rapporter. QuickSight er en business intelligence (BI)-tjeneste som du kan bruke til å konsumere data fra mange forskjellige kilder og bygge intelligente dashboards. I dette eksemplet genererer vi en QuickSight-analyse ved å bruke det endelige datasettet vi produserte, som vist i følgende eksempelvisualiseringer.

For å lære mer om Amazon QuickSight, se Komme i gang med Amazon Quicksight.

Opprydding

Til slutt må vi slå av den bærbare instansen vi har brukt i dette eksperimentet fra AWS Console.

konklusjonen

I dette innlegget demonstrerte vi hvordan du bruker Amazon Comprehend til å analysere produktanmeldelser og finne de beste emnene ved å bruke emnemodellering som teknikk. Emnemodellering lar deg se gjennom flere emner og organisere, forstå og oppsummere dem i stor skala. Du kan raskt og enkelt oppdage skjulte mønstre som er tilstede på tvers av dataene, og deretter bruke denne innsikten til å ta datadrevne beslutninger. Du kan bruke emnemodellering til å løse en rekke forretningsproblemer, for eksempel automatisk merking av kundestøttebilletter, dirigere samtaler til de riktige teamene basert på emnet, oppdage behovet for støttebilletter, få bedre innsikt fra samtaler, lage datadrevne planer, lage problemer -fokusert innhold, forbedre salgsstrategi, og identifisere kundeproblemer og friksjoner.

Dette er bare noen få eksempler, men du kan tenke på mange flere forretningsproblemer du møter i organisasjonen din på daglig basis, og hvordan du kan bruke emnemodellering med andre ML-teknikker for å løse disse.

---

Om forfatterne

Gurpreet er en dataforsker med AWS Professional Services basert i Canada. Hun brenner for å hjelpe kunder med å innovere med maskinlæring og kunstig intelligens-teknologier for å utnytte forretningsverdi og innsikt fra data. På fritiden liker hun å gå på tur utendørs og lese bøker.i

Rushdi Shams er en dataforsker med AWS Professional Services, Canada. Han bygger maskinlæringsprodukter for AWS-kunder. Han elsker å lese og skrive science fiction.

Wrick Talukdar er seniorarkitekt med Amazon Comprehend Service-team. Han jobber med AWS-kunder for å hjelpe dem å ta i bruk maskinlæring i stor skala. Utenom jobben liker han å lese og fotografere.