Obtenha melhores insights de avaliações usando o Amazon Comprehend

“85% dos compradores confiam em avaliações online tanto quanto em recomendações pessoais” – Gartner

Os consumidores estão cada vez mais envolvidos com as empresas por meio de superfícies digitais e vários pontos de contato. As estatísticas mostram que a maioria dos compradores usa avaliações para determinar quais produtos comprar e quais serviços usar. Conforme Centro de Pesquisa Spiegel, a probabilidade de compra de um produto com cinco avaliações é 270% maior do que a probabilidade de compra de um produto sem avaliações. As avaliações têm o poder de influenciar as decisões do consumidor e fortalecer o valor da marca.

Neste post, usamos Amazon Comprehend para extrair informações significativas de análises de produtos, analisá-las para entender como os usuários de diferentes demografias estão reagindo aos produtos e descobrir informações agregadas sobre a afinidade do usuário em relação a um produto. O Amazon Comprehend é um serviço de processamento de linguagem natural (NLP) totalmente gerenciado e continuamente treinado que pode extrair informações sobre o conteúdo de um documento ou texto.

Visão geral da solução

Hoje, as avaliações podem ser fornecidas pelos clientes de várias maneiras, como classificações por estrelas, texto livre ou linguagem natural ou compartilhamentos de mídia social. Texto livre ou comentários em linguagem natural ajudam a construir confiança, pois é uma opinião independente dos consumidores. É frequentemente usado pelas equipes de produto para interagir com os clientes por meio de canais de avaliação. É um fato comprovado que quando os clientes se sentem ouvidos, seu sentimento sobre a marca melhora. Embora seja comparativamente mais fácil analisar classificações por estrelas ou compartilhamentos de mídia social, a linguagem natural ou as revisões de texto livre apresentam vários desafios, como identificar palavras-chave ou frases, tópicos ou conceitos e sentimentos em nível de entidade. O desafio se deve principalmente à variabilidade do comprimento do texto escrito e à presença plausível de sinais e ruídos. Além disso, a informação pode ser muito clara e explícita (por exemplo, com palavras-chave e frases-chave) ou pouco clara e implícita (temas e conceitos abstratos). Ainda mais desafiador é entender os diferentes tipos de sentimentos e relacioná-los a produtos e serviços adequados. No entanto, é muito importante entender essas informações e sinais textuais para fornecer uma experiência de cliente sem atritos.

Neste post, usamos um arquivo publicamente disponível PNL – fast.ai conjunto de dados para analisar as análises de produtos fornecidas pelos clientes. Começamos usando uma técnica de aprendizado de máquina não supervisionado (ML) conhecida como modelagem de tópicos. Esta é uma técnica popular não supervisionada que descobre tópicos abstratos que podem ocorrer em uma coleção de revisão de texto. A modelagem de tópicos é um problema de agrupamento não supervisionado, o que significa que os modelos não têm conhecimento sobre possíveis variáveis ​​de destino (como tópicos em uma revisão). Os tópicos são representados como clusters. Muitas vezes, o número de clusters em um corpus de documentos é decidido com a ajuda de especialistas do domínio ou usando alguma análise estatística padrão. As saídas do modelo geralmente têm três componentes: clusters numerados (tópico 0, tópico 1 e assim por diante), palavras-chave associadas a cada cluster e clusters representativos para cada documento (ou revisão em nosso caso). Por sua natureza inerente, os modelos de tópicos não geram rótulos legíveis por humanos para os clusters ou tópicos, o que é um equívoco comum. Algo a ser observado sobre a modelagem de tópicos em geral é que é um modelo de associação mista — cada documento no modelo pode ter uma semelhança com cada tópico. O modelo de tópico aprende em um processo Bayesiano iterativo para determinar a probabilidade de que cada documento esteja associado a um determinado tema ou tópico. A saída do modelo depende da seleção ideal do número de tópicos. Um pequeno número de tópicos pode resultar em tópicos muito amplos e um número maior de tópicos pode resultar em tópicos redundantes ou tópicos com semelhança. Existem várias maneiras de avaliar modelos de tópicos:

• Julgamento humano - Baseado em observação, baseado em interpretação
• Métricas quantitativas - Perplexidade, cálculos de coerência
• Abordagem mista - Uma combinação de abordagens quantitativas e baseadas em julgamento

