Obtenga una mejor perspectiva de las reseñas con Amazon Comprehend

“El 85% de los compradores confían tanto en las reseñas en línea como en una recomendación personal” – Gartner

Los consumidores interactúan cada vez más con las empresas a través de superficies digitales y múltiples puntos de contacto. Las estadísticas muestran que la mayoría de los compradores utilizan las reseñas para determinar qué productos comprar y qué servicios utilizar. según Centro de Investigación Spiegel, la probabilidad de compra de un producto con cinco reseñas es un 270 % mayor que la probabilidad de compra de un producto sin reseñas. Las reseñas tienen el poder de influir en las decisiones de los consumidores y fortalecer el valor de la marca.

En esta publicación, usamos Amazon Comprehend para extraer información significativa de las revisiones de productos, analizarla para comprender cómo los usuarios de diferentes grupos demográficos reaccionan a los productos y descubrir información agregada sobre la afinidad de los usuarios hacia un producto. Amazon Comprehend es un servicio de procesamiento de lenguaje natural (NLP) completamente administrado y capacitado continuamente que puede extraer información sobre el contenido de un documento o texto.

Resumen de la solución

Hoy en día, los clientes pueden proporcionar reseñas de varias maneras, como calificaciones de estrellas, texto libre o lenguaje natural, o compartir en las redes sociales. Las reseñas en texto libre o en lenguaje natural ayudan a generar confianza, ya que es una opinión independiente de los consumidores. A menudo, los equipos de productos lo utilizan para interactuar con los clientes a través de los canales de revisión. Es un hecho comprobado que cuando los clientes se sienten escuchados, su percepción de la marca mejora. Mientras que es comparativamente más fácil analizar calificaciones de estrellas o compartir en redes sociales, el lenguaje natural o las revisiones de texto libre plantean múltiples desafíos, como identificar palabras clave o frases, temas o conceptos y opiniones o opiniones a nivel de entidad. El desafío se debe principalmente a la variabilidad de la longitud del texto escrito y la presencia plausible de señales y ruido. Además, la información puede ser muy clara y explícita (por ejemplo, con palabras clave y frases clave) o poco clara e implícita (temas y conceptos abstractos). Aún más desafiante es comprender diferentes tipos de sentimientos y relacionarlos con productos y servicios apropiados. Sin embargo, es muy importante comprender esta información y las señales textuales para brindar una experiencia de cliente sin fricciones.

En esta publicación, usamos un disponible públicamente PNL – fast.ai conjunto de datos para analizar las reseñas de productos proporcionadas por los clientes. Comenzamos usando una técnica de aprendizaje automático (ML) no supervisada conocida como modelado de temas. Esta es una técnica popular no supervisada que descubre temas abstractos que pueden ocurrir en una colección de revisión de texto. El modelado de temas es un problema de agrupación que no está supervisado, lo que significa que los modelos no tienen conocimiento de las posibles variables de destino (como los temas de una revisión). Los temas se representan como grupos. A menudo, el número de grupos en un corpus de documentos se decide con la ayuda de expertos en el dominio o mediante algún análisis estadístico estándar. Los resultados del modelo generalmente tienen tres componentes: grupos numerados (tema 0, tema 1, etc.), palabras clave asociadas a cada grupo y grupos representativos para cada documento (o revisión en nuestro caso). Por su naturaleza inherente, los modelos de temas no generan etiquetas legibles para los grupos o temas, lo cual es un error común. Algo a tener en cuenta sobre el modelado de temas en general es que se trata de un modelo de pertenencia mixta: cada documento del modelo puede tener un parecido con todos los temas. El modelo de tema aprende en un proceso bayesiano iterativo para determinar la probabilidad de que cada documento esté asociado con un tema o tema determinado. El resultado del modelo depende de la selección óptima del número de temas. Una pequeña cantidad de temas puede dar como resultado que los temas sean demasiado amplios, y una gran cantidad de temas puede dar como resultado temas redundantes o temas similares. Hay varias maneras de evaluar los modelos de temas:

• Juicio humano: basado en la observación, basado en la interpretación
• Métricas cuantitativas – Perplejidad, cálculos de coherencia
• Enfoque mixto: una combinación de enfoques cuantitativos y basados ​​en el juicio

