Få bättre insikt från recensioner med Amazon Comprehend

"85 % av köparna litar lika mycket på onlinerecensioner som en personlig rekommendation" - Gartner

Konsumenter engagerar sig alltmer med företag genom digitala ytor och flera kontaktpunkter. Statistik visar att majoriteten av shoppare använder recensioner för att avgöra vilka produkter de ska köpa och vilka tjänster de ska använda. Enligt Spiegel Research Center, är köpsannolikheten för en produkt med fem recensioner 270 % större än köpsannolikheten för en produkt utan recensioner. Recensioner har makten att påverka konsumenternas beslut och stärka varumärkesvärdet.

I det här inlägget använder vi Amazon Comprehend att extrahera meningsfull information från produktrecensioner, analysera den för att förstå hur användare av olika demografier reagerar på produkter och upptäcka samlad information om användaraffinitet till en produkt. Amazon Comprehend är en fullt hanterad och kontinuerligt utbildad NLP-tjänst (natural language processing) som kan extrahera insikter om innehållet i ett dokument eller en text.

Lösningsöversikt

Idag kan recensioner tillhandahållas av kunder på olika sätt, såsom stjärnbetyg, fritext eller naturligt språk, eller delningar i sociala medier. Fritext eller naturliga recensioner hjälper till att bygga förtroende, eftersom det är en oberoende åsikt från konsumenter. Det används ofta av produktteam för att interagera med kunder genom granskningskanaler. Det är ett bevisat faktum att när kunder känner sig hörda, förbättras deras känsla för varumärket. Medan det är förhållandevis lättare att analysera stjärnbetyg eller delningar i sociala medier, utgör naturligt språk eller fritextrecensioner flera utmaningar, som att identifiera nyckelord eller fraser, ämnen eller begrepp, och känslor eller känslor på enhetsnivå. Utmaningen beror främst på variationen i längd i skriven text och rimlig närvaro av både signaler och brus. Vidare kan informationen antingen vara mycket tydlig och explicit (till exempel med nyckelord och nyckelfraser) eller otydlig och implicit (abstrakta ämnen och begrepp). Ännu mer utmanande är att förstå olika typer av känslor och relatera dem till lämpliga produkter och tjänster. Ändå är det mycket viktigt att förstå denna information och textsignaler för att ge en friktionsfri kundupplevelse.

I det här inlägget använder vi en allmänt tillgänglig NLP – fast.ai datauppsättning för att analysera produktrecensioner från kunder. Vi börjar med att använda en oövervakad maskininlärningsteknik (ML) som kallas ämnesmodellering. Detta är en populär oövervakad teknik som upptäcker abstrakta ämnen som kan förekomma i en textrecensionssamling. Ämnesmodellering är ett klustringsproblem som är oövervakat, vilket innebär att modellerna inte har någon kunskap om möjliga målvariabler (som ämnen i en översikt). Ämnena representeras som kluster. Ofta bestäms antalet kluster i en korpus av dokument med hjälp av domänexperter eller med hjälp av någon standard statistisk analys. Modellutgångarna har i allmänhet tre komponenter: numrerade kluster (ämne 0, ämne 1, och så vidare), nyckelord associerade med varje kluster och representativa kluster för varje dokument (eller recension i vårt fall). Genom sin inneboende natur genererar inte ämnesmodeller läsbara etiketter för klustren eller ämnena, vilket är en vanlig missuppfattning. Något att notera om ämnesmodellering i allmänhet är att det är en blandad medlemskapsmodell – varje dokument i modellen kan ha en likhet med varje ämne. Ämnesmodellen lär sig i en iterativ Bayesiansk process för att bestämma sannolikheten för att varje dokument är associerat med ett givet tema eller ämne. Modellens utdata beror på att man väljer antalet ämnen optimalt. Ett litet antal ämnen kan leda till att ämnena blir för breda och ett större antal ämnen kan resultera i överflödiga ämnen eller ämnen med likhet. Det finns ett antal sätt att utvärdera ämnesmodeller:

• Mänskligt omdöme – Observationsbaserat, tolkningsbaserat
• Kvantitativa mått – Förvirring, koherensberäkningar
• Mixed approach – En kombination av bedömningsbaserade och kvantitativa metoder