A perplexidade é calculada dividindo um conjunto de dados em duas partes – um conjunto de treinamento e um conjunto de teste. A probabilidade geralmente é calculada como um logaritmo, portanto, essa métrica às vezes é chamada de probabilidade logarítmica mantida. A perplexidade é uma métrica preditiva. Ele avalia a capacidade de um modelo de tópico de prever um conjunto de teste após ter sido treinado em um conjunto de treinamento. Uma das deficiências da perplexidade é que ela não captura o contexto, o que significa que não captura a relação entre palavras em um tópico ou tópicos em um documento. No entanto, a ideia de contexto semântico é importante para a compreensão humana. Medidas como a probabilidade condicional da co-ocorrência de palavras em um tópico podem ser úteis. Essas abordagens são coletivamente chamadas de coerência. Para este post, nos concentramos na abordagem do julgamento humano (baseado na observação), ou seja, observar as n principais palavras em um tópico.

A solução consiste nas seguintes etapas de alto nível:

1. Configure um Amazon Sage Maker instância do notebook.
2. Crie um caderno.
3. Realize análises exploratórias de dados.
4. Execute seu trabalho de modelagem de tópicos do Amazon Comprehend.
5. Gere tópicos e entenda o sentimento.
6. Use AmazonQuickSight para visualizar dados e gerar relatórios.

Você pode usar essa solução em qualquer região da AWS, mas precisa garantir que as APIs do Amazon Comprehend e o SageMaker estejam na mesma região. Para este post, usamos a Região Leste dos EUA (Norte da Virgínia).

Configure sua instância de notebook SageMaker

Você pode interagir com o Amazon Comprehend por meio do Console de gerenciamento da AWS, Interface de linha de comando AWS (AWS CLI), ou API do Amazon Comprehend. Para obter mais informações, consulte Introdução ao Amazon Comprehend. Usamos um notebook SageMaker e um código Python (Boto3) em toda esta postagem para interagir com as APIs do Amazon Comprehend.

1. No console do Amazon SageMaker, em Notebook no painel de navegação, escolha
   Instâncias de notebook.
2. Escolha Criar instância de notebook.
3. Especifique um nome de instância de notebook e defina o tipo de instância como ml.r5.2xlarge.
4. Deixe o restante das configurações padrão.
5. Crie uma AWS Identity and Access Management (IAM) papel com AmazonSageMakerFullAccess e acesso a todos os necessários Serviço de armazenamento simples da Amazon (Amazon S3) buckets e APIs do Amazon Comprehend.
6. Escolha Criar instância de notebook.
   Após alguns minutos, sua instância de notebook está pronta.
7. Para acessar o Amazon Comprehend da instância do notebook, você precisa anexar o ComprehendFullAccess política para sua função do IAM.

Para obter uma visão geral de segurança do Amazon Comprehend, consulte Segurança no Amazon Comprehend.

Depois de abrir a instância do notebook que você provisionou, no console do Jupyter, escolha New e depois Python 3 (Data Science). Alternativamente, você pode acessar o arquivo de código de amostra no GitHub repo. Você pode fazer upload do arquivo para a instância do notebook para executá-lo diretamente ou cloná-lo.

O repositório do GitHub contém três notebooks:

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

Realizar análise exploratória de dados

Usamos o primeiro caderno (data_processing.ipynb) para explorar e processar os dados. Começamos simplesmente carregando os dados de um bucket do S3 em um 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)

Na seção seguinte, realizamos a análise exploratória de dados (EDA) para entender os dados. Começamos explorando a forma dos dados e metadados. Para autenticidade, usamos apenas avaliações verificadas.

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

Exploramos ainda mais a contagem de cada categoria e verificamos se há dados duplicados.

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

Quando estivermos satisfeitos com os resultados, passamos para a próxima etapa de pré-processamento dos dados. O Amazon Comprehend recomenda fornecer pelo menos 1,000 documentos em cada trabalho de modelagem de tópicos, com cada documento com pelo menos três frases. Os documentos devem estar em arquivos de texto formatados em UTF-8. Na etapa a seguir, garantimos que os dados estejam no formato UTF-8 recomendado e que cada entrada não tenha mais de 5,000 bytes de tamanho.

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)

Em seguida, salvamos os dados no Amazon S3 e também mantemos uma cópia local na instância do notebook.

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

Isso conclui nossa fase de processamento de dados.

Executar um trabalho de modelagem de tópicos do Amazon Comprehend

Em seguida, passamos para a próxima fase, na qual usamos os dados pré-processados ​​para executar um trabalho de modelagem de tópicos usando o Amazon Comprehend. Nesta fase, você pode usar o segundo notebook (model_training.ipynb) ou use o console do Amazon Comprehend para executar o trabalho de modelagem de tópicos. Para obter instruções sobre como usar o console, consulte Executando jobs de análise usando o console. Se estiver usando o notebook, você pode começar criando um cliente Amazon Comprehend usando Boto3, conforme mostrado no exemplo a seguir.

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

