Få bedre indsigt fra anmeldelser ved hjælp af Amazon Comprehend

"85 % af købere stoler lige så meget på onlineanmeldelser som en personlig anbefaling" - Gartner

Forbrugere engagerer sig i stigende grad med virksomheder gennem digitale overflader og flere kontaktpunkter. Statistikker viser, at størstedelen af ​​shoppere bruger anmeldelser til at bestemme, hvilke produkter de skal købe, og hvilke tjenester der skal bruges. Som pr Spiegel Forskningscenter, er købssandsynligheden for et produkt med fem anmeldelser 270 % større end købssandsynligheden for et produkt uden anmeldelser. Anmeldelser har magten til at påvirke forbrugernes beslutninger og styrke brandværdien.

I dette indlæg bruger vi Amazon Comprehend at udtrække meningsfuld information fra produktanmeldelser, analysere den for at forstå, hvordan brugere af forskellige demografiske grupper reagerer på produkter, og opdage aggregerede oplysninger om brugernes tilhørsforhold til et produkt. Amazon Comprehend er en fuldt administreret og kontinuerligt trænet NLP-tjeneste (natural language processing), der kan udtrække indsigt om indholdet af et dokument eller en tekst.

Løsningsoversigt

I dag kan anmeldelser leveres af kunder på forskellige måder, såsom stjernebedømmelser, fritekst eller naturligt sprog eller delinger på sociale medier. Fritekst eller naturlige sproganmeldelser hjælper med at opbygge tillid, da det er en uafhængig mening fra forbrugerne. Det bruges ofte af produktteams til at interagere med kunder gennem anmeldelseskanaler. Det er et bevist faktum, at når kunder føler sig hørt, forbedres deres følelse af mærket. Mens det er forholdsvis nemmere at analysere stjernebedømmelser eller delinger på sociale medier, udgør naturligt sprog eller fritekstanmeldelser flere udfordringer, som f.eks. at identificere søgeord eller sætninger, emner eller begreber og følelser eller følelser på enhedsniveau. Udfordringen skyldes hovedsageligt variationen i længden i skrevet tekst og plausibel tilstedeværelse af både signaler og støj. Endvidere kan informationen enten være meget klar og eksplicit (f.eks. med søgeord og nøglesætninger) eller uklare og implicitte (abstrakte emner og begreber). Endnu mere udfordrende er det at forstå forskellige typer af følelser og relatere dem til passende produkter og tjenester. Ikke desto mindre er det yderst vigtigt at forstå disse oplysninger og tekstsignaler for at give en friktionsfri kundeoplevelse.

I dette indlæg bruger vi en offentlig tilgængelig NLP – fast.ai datasæt til at analysere produktanmeldelser leveret af kunder. Vi starter med at bruge en unsupervised machine learning (ML) teknik kendt som emnemodellering. Dette er en populær uovervåget teknik, der opdager abstrakte emner, der kan forekomme i en tekstanmeldelsessamling. Emnemodellering er et klyngeproblem, der er uovervåget, hvilket betyder, at modellerne ikke har viden om mulige målvariable (såsom emner i en gennemgang). Emnerne er repræsenteret som klynger. Ofte bestemmes antallet af klynger i et korpus af dokumenter ved hjælp af domæneeksperter eller ved at bruge nogle standard statistiske analyser. Modeloutput har generelt tre komponenter: nummererede klynger (emne 0, emne 1, og så videre), nøgleord knyttet til hver klynge og repræsentative klynger for hvert dokument (eller anmeldelse i vores tilfælde). I sagens natur genererer emnemodeller ikke menneskelæselige etiketter til klyngerne eller emnerne, hvilket er en almindelig misforståelse. Noget at bemærke om emnemodellering generelt er, at det er en blandet medlemskabsmodel – hvert dokument i modellen kan have en lighed med hvert emne. Emnemodellen lærer i en iterativ Bayesiansk proces at bestemme sandsynligheden for, at hvert dokument er forbundet med et givet tema eller emne. Modeloutputtet afhænger af at vælge antallet af emner optimalt. Et lille antal emner kan resultere i, at emnerne bliver for brede, og et større antal emner kan resultere i overflødige emner eller emner med lighed. Der er en række måder at evaluere emnemodeller på:

• Menneskelig dømmekraft – Observationsbaseret, fortolkningsbaseret
• Kvantitative målinger - Forvirring, sammenhængsberegninger
• Blandet tilgang – En kombination af vurderingsbaserede og kvantitative tilgange