Förvirring beräknas genom att dela upp en datauppsättning i två delar – en träningsuppsättning och en testuppsättning. Sannolikhet beräknas vanligtvis som en logaritm, så detta mått kallas ibland för den uthållna logaritmen. Förvirring är ett prediktivt mått. Den bedömer en ämnesmodells förmåga att förutsäga ett testset efter att ha tränats på ett träningsset. En av bristerna med förvirring är att den inte fångar sammanhanget, vilket betyder att den inte fångar förhållandet mellan ord i ett ämne eller ämnen i ett dokument. Men idén om semantiskt sammanhang är viktig för mänsklig förståelse. Åtgärder som villkorlig sannolikhet för samtidig förekomst av ord i ett ämne kan vara till hjälp. Dessa tillvägagångssätt kallas gemensamt för koherens. För det här inlägget fokuserar vi på det mänskliga omdömet (observationsbaserade) tillvägagångssättet, nämligen att observera de n översta orden i ett ämne.

Lösningen består av följande steg på hög nivå:

1. Ställ in en Amazon SageMaker anteckningsbok instans.
2. Skapa en anteckningsbok.
3. Utför analysdata.
4. Kör ditt Amazon Comprehend-ämnesmodelleringsjobb.
5. Skapa ämnen och förstå känslor.
6. Använda Amazon QuickSight att visualisera data och generera rapporter.

Du kan använda den här lösningen i vilken AWS-region som helst, men du måste se till att Amazon Comprehend API och SageMaker är i samma region. För det här inlägget använder vi regionen US East (N. Virginia).

Konfigurera din SageMaker-anteckningsbok-instans

Du kan interagera med Amazon Comprehend via AWS Management Console, AWS-kommandoradsgränssnitt (AWS CLI), eller Amazon Comprehend API. För mer information, se Komma igång med Amazon Comprehend. Vi använder en SageMaker-anteckningsbok och Python (Boto3)-kod genom hela det här inlägget för att interagera med Amazon Comprehend API:er.

1. På Amazon SageMaker-konsolen, under Notebook i navigeringsfönstret, välj
   Notebook-instanser.
2. Välj Skapa anteckningsboksinstans.
3. Ange ett namn på en anteckningsbokförekomst och ställ in instanstypen som ml.r5.2xlarge.
4. Lämna resten av standardinställningarna.
5. Skapa ett AWS Identity and Access Management (IAM) roll med AmazonSageMakerFullAccess och tillgång till alla nödvändiga Amazon Simple Storage Service (Amazon S3) hinkar och Amazon Comprehend API:er.
6. Välj Skapa anteckningsboksinstans.
   Efter några minuter är din anteckningsbok-instans klar.
7. För att komma åt Amazon Comprehend från anteckningsboken måste du bifoga ComprehendFullAccess policy för din IAM-roll.

För en säkerhetsöversikt över Amazon Comprehend, se Säkerhet i Amazon Comprehend.

När du har öppnat notebook-instansen som du tillhandahållit, på Jupyter-konsolen, välj Ny och sedan Python 3 (Data Science). Alternativt kan du komma åt exempelkodfilen i GitHub repo. Du kan ladda upp filen till notebook-instansen för att köra den direkt eller klona den.

GitHub-repoet innehåller tre anteckningsböcker:

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

Utför utforskande dataanalys

Vi använder den första anteckningsboken (data_processing.ipynb) för att utforska och bearbeta data. Vi börjar med att helt enkelt ladda data från en S3-bucket till 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 följande avsnitt utför vi utforskande dataanalys (EDA) för att förstå data. Vi börjar med att utforska formen på data och metadata. För autenticitet använder vi endast verifierade recensioner.

# 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öker ytterligare antalet av varje kategori och ser om det finns några dubbletter av data.

# 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 är nöjda med resultatet går vi vidare till nästa steg av förbearbetning av data. Amazon Comprehend rekommenderar att du tillhandahåller minst 1,000 8 dokument i varje ämnesmodelleringsjobb, med varje dokument minst tre meningar långt. Dokument måste vara i UTF-8-formaterade textfiler. I följande steg ser vi till att data är i det rekommenderade UTF-5,000-formatet och att varje indata inte är större än XNUMX XNUMX byte.

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 sparar sedan data till Amazon S3 och behåller även en lokal kopia i notebook-instansen.

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

Detta avslutar vår databehandlingsfas.

Kör ett Amazon Comprehend-ämnesmodelleringsjobb