Você pode enviar seus documentos para modelagem de tópicos de duas maneiras: um documento por arquivo ou um documento por linha.

Começamos com 5 tópicos (k-number) e usamos um documento por linha. Não existe uma única melhor maneira como prática padrão para selecionar k ou o número de tópicos. Você pode experimentar diferentes valores de k e selecionar aquele que tem a maior probabilidade.

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

Nosso trabalho de modelagem de tópicos do Amazon Comprehend exige que você passe um InputDataConfig objeto de dicionário com S3, InputFormat e DocumentReadAction como parâmetros necessários. Da mesma forma, você precisa fornecer o OutputDataConfig objeto com S3 e DataAccessRoleArn como parâmetros necessários. Para obter mais informações, consulte a documentação do Boto3 para 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,
}

Em seguida, você pode iniciar um trabalho de detecção de tópico assíncrono passando o número de tópicos, objeto de configuração de entrada, objeto de configuração de saída e uma função do IAM, conforme mostrado no exemplo a seguir.

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

Você pode acompanhar o status atual do trabalho chamando o DescribeTopicDetectionJob Operação. O status do trabalho pode ser um dos seguintes:

• ENVIADO – O trabalho foi recebido e está na fila para processamento
• IN_PROGRESS – Amazon Comprehend está processando o trabalho
• COMPLETED – O trabalho foi concluído com sucesso e a saída está disponível
• FALHA – O trabalho não foi concluído

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

Quando o trabalho é concluído com êxito, ele retorna um archive compactado contendo dois arquivos: topic-terms.csv e doc-topics.csv. O primeiro arquivo de saída, topic-terms.csv, é uma lista de tópicos na coleção. Para cada tópico, a lista inclui, por padrão, os principais termos por tópico de acordo com seu peso. O segundo arquivo, doc-topics.csv, lista os documentos associados a um tópico e a proporção do documento referente ao tópico. Porque nós especificamos ONE_DOC_PER_LINE anteriormente no input_doc_format variável, o documento é identificado pelo nome do arquivo e pelo número da linha indexada em 0 dentro do arquivo. Para obter mais informações sobre modelagem de tópicos, consulte Modelagem de tópicos.
As saídas do Amazon Comprehend são copiadas localmente para nossas próximas etapas.

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

Como o número de tópicos é muito menor do que o vocabulário associado à coleção de documentos, a representação do espaço de tópicos também pode ser vista como um processo de redução de dimensionalidade. Você pode usar esta representação do espaço de tópicos de documentos para realizar clustering. Por outro lado, você pode analisar a frequência de palavras em cada cluster para determinar o tópico associado a cada cluster. Para este post, não realizamos outras técnicas como clustering.

Usamos o terceiro caderno (topic_mapping_sentiment_generation.ipynb) para descobrir como os usuários de diferentes grupos demográficos estão reagindo aos produtos e também analisar informações agregadas sobre a afinidade do usuário em relação a um determinado produto.

Podemos combinar as saídas do bloco de anotações anterior para obter tópicos e termos associados para cada tópico. No entanto, os tópicos são numerados e podem carecer de explicabilidade. Portanto, preferimos usar um humano no circuito com conhecimento de domínio suficiente e experiência no assunto para nomear os tópicos observando seus termos associados. Esse processo pode ser considerado como um mapeamento de números de tópicos para nomes de tópicos. No entanto, vale ressaltar que a lista individual de termos para os tópicos pode ser mutuamente inclusiva e, portanto, pode criar vários mapeamentos. O human-in-the-loop deve formalizar os mapeamentos com base no contexto do caso de uso. Caso contrário, o desempenho downstream pode ser afetado.

Começamos declarando as variáveis. Para cada revisão, pode haver vários tópicos. Contamos sua frequência e selecionamos no máximo três tópicos mais frequentes. Esses tópicos são relatados como os tópicos representativos de uma revisão. Primeiro, definimos uma variável TOP_TOPICS para manter o número máximo de tópicos representativos. Em segundo lugar, definimos e definimos valores para o language_code variável para oferecer suporte ao parâmetro de idioma necessário do Amazon Comprehend. Por fim, criamos topicMaps, que é um dicionário que mapeia números de tópicos para nomes de tópicos.

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