Forvirring beregnes ved at opdele et datasæt i to dele – et træningssæt og et testsæt. Sandsynlighed beregnes normalt som en logaritme, så denne metrik omtales nogle gange som den udholdte log-sandsynlighed. Forvirring er en forudsigelig metrik. Den vurderer en emnemodels evne til at forudsige et testsæt efter at være blevet trænet på et træningssæt. En af manglerne ved forvirring er, at den ikke fanger kontekst, hvilket betyder, at den ikke fanger forholdet mellem ord i et emne eller emner i et dokument. Men ideen om semantisk kontekst er vigtig for menneskelig forståelse. Mål som f.eks. den betingede sandsynlighed for samtidig forekomst af ord i et emne kan være nyttige. Disse tilgange omtales samlet som sammenhæng. Til dette indlæg fokuserer vi på den menneskelige dømmekraft (observationsbaserede) tilgang, nemlig at observere de øverste n ord i et emne.

Løsningen består af følgende overordnede trin:

1. Opret en Amazon SageMaker notesbogsforekomst.
2. Opret en notesbog.
3. Udfør undersøgende dataanalyse.
4. Kør dit Amazon Comprehend-emnemodelleringsjob.
5. Generer emner og forstå følelser.
6. Brug Amazon QuickSight at visualisere data og generere rapporter.

Du kan bruge denne løsning i enhver AWS-region, men du skal sikre dig, at Amazon Comprehend API'erne og SageMaker er i samme region. Til dette indlæg bruger vi regionen US East (N. Virginia).

Konfigurer din SageMaker notebook-instans

Du kan interagere med Amazon Comprehend via AWS Management Console, AWS Command Line Interface (AWS CLI), eller Amazon Comprehend API. For mere information, se Kom godt i gang med Amazon Comprehend. Vi bruger en SageMaker notesbog og Python (Boto3) kode i hele dette indlæg til at interagere med Amazon Comprehend API'erne.

1. Vælg på Amazon SageMaker-konsollen under Notesbog i navigationsruden
   Notebook-forekomster.
2. Vælg Opret notesbogsforekomst.
3. Angiv et notesbogsforekomstnavn, og indstil forekomsttypen til ml.r5.2xlarge.
4. Forlad resten af ​​standardindstillingerne.
5. Opret en AWS Identity and Access Management (IAM) rolle med AmazonSageMakerFullAccess og adgang til det nødvendige Amazon Simple Storage Service (Amazon S3) buckets og Amazon Comprehend API'er.
6. Vælg Opret notesbogsforekomst.
   Efter et par minutter er din notebook-forekomst klar.
7. For at få adgang til Amazon Comprehend fra notebook-forekomsten skal du vedhæfte ComprehendFullAccess politik til din IAM-rolle.

For en sikkerhedsoversigt over Amazon Comprehend, se Sikkerhed i Amazon Comprehend.

Når du har åbnet den notesbogsforekomst, som du klargjorde, skal du på Jupyter-konsollen vælge Ny og derefter Python 3 (Data Science). Alternativt kan du få adgang til prøvekodefilen i GitHub repo. Du kan uploade filen til notebook-forekomsten for at køre den direkte eller klone den.

GitHub-reposen indeholder tre notesbøger:

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

Udfør undersøgende dataanalyse

Vi bruger den første notesbog (data_processing.ipynb) for at udforske og behandle dataene. Vi starter med blot at indlæse dataene fra en S3 bucket ind 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 det følgende afsnit udfører vi eksplorativ dataanalyse (EDA) for at forstå dataene. Vi starter med at udforske formen på data og metadata. For ægtheden bruger vi kun bekræftede 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 undersøger yderligere antallet af hver kategori og ser, om der er nogen duplikerede data til stede.

# 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 tilfredse med resultaterne, går vi videre til næste trin med forbehandling af dataene. Amazon Comprehend anbefaler at levere mindst 1,000 dokumenter i hvert emnemodelleringsjob, med hvert dokument mindst tre sætninger langt. Dokumenter skal være i UTF-8-formaterede tekstfiler. I det følgende trin sørger vi for, at data er i det anbefalede UTF-8-format, og at hvert input ikke er mere end 5,000 bytes i størrelse.

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 gemmer derefter dataene til Amazon S3 og beholder også en lokal kopi i notebook-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 afslutter vores databehandlingsfase.

Kør et Amazon Comprehend-emnemodelleringsjob