La perplejidad se calcula dividiendo un conjunto de datos en dos partes: un conjunto de entrenamiento y un conjunto de prueba. La probabilidad generalmente se calcula como un logaritmo, por lo que esta métrica a veces se denomina log-verosimilitud retenida. La perplejidad es una métrica predictiva. Evalúa la capacidad de un modelo de tema para predecir un conjunto de prueba después de haber sido entrenado en un conjunto de entrenamiento. Una de las deficiencias de la perplejidad es que no capta el contexto, lo que significa que no capta la relación entre las palabras de un tema o los temas de un documento. Sin embargo, la idea de contexto semántico es importante para la comprensión humana. Pueden ser útiles medidas como la probabilidad condicional de la concurrencia de palabras en un tema. Estos enfoques se conocen colectivamente como coherencia. Para esta publicación, nos enfocamos en el enfoque del juicio humano (basado en la observación), es decir, observar las n palabras principales en un tema.

La solución consta de los siguientes pasos de alto nivel:

1. Configurar un Amazon SageMaker instancia de cuaderno.
2. Crea un cuaderno.
3. Realice análisis de datos exploratorios.
4. Ejecute su trabajo de modelado de temas de Amazon Comprehend.
5. Generar temas y comprender el sentimiento.
6. Uso Amazon QuickSight para visualizar datos y generar informes.

Puede utilizar esta solución en cualquier región de AWS, pero debe asegurarse de que las API de Amazon Comprehend y SageMaker estén en la misma región. Para esta publicación, usamos la Región EE. UU. Este (Norte de Virginia).

Configure su instancia de bloc de notas de SageMaker

Puede interactuar con Amazon Comprehend a través de la Consola de administración de AWS, Interfaz de línea de comandos de AWS (AWS CLI)o Amazon Comprender API. Para obtener más información, consulte Primeros pasos con Amazon Comprehend. Usamos un cuaderno SageMaker y código Python (Boto3) en esta publicación para interactuar con las API de Amazon Comprehend.

1. En la consola de Amazon SageMaker, en Notebook en el panel de navegación, elija
   Instancias de portátiles.
2. Elija Crear instancia de cuaderno.
3. Especifique un nombre de instancia de notebook y establezca el tipo de instancia como ml.r5.2xlarge.
4. Deje el resto de la configuración predeterminada.
5. Crear una Administración de acceso e identidad de AWS (IAM) papel con AmazonSageMakerFullAccess y acceso a todo lo necesario Servicio de almacenamiento simple de Amazon (Amazon S3) cubos y Amazon Comprehend API.
6. Elija Crear instancia de cuaderno.
   Después de unos minutos, su instancia de notebook está lista.
7. Para acceder a Amazon Comprehend desde la instancia del cuaderno, debe adjuntar el ComprehendFullAccess política a su rol de IAM.

Para obtener una descripción general de la seguridad de Amazon Comprehend, consulte Seguridad en Amazon Comprehend.

Después de abrir la instancia del cuaderno que aprovisionó, en la consola de Jupyter, elija Nuevo y luego Python 3 (Ciencia de datos). Alternativamente, puede acceder al archivo de código de muestra en el Repositorio GitHub. Puede cargar el archivo en la instancia del cuaderno para ejecutarlo directamente o clonarlo.

El repositorio de GitHub contiene tres cuadernos:

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

Realizar análisis de datos exploratorios

Usamos el primer cuaderno (data_processing.ipynb) para explorar y procesar los datos. Comenzamos simplemente cargando los datos de un depósito S3 en un 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)

En la siguiente sección, realizamos un análisis exploratorio de datos (EDA) para comprender los datos. Comenzamos explorando la forma de los datos y metadatos. Para mayor autenticidad, utilizamos solo reseñas 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 más a fondo el recuento de cada categoría y vemos si hay datos 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()])

Cuando estamos satisfechos con los resultados, pasamos al siguiente paso de preprocesamiento de los datos. Amazon Comprehend recomienda proporcionar al menos 1,000 documentos en cada trabajo de modelado de temas, con cada documento de al menos tres oraciones. Los documentos deben estar en archivos de texto con formato UTF-8. En el siguiente paso, nos aseguramos de que los datos estén en el formato UTF-8 recomendado y que cada entrada no tenga más de 5,000 bytes de tamaño.

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)

Luego guardamos los datos en Amazon S3 y también mantenemos una copia local en la instancia del cuaderno.

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

Esto completa nuestra fase de procesamiento de datos.

Ejecute un trabajo de modelado de temas de Amazon Comprehend