Vi går sedan till nästa fas, där vi använder förbearbetade data för att köra ett ämnesmodelleringsjobb med Amazon Comprehend. I detta skede kan du antingen använda den andra anteckningsboken (model_training.ipynb) eller använd Amazon Comprehend-konsolen för att köra ämnesmodelleringsjobbet. För instruktioner om hur du använder konsolen, se Kör analysjobb med hjälp av konsolen. Om du använder anteckningsboken kan du börja med att skapa en Amazon Comprehend-klient med Boto3, som visas i följande exempel.

# 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 skicka in dina dokument för ämnesmodellering på två sätt: ett dokument per fil eller ett dokument per rad.

Vi börjar med 5 ämnen (k-nummer), och använder ett dokument per rad. Det finns inget enskilt bästa sätt som standardpraxis att välja k eller antalet ämnen. Du kan prova olika värden på k och välja den som har störst sannolikhet.

# 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årt Amazon Comprehend-ämnemodelleringsjobb kräver att du klarar ett InputDataConfig ordboksobjekt med S3, InputFormatoch DocumentReadAction efter erforderliga parametrar. På samma sätt måste du tillhandahålla OutputDataConfig objekt med S3 och DataAccessRoleArn efter erforderliga parametrar. För mer information, se Boto3-dokumentationen för 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 sedan starta ett asynkront ämnesdetekteringsjobb genom att skicka antalet ämnen, inmatningskonfigurationsobjekt, output-konfigurationsobjekt och en IAM-roll, som visas i följande exempel.

# 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 spåra aktuell status för jobbet genom att ringa DescribeTopicDetectionJob drift. Statusen för jobbet kan vara något av följande:

• LÄMNAT – Jobbet har tagits emot och står i kö för behandling
• IN_PROGRESS – Amazon Comprehend bearbetar jobbet
• AVSLUTAD – Jobbet slutfördes och resultatet är tillgängligt
• FAILED – Jobbet slutfördes inte

# 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 är slutfört returnerar det ett komprimerat arkiv som innehåller två filer: topic-terms.csv och doc-topics.csv. Den första utdatafilen, topic-terms.csv, är en lista över ämnen i samlingen. För varje ämne innehåller listan, som standard, de bästa termerna per ämne enligt deras vikt. Den andra filen, doc-topics.csv, listar de dokument som är kopplade till ett ämne och hur stor andel av dokumentet som rör ämnet. För att vi specificerade ONE_DOC_PER_LINE tidigare i input_doc_format variabel, identifieras dokumentet av filnamnet och det 0-indexerade radnumret i filen. För mer information om ämnesmodellering, se Ämnesmodellering.
Utdata från Amazon Comprehend kopieras lokalt för våra nästa steg.

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

Eftersom antalet ämnen är mycket mindre än vokabulären som är associerad med dokumentsamlingen, kan ämnesutrymmesrepresentationen också ses som en dimensionsreducerande process. Du kan använda den här ämnesrepresentationen av dokument för att utföra klustring. Å andra sidan kan du analysera frekvensen av ord i varje kluster för att bestämma ämne som är associerat med varje kluster. För det här inlägget utför vi inga andra tekniker som klustring.

Vi använder den tredje anteckningsboken (topic_mapping_sentiment_generation.ipynb) för att ta reda på hur användare av olika demografier reagerar på produkter, och även analysera samlad information om användaraffinitet till en viss produkt.

Vi kan kombinera utdata från föregående anteckningsbok för att få ämnen och tillhörande termer för varje ämne. Ämnena är dock numrerade och kan sakna förklaring. Därför föredrar vi att använda en människa-i-loopen med tillräckligt med domänkunskap och ämnesexpertis för att namnge ämnena genom att titta på deras associerade termer. Denna process kan betraktas som en kartläggning från ämnesnummer till ämnesnamn. Det är dock anmärkningsvärt att den individuella listan med termer för ämnena kan vara ömsesidigt inkluderande och därför kan skapa flera mappningar. Människan-i-slingan bör formalisera mappningarna baserat på sammanhanget för användningsfallet. Annars kan nedströmsprestandan påverkas.

Vi börjar med att deklarera variablerna. För varje recension kan det finnas flera ämnen. Vi räknar deras frekvens och väljer max tre vanligaste ämnen. Dessa ämnen rapporteras som representativa ämnen i en recension. Först definierar vi en variabel TOP_TOPICS att hålla det maximala antalet representativa ämnen. För det andra definierar vi och ställer in värden till language_code variabel för att stödja den erforderliga språkparametern för Amazon Comprehend. Äntligen skapar vi topicMaps, som är en ordbok som mappar ämnesnummer till ämnesnamn.

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