Em seguida, usamos o arquivo topic-terms.csv gerado pelo Amazon Comprehend para conectar os termos exclusivos associados a cada tópico. Em seguida, aplicando o dicionário de mapeamento nessa associação tópico-termo, conectamos os termos exclusivos aos nomes dos tópicos.

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

Esse mapeamento melhora a legibilidade e a explicabilidade dos tópicos gerados pelo Amazon Comprehend, como podemos ver no DataFrame a seguir.

Além disso, juntamos o número do tópico, termos e nomes aos dados de entrada iniciais, conforme mostrado nas etapas a seguir.

Isso retorna termos e nomes de tópicos correspondentes a cada revisão. Os números e os termos dos tópicos são reunidos em cada revisão e, em seguida, reunidos de volta ao DataFrame original que salvamos no primeiro bloco de anotações.

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

Geramos sentimento para o texto de revisão usando detect_sentiment. Ele inspeciona o texto e retorna uma inferência do sentimento predominante (POSITIVO, NEUTRO, MISTURADO ou NEGATIVO).

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)

Tanto os tópicos quanto os sentimentos estão intimamente ligados às avaliações. Como agregaremos tópicos e sentimentos no nível do produto, precisamos criar uma chave composta combinando os tópicos e sentimentos gerados pelo 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']

Depois, agregamos no nível do produto e contamos as chaves compostas para cada produto.

Essa etapa final nos ajuda a entender melhor a granularidade das avaliações por produto e a categorizá-la por tópico de maneira agregada. Por exemplo, podemos considerar os valores mostrados para topicDF DataFrame. Para o primeiro produto, de todos os comentários sobre ele, no geral os clientes tiveram uma experiência positiva em termos de devolução, tamanho e conforto do produto. Para o segundo produto, os clientes tiveram principalmente uma experiência mista a positiva na devolução do produto e uma experiência positiva no tamanho do produto.

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

Nosso DataFrame final consiste nessas informações de tópico e informações de sentimento unidas de volta ao DataFrame final chamado feedbackTopics que salvamos no Amazon S3 em nosso primeiro notebook.

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

Use o Amazon QuickSight para visualizar os dados

Você pode usar o QuickSight para visualizar os dados e gerar relatórios. O QuickSight é um serviço de business intelligence (BI) que você pode usar para consumir dados de várias fontes diferentes e criar painéis inteligentes. Neste exemplo, geramos uma análise do QuickSight usando o conjunto de dados final que produzimos, conforme mostrado nas visualizações de exemplo a seguir.

Para saber mais sobre o Amazon QuickSight, consulte Introdução ao Amazon Quicksight.

Limpar

No final, precisamos desligar a instância do notebook que usamos neste experimento do Console AWS.

Conclusão

Neste post, demonstramos como usar o Amazon Comprehend para analisar análises de produtos e encontrar os principais tópicos usando a modelagem de tópicos como técnica. A modelagem de tópicos permite examinar vários tópicos e organizá-los, compreendê-los e resumi-los em escala. Você pode descobrir de forma rápida e fácil padrões ocultos que estão presentes nos dados e, em seguida, usar esse insight para tomar decisões orientadas por dados. Você pode usar a modelagem de tópicos para resolver vários problemas de negócios, como marcar automaticamente tíquetes de suporte ao cliente, encaminhar conversas para as equipes certas com base no tópico, detectar a urgência de tíquetes de suporte, obter melhores insights de conversas, criar planos orientados por dados, criar problemas -Conteúdo focado, melhorando a estratégia de vendas e identificando problemas e atritos do cliente.

Esses são apenas alguns exemplos, mas você pode pensar em muitos outros problemas de negócios que enfrenta diariamente em sua organização e como usar a modelagem de tópicos com outras técnicas de ML para resolvê-los.

---

Sobre os autores

Gurpreet é um cientista de dados da AWS Professional Services com sede no Canadá. Ela é apaixonada por ajudar os clientes a inovar com tecnologias de Machine Learning e Inteligência Artificial para aproveitar o valor de negócios e insights de dados. Nas horas vagas, gosta de fazer caminhadas ao ar livre e ler livros.i

Rushdi Shams é cientista de dados da AWS Professional Services, Canadá. Ele cria produtos de machine learning para clientes da AWS. Ele adora ler e escrever ficção científica.

Wrick Talukdar é arquiteto sênior da equipe do Amazon Comprehend Service. Ele trabalha com clientes da AWS para ajudá-los a adotar o aprendizado de máquina em larga escala. Fora do trabalho, gosta de ler e fotografar.