Luego pasamos a la siguiente fase, donde usamos los datos preprocesados ​​para ejecutar un trabajo de modelado de temas con Amazon Comprehend. En esta etapa, puede usar el segundo cuaderno (model_training.ipynb) o use la consola de Amazon Comprehend para ejecutar el trabajo de modelado de temas. Para obtener instrucciones sobre el uso de la consola, consulte Ejecución de trabajos de análisis mediante la consola. Si está usando el cuaderno, puede comenzar creando un cliente de Amazon Comprehend usando Boto3, como se muestra en el siguiente ejemplo.

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

Puede enviar sus documentos para el modelado de temas de dos maneras: un documento por archivo o un documento por línea.

Comenzamos con 5 temas (número k) y usamos un documento por línea. No existe una mejor manera única como práctica estándar para seleccionar k o el número de temas. Puede probar diferentes valores de k y seleccionar el que tenga la mayor probabilidad.

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

Nuestro trabajo de modelado de temas de Amazon Comprehend requiere que apruebe un InputDataConfig objeto de diccionario con S3, InputFormaty DocumentReadAction como parámetros requeridos. Del mismo modo, debe proporcionar la OutputDataConfig objeto con S3 y DataAccessRoleArn como parámetros requeridos. Para obtener más información, consulte la documentación de 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,
}

A continuación, puede iniciar un trabajo de detección de temas asíncrono pasando la cantidad de temas, el objeto de configuración de entrada, el objeto de configuración de salida y un rol de IAM, como se muestra en el siguiente ejemplo.

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

Puede realizar un seguimiento del estado actual del trabajo llamando al DescribeTopicDetectionJob operación. El estado del trabajo puede ser uno de los siguientes:

• ENVIADO: el trabajo se ha recibido y está en cola para su procesamiento.
• IN_PROGRESS: Amazon Comprehend está procesando el trabajo
• COMPLETADO: el trabajo se completó con éxito y la salida está disponible
• FAILED: el trabajo no se completó

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

Cuando el trabajo se completa con éxito, devuelve un archivo comprimido que contiene dos archivos: topic-terms.csv y doc-topics.csv. El primer archivo de salida, topic-terms.csv, es una lista de temas en la colección. Para cada tema, la lista incluye, por defecto, los principales términos por tema según su peso. El segundo archivo, doc-topics.csv, enumera los documentos asociados con un tema y la proporción del documento que se ocupa del tema. porque especificamos ONE_DOC_PER_LINE anteriormente en el input_doc_format variable, el documento se identifica por el nombre del archivo y el número de línea indexado 0 dentro del archivo. Para obtener más información sobre el modelado de temas, consulte Modelado de temas.
Los resultados de Amazon Comprehend se copian localmente para nuestros próximos pasos.

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

Debido a que la cantidad de temas es mucho menor que el vocabulario asociado con la colección de documentos, la representación del espacio de temas también puede verse como un proceso de reducción de la dimensionalidad. Puede utilizar esta representación del espacio de temas de los documentos para realizar la agrupación. Por otro lado, puede analizar la frecuencia de palabras en cada grupo para determinar el tema asociado con cada grupo. Para esta publicación, no realizamos ninguna otra técnica como la agrupación.

Usamos el tercer cuaderno (topic_mapping_sentiment_generation.ipynb) para averiguar cómo reaccionan los usuarios de diferentes grupos demográficos a los productos, y también analizar información agregada sobre la afinidad del usuario hacia un producto en particular.

Podemos combinar los resultados del cuaderno anterior para obtener temas y términos asociados para cada tema. Sin embargo, los temas están numerados y pueden carecer de explicabilidad. Por lo tanto, preferimos utilizar un humano en el circuito con suficiente conocimiento del dominio y experiencia en la materia para nombrar los temas al observar sus términos asociados. Este proceso se puede considerar como un mapeo de números de tema a nombres de tema. Sin embargo, cabe señalar que la lista individual de términos para los temas puede incluirse mutuamente y, por lo tanto, puede crear múltiples asignaciones. El humano en el circuito debe formalizar las asignaciones en función del contexto del caso de uso. De lo contrario, el rendimiento aguas abajo puede verse afectado.

Comenzamos declarando las variables. Para cada revisión, puede haber varios temas. Contamos su frecuencia y seleccionamos un máximo de tres temas más frecuentes. Estos temas se informan como los temas representativos de una revisión. Primero, definimos una variable TOP_TOPICS celebrar el máximo número de temas representativos. En segundo lugar, definimos y establecemos valores para el language_code variable para admitir el parámetro de idioma requerido de Amazon Comprehend. Finalmente, creamos topicMaps, que es un diccionario que asigna números de temas a nombres de temas.

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