Därefter använder vi filen topic-terms.csv som genereras av Amazon Comprehend för att koppla samman de unika termer som är associerade med varje ämne. Sedan, genom att använda kartordboken på den här ämnestermassociationen, kopplar vi de unika termerna till ämnesnamnen.

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

Denna kartläggning förbättrar läsbarheten och förklarabarheten för de ämnen som genereras av Amazon Comprehend, som vi kan se i följande DataFrame.

Dessutom kopplar vi ämnesnumret, termerna och namnen till de initiala indata, som visas i följande steg.

Detta returnerar ämnestermer och namn som motsvarar varje recension. Ämnesnumren och termerna sammanfogas med varje recension och förenas sedan vidare till den ursprungliga DataFrame som vi sparade i den första anteckningsboken.

# 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 genererar sentiment för recensionstexten med hjälp av detect_sentiment. Den inspekterar text och returnerar en slutledning av den rådande känslan (POSITIV, NEUTRAL, BLANDAD 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 ämnen och känslor är tätt kopplade till recensioner. Eftersom vi kommer att samla ämnen och känslor på produktnivå, måste vi skapa en sammansatt nyckel genom att kombinera ämnen och känslor som genereras 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']

Efteråt aggregerar vi på produktnivå och räknar sammansatta nycklar för varje produkt.

Det här sista steget hjälper oss att bättre förstå granulariteten i recensionerna per produkt och kategorisera dem per ämne på ett aggregerat sätt. Till exempel kan vi överväga värdena som visas för topicDF DataFrame. För den första produkten, av alla recensioner för den, hade kunderna totalt sett en positiv upplevelse av produktretur, storlek och komfort. För den andra produkten hade kunderna mestadels en blandad till positiv upplevelse av produktretur och en positiv upplevelse av produktstorlek.

# 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 slutliga DataFrame består av denna ämnesinformation och sentimentinformation sammanfogad till den slutliga DataFrame som heter feedbackTopics som vi sparade på Amazon S3 i vår första anteckningsbok.

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

Använd Amazon QuickSight för att visualisera data

Du kan använda QuickSight för att visualisera data och generera rapporter. QuickSight är en BI-tjänst (business intelligence) som du kan använda för att konsumera data från många olika källor och bygga intelligenta instrumentpaneler. I det här exemplet genererar vi en QuickSight-analys med den slutliga datamängden vi producerade, som visas i följande exempelvisualiseringar.

För att lära dig mer om Amazon QuickSight, se Komma igång med Amazon Quicksight.

Städa

I slutet måste vi stänga av notebook-instansen som vi har använt i det här experimentet från AWS Console.

Slutsats

I det här inlägget demonstrerade vi hur man använder Amazon Comprehend för att analysera produktrecensioner och hitta de bästa ämnena med hjälp av ämnesmodellering som en teknik. Ämnesmodellering gör att du kan titta igenom flera ämnen och organisera, förstå och sammanfatta dem i stor skala. Du kan snabbt och enkelt upptäcka dolda mönster som finns i data och sedan använda den insikten för att fatta datadrivna beslut. Du kan använda ämnesmodellering för att lösa många affärsproblem, som att automatiskt tagga kundsupportbiljetter, dirigera konversationer till rätt team baserat på ämne, upptäcka hur brådskande supportärenden är, få bättre insikter från konversationer, skapa datadrivna planer, skapa problem -fokuserat innehåll, förbättra säljstrategin och identifiera kundproblem och friktioner.

Det här är bara några exempel, men du kan tänka på många fler affärsproblem som du möter i din organisation dagligen, och hur du kan använda ämnesmodellering med andra ML-tekniker för att lösa dessa.

---

Om författarna

Gurpreet är en dataforskare med AWS Professional Services baserad från Kanada. Hon brinner för att hjälpa kunder att förnya sig med maskininlärning och artificiell intelligens för att utnyttja affärsvärde och insikter från data. På fritiden tycker hon om att vandra utomhus och läsa böcker.i

Rushdi Shams är en dataforskare med AWS Professional Services, Kanada. Han bygger maskininlärningsprodukter för AWS-kunder. Han älskar att läsa och skriva science fiction.

Wrick Talukdar är en senior arkitekt med Amazon Comprehend Service-team. Han arbetar med AWS-kunder för att hjälpa dem att ta till sig maskininlärning i stor skala. Utanför jobbet tycker han om att läsa och fotografera.