Vi går derefter til næste fase, hvor vi bruger de forbehandlede data til at køre et emnemodelleringsjob ved hjælp af Amazon Comprehend. På dette tidspunkt kan du enten bruge den anden notesbog (model_training.ipynb) eller brug Amazon Comprehend-konsollen til at køre emnemodelleringsjobbet. For instruktioner om brug af konsollen, se Kørsel af analysejob ved hjælp af konsollen. Hvis du bruger notesbogen, kan du starte med at oprette en Amazon Comprehend-klient ved hjælp af 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 indsende dine dokumenter til emnemodellering på to måder: et dokument pr. fil eller et dokument pr. linje.

Vi starter med 5 emner (k-tal), og bruger et dokument pr. linje. Der er ingen enkelt bedste måde som standardpraksis at vælge k eller antallet af emner på. Du kan prøve forskellige værdier af k og vælge den, der har størst sandsynlighed.

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

Vores Amazon Comprehend-emnemodelleringsjob kræver, at du består en InputDataConfig ordbogsobjekt med S3, InputFormatog DocumentReadAction efter krævede parametre. På samme måde skal du levere OutputDataConfig objekt med S3 og DataAccessRoleArn efter krævede parametre. For mere information henvises til Boto3-dokumentationen 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 derefter starte et asynkront emneregistreringsjob ved at videregive antallet af emner, inputkonfigurationsobjekt, outputkonfigurationsobjekt 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 den aktuelle status for jobbet ved at ringe til DescribeTopicDetectionJob operation. Status for jobbet kan være en af ​​følgende:

• INDSENDT – Jobbet er modtaget og står i kø til behandling
• IN_PROGRESS – Amazon Comprehend behandler jobbet
• UDFØRT – Jobbet blev fuldført, og outputtet er tilgængeligt
• FAILED – Jobbet blev ikke fuldfø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 jobbet er fuldført, returnerer det et komprimeret arkiv, der indeholder to filer: topic-terms.csv og doc-topics.csv. Den første outputfil, topic-terms.csv, er en liste over emner i samlingen. For hvert emne inkluderer listen som standard de øverste udtryk efter emne i henhold til deres vægt. Den anden fil, doc-topics.csv, viser de dokumenter, der er knyttet til et emne, og den andel af dokumentet, der vedrører emnet. Fordi vi specificerede ONE_DOC_PER_LINE tidligere i input_doc_format variabel, identificeres dokumentet med filnavnet og det 0-indekserede linjenummer i filen. For mere information om emnemodellering, se Emnemodellering.
Outputtet fra Amazon Comprehend kopieres lokalt til vores næste trin.

# 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 af emner er meget mindre end det ordforråd, der er knyttet til dokumentsamlingen, kan emnerumsrepræsentationen også ses som en dimensionsreduktionsproces. Du kan bruge denne emnepladsrepræsentation af dokumenter til at udføre klyngedannelse. På den anden side kan du analysere frekvensen af ​​ord i hver klynge for at bestemme emnet forbundet med hver klynge. Til dette indlæg udfører vi ikke andre teknikker som klyngedannelse.

Vi bruger den tredje notesbog (topic_mapping_sentiment_generation.ipynb) for at finde ud af, hvordan brugere af forskellige demografiske grupper reagerer på produkter, og også analysere aggregerede oplysninger om brugeraffinitet til et bestemt produkt.

Vi kan kombinere output fra den forrige notesbog for at få emner og tilhørende udtryk for hvert emne. Emnerne er dog nummererede og kan mangle forklaringsmuligheder. Derfor foretrækker vi at bruge et menneske-i-løkken med nok domæneviden og fagekspertise til at navngive emnerne ved at se på deres tilknyttede termer. Denne proces kan betragtes som en kortlægning fra emnenumre til emnenavne. Det er dog bemærkelsesværdigt, at den individuelle liste over termer for emnerne kan være gensidigt inkluderende og derfor kan skabe flere tilknytninger. Human-in-the-loop bør formalisere kortlægningerne baseret på konteksten af ​​use casen. Ellers kan downstream-ydelsen blive påvirket.

Vi starter med at erklære variablerne. For hver anmeldelse kan der være flere emner. Vi tæller deres hyppighed og udvælger højst tre mest hyppige emner. Disse emner rapporteres som de repræsentative emner i en anmeldelse. Først definerer vi en variabel TOP_TOPICS at holde det maksimale antal repræsentative emner. For det andet definerer og sætter vi værdier til language_code variabel for at understøtte den nødvendige sprogparameter for Amazon Comprehend. Til sidst skaber vi topicMaps, som er en ordbog, der knytter emnenumre til emnenavne.

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