A continuación, usamos el archivo topic-terms.csv generado por Amazon Comprehend para conectar los términos únicos asociados con cada tema. Luego, al aplicar el diccionario de mapeo en esta asociación tema-término, conectamos los términos únicos con los nombres de los temas.

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

Este mapeo mejora la legibilidad y explicabilidad de los temas generados por Amazon Comprehend, como podemos ver en el siguiente DataFrame.

Además, unimos el número de tema, los términos y los nombres a los datos de entrada iniciales, como se muestra en los siguientes pasos.

Esto devuelve los términos y nombres de los temas correspondientes a cada revisión. Los números de tema y los términos se unen con cada revisión y luego se vuelven a unir al DataFrame original que guardamos en el primer cuaderno.

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

Generamos sentimiento para el texto de revisión usando detect_sentiment. Inspecciona el texto y devuelve una inferencia del sentimiento predominante (POSITIVO, NEUTRO, MIXTO o 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 los temas como los sentimientos están estrechamente relacionados con las reseñas. Debido a que agregaremos temas y opiniones a nivel de producto, necesitamos crear una clave compuesta combinando los temas y las opiniones generados por 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']

Luego, agregamos a nivel de producto y contamos las claves compuestas para cada producto.

Este paso final nos ayuda a comprender mejor la granularidad de las revisiones por producto y categorizarlas por tema de manera agregada. Por ejemplo, podemos considerar los valores que se muestran para topicDF DataFrame. Para el primer producto, de todas las revisiones, en general los clientes tuvieron una experiencia positiva en cuanto a la devolución, el tamaño y la comodidad del producto. Para el segundo producto, los clientes tuvieron en su mayoría una experiencia mixta a positiva en la devolución del producto y una experiencia positiva en el tamaño del producto.

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

Nuestro DataFrame final consiste en la información de este tema y la información de sentimiento unidas al DataFrame final llamado feedbackTopics que guardamos en Amazon S3 en nuestro primer portátil.

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

Utilice Amazon QuickSight para visualizar los datos

Puede usar QuickSight para visualizar los datos y generar informes. QuickSight es un servicio de inteligencia comercial (BI) que puede usar para consumir datos de muchas fuentes diferentes y crear tableros inteligentes. En este ejemplo, generamos un análisis QuickSight usando el conjunto de datos final que producimos, como se muestra en las siguientes visualizaciones de ejemplo.

Para obtener más información sobre Amazon QuickSight, consulte Primeros pasos con Amazon Quicksight.

Limpiar

Al final, debemos cerrar la instancia del cuaderno que hemos usado en este experimento desde la consola de AWS.

Conclusión

En esta publicación, demostramos cómo usar Amazon Comprehend para analizar reseñas de productos y encontrar los temas principales utilizando el modelado de temas como técnica. El modelado de temas le permite examinar varios temas y organizarlos, comprenderlos y resumirlos a escala. Puede descubrir rápida y fácilmente patrones ocultos que están presentes en los datos y luego usar esa información para tomar decisiones basadas en datos. Puede usar el modelado de temas para resolver numerosos problemas comerciales, como etiquetar automáticamente los tickets de atención al cliente, enrutar conversaciones a los equipos correctos según el tema, detectar la urgencia de los tickets de soporte, obtener mejores perspectivas de las conversaciones, crear planes basados ​​en datos, crear problemas. -contenido enfocado, mejorando la estrategia de ventas e identificando problemas y fricciones de los clientes.

Estos son solo algunos ejemplos, pero puede pensar en muchos más problemas comerciales que enfrenta en su organización a diario, y cómo puede usar el modelado de temas con otras técnicas de ML para resolverlos.

---

Acerca de los autores

Gurpreet es un científico de datos de AWS Professional Services con sede en Canadá. Le apasiona ayudar a los clientes a innovar con tecnologías de aprendizaje automático e inteligencia artificial para aprovechar el valor comercial y los conocimientos de los datos. En su tiempo libre, le gusta caminar al aire libre y leer libros.i

Fundas Rushdi es un científico de datos de AWS Professional Services, Canadá. Crea productos de aprendizaje automático para los clientes de AWS. Le encanta leer y escribir ciencia ficción.

Wrick Talukdar es un arquitecto sénior del equipo de Amazon Comprehend Service. Trabaja con los clientes de AWS para ayudarlos a adoptar el aprendizaje automático a gran escala. Fuera del trabajo, disfruta de la lectura y la fotografía.