Dernæst bruger vi topic-terms.csv-filen genereret af Amazon Comprehend til at forbinde de unikke termer forbundet med hvert emne. Derefter, ved at anvende kortlægningsordbogen på denne emneudtryksforening, forbinder vi de unikke termer 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 kortlægning forbedrer læsbarheden og forklarligheden af ​​de emner, der genereres af Amazon Comprehend, som vi kan se i den følgende DataFrame.

Desuden forbinder vi emnenummeret, termerne og navnene til de indledende inputdata, som vist i de følgende trin.

Dette returnerer emneudtryk og navne svarende til hver anmeldelse. Emnenumrene og termerne sammenføjes med hver anmeldelse og føjes derefter yderligere tilbage til den originale DataFrame, vi gemte i den første notesbog.

# 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 stemning for anmeldelsesteksten vha detect_sentiment. Den inspicerer tekst og returnerer en konklusion af den fremherskende følelse (POSITIV, NEUTRAL, 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 tæt forbundet med anmeldelser. Fordi vi vil samle emner og følelser på produktniveau, er vi nødt til at skabe en sammensat nøgle ved at kombinere emnerne og følelserne genereret af 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']

Bagefter aggregerer vi på produktniveau og tæller de sammensatte nøgler for hvert produkt.

Dette sidste trin hjælper os med bedre at forstå granulariteten af ​​anmeldelserne pr. produkt og kategorisere dem pr. emne på en aggregeret måde. For eksempel kan vi overveje de viste værdier for emneDF DataFrame. For det første produkt, af alle anmeldelserne for det, havde kunderne generelt en positiv oplevelse med produktretur, størrelse og komfort. For det andet produkt havde kunderne for det meste en blandet til positiv oplevelse af produktretur og en positiv oplevelse af 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()

Vores endelige DataFrame består af denne emneinformation og sentimentinformation sammenføjet tilbage til den endelige DataFrame navngivet feedbackTopics som vi gemte på Amazon S3 i vores første notesbog.

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

Brug Amazon QuickSight til at visualisere dataene

Du kan bruge QuickSight til at visualisere dataene og generere rapporter. QuickSight er en business intelligence-tjeneste (BI), som du kan bruge til at forbruge data fra mange forskellige kilder og bygge intelligente dashboards. I dette eksempel genererer vi en QuickSight-analyse ved hjælp af det endelige datasæt, vi producerede, som vist i følgende eksempelvisualiseringer.

For at lære mere om Amazon QuickSight, se Kom godt i gang med Amazon Quicksight.

Ryd op

Til sidst skal vi lukke den notebook-instans, vi har brugt i dette eksperiment fra AWS Console.

Konklusion

I dette indlæg demonstrerede vi, hvordan man bruger Amazon Comprehend til at analysere produktanmeldelser og finde de bedste emner ved hjælp af emnemodellering som en teknik. Emnemodellering giver dig mulighed for at se flere emner igennem og organisere, forstå og opsummere dem i skala. Du kan hurtigt og nemt opdage skjulte mønstre, der er til stede på tværs af dataene, og derefter bruge denne indsigt til at træffe datadrevne beslutninger. Du kan bruge emnemodellering til at løse adskillige forretningsproblemer, såsom automatisk tagging af kundesupportbilletter, dirigere samtaler til de rigtige teams baseret på emne, opdage, hvor meget supportbilletter er, få bedre indsigt fra samtaler, oprette datadrevne planer, oprette problem -fokuseret indhold, forbedring af salgsstrategi og identificering af kundeproblemer og gnidninger.

Dette er blot nogle få eksempler, men du kan tænke på mange flere forretningsproblemer, som du står over for i din organisation på daglig basis, og hvordan du kan bruge emnemodellering med andre ML-teknikker til at løse dem.

---

Om forfatterne

Gurpreet er en dataforsker med AWS Professional Services baseret i Canada. Hun brænder for at hjælpe kunder med at innovere med Machine Learning og Artificial Intelligence-teknologier for at udnytte forretningsværdi og indsigt fra data. I sin fritid nyder hun at vandre udendørs og læse bøger.i

Rushdi Shams er dataforsker hos AWS Professional Services, Canada. Han bygger maskinlæringsprodukter til AWS-kunder. Han elsker at læse og skrive science fiction.

Wrick Talukdar er seniorarkitekt hos Amazon Comprehend Service-teamet. Han arbejder med AWS-kunder for at hjælpe dem med at indføre maskinlæring i stor skala. Uden for arbejdet holder han af at læse og fotografere.