Obtenez un meilleur aperçu des avis à l'aide d'Amazon Comprehend

"85% des acheteurs font autant confiance aux avis en ligne qu'à une recommandation personnelle" - Gartner

Les consommateurs interagissent de plus en plus avec les entreprises par le biais de surfaces numériques et de multiples points de contact. Les statistiques montrent que la majorité des acheteurs utilisent les avis pour déterminer quels produits acheter et quels services utiliser. Selon Centre de recherche Spiegel, la probabilité d'achat d'un produit avec cinq avis est supérieure de 270 % à la probabilité d'achat d'un produit sans avis. Les avis ont le pouvoir d'influencer les décisions des consommateurs et de renforcer la valeur de la marque.

Dans ce post, nous utilisons Amazon comprendre pour extraire des informations significatives des avis sur les produits, les analyser pour comprendre comment les utilisateurs de différentes données démographiques réagissent aux produits et découvrir des informations agrégées sur l'affinité des utilisateurs envers un produit. Amazon Comprehend est un service de traitement du langage naturel (NLP) entièrement géré et formé en continu qui peut extraire des informations sur le contenu d'un document ou d'un texte.

Vue d'ensemble de la solution

Aujourd'hui, les avis peuvent être fournis par les clients de différentes manières, telles que les notes par étoiles, le texte libre ou le langage naturel, ou les partages sur les réseaux sociaux. Les avis en texte libre ou en langage naturel aident à renforcer la confiance, car il s'agit d'une opinion indépendante des consommateurs. Il est souvent utilisé par les équipes produit pour interagir avec les clients via des canaux d'avis. C'est un fait avéré que lorsque les clients se sentent entendus, leur sentiment sur la marque s'améliore. Alors qu'il est relativement plus facile d'analyser les classements par étoiles ou les partages sur les réseaux sociaux, les critiques en langage naturel ou en texte libre posent de multiples défis, comme l'identification de mots clés ou d'expressions, de sujets ou de concepts, et de sentiments ou de sentiments au niveau de l'entité. Le défi est principalement dû à la variabilité de la longueur du texte écrit et à la présence plausible de signaux et de bruit. En outre, les informations peuvent être soit très claires et explicites (par exemple, avec des mots-clés et des phrases clés), soit peu claires et implicites (sujets et concepts abstraits). Il est encore plus difficile de comprendre les différents types de sentiments et de les relier aux produits et services appropriés. Néanmoins, il est très important de comprendre ces informations et ces signaux textuels afin de fournir une expérience client fluide.

Dans cet article, nous utilisons une version accessible au public PNL – fast.ai ensemble de données pour analyser les avis sur les produits fournis par les clients. Nous commençons par utiliser une technique d'apprentissage automatique (ML) non supervisée connue sous le nom de modélisation thématique. Il s'agit d'une technique non supervisée populaire qui découvre des sujets abstraits pouvant apparaître dans une collection de révision de texte. La modélisation des sujets est un problème de regroupement non supervisé, ce qui signifie que les modèles n'ont aucune connaissance des variables cibles possibles (telles que les sujets d'une revue). Les sujets sont représentés sous forme de clusters. Souvent, le nombre de groupes dans un corpus de documents est décidé avec l'aide d'experts du domaine ou en utilisant une analyse statistique standard. Les sorties du modèle ont généralement trois composants : des clusters numérotés (sujet 0, sujet 1, etc.), des mots-clés associés à chaque cluster et des clusters représentatifs pour chaque document (ou revue dans notre cas). De par leur nature inhérente, les modèles de sujets ne génèrent pas d'étiquettes lisibles par l'homme pour les clusters ou les sujets, ce qui est une idée fausse courante. Une chose à noter à propos de la modélisation de sujet en général est qu'il s'agit d'un modèle d'appartenance mixte : chaque document du modèle peut avoir une ressemblance avec chaque sujet. Le modèle de sujet apprend dans un processus bayésien itératif pour déterminer la probabilité que chaque document soit associé à un thème ou sujet donné. La sortie du modèle dépend de la sélection optimale du nombre de sujets. Un petit nombre de sujets peut rendre les sujets trop larges, et un plus grand nombre de sujets peut entraîner des sujets redondants ou des sujets similaires. Il existe plusieurs façons d'évaluer les modèles de sujet :

• Jugement humain - Basé sur l'observation, basé sur l'interprétation
• Métriques quantitatives – Perplexité, calculs de cohérence
• Approche mixte - Une combinaison d'approches fondées sur le jugement et quantitatives

La perplexité est calculée en divisant un ensemble de données en deux parties : un ensemble d'apprentissage et un ensemble de test. La probabilité est généralement calculée sous forme de logarithme, de sorte que cette métrique est parfois appelée log-vraisemblance retenue. La perplexité est une mesure prédictive. Il évalue la capacité d'un modèle de sujet à prédire un ensemble de test après avoir été entraîné sur un ensemble d'apprentissage. L'un des défauts de la perplexité est qu'elle ne capture pas le contexte, ce qui signifie qu'elle ne capture pas la relation entre les mots d'un sujet ou les sujets d'un document. Cependant, l'idée de contexte sémantique est importante pour la compréhension humaine. Des mesures telles que la probabilité conditionnelle de la cooccurrence de mots dans un sujet peuvent être utiles. Ces approches sont collectivement appelées cohérence. Pour cet article, nous nous concentrons sur l'approche du jugement humain (basée sur l'observation), à savoir l'observation des n premiers mots d'un sujet.

La solution consiste en les étapes de haut niveau suivantes :

1. Mettre en place un Amazon Sage Maker instance de bloc-notes.
2. Créez un cahier.
3. Effectuer une analyse exploratoire des données.
4. Exécutez votre tâche de modélisation de sujet Amazon Comprehend.
5. Générez des sujets et comprenez le sentiment.
6. Utilisez Amazon QuickSight pour visualiser les données et générer des rapports.

Vous pouvez utiliser cette solution dans n'importe quelle région AWS, mais vous devez vous assurer que les API Amazon Comprehend et SageMaker se trouvent dans la même région. Pour cet article, nous utilisons la région USA Est (Virginie du Nord).

Configurer votre instance de bloc-notes SageMaker

Vous pouvez interagir avec Amazon Comprehend via le Console de gestion AWS, Interface de ligne de commande AWS (AWS CLI), ou l'API Amazon Comprehend. Pour plus d'informations, reportez-vous à Premiers pas avec Amazon Comprehend. Nous utilisons un bloc-notes SageMaker et du code Python (Boto3) tout au long de cet article pour interagir avec les API Amazon Comprehend.

1. Sur la console Amazon SageMaker, sous Bloc-notes dans le volet de navigation, choisissez
   Instances de bloc-notes.
2. Choisissez Créer une instance de bloc-notes.
3. Spécifiez un nom d'instance de bloc-notes et définissez le type d'instance sur ml.r5.2xlarge.
4. Laissez le reste des paramètres par défaut.
5. Créer un Gestion des identités et des accès AWS (IAM) rôle avec AmazonSageMakerFullAccess et l'accès à tout ce qui est nécessaire Service de stockage simple Amazon (Amazon S3) compartiments et API Amazon Comprehend.
6. Choisissez Créer une instance de bloc-notes.
   Après quelques minutes, votre instance de bloc-notes est prête.
7. Pour accéder à Amazon Comprehend à partir de l'instance de bloc-notes, vous devez joindre le ComprehendFullAccess stratégie à votre rôle IAM.

Pour une présentation de la sécurité d'Amazon Comprehend, consultez Sécurité dans Amazon Comprehend.

Après avoir ouvert l'instance de bloc-notes que vous avez provisionnée, sur la console Jupyter, choisissez Nouveau, puis Python 3 (Data Science). Vous pouvez également accéder au fichier d'exemple de code dans le GitHub repo. Vous pouvez télécharger le fichier sur l'instance de bloc-notes pour l'exécuter directement ou le cloner.

Le référentiel GitHub contient trois notebooks :

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

Effectuer une analyse exploratoire des données

Nous utilisons le premier cahier (data_processing.ipynb) pour explorer et traiter les données. Nous commençons par charger simplement les données d'un compartiment S3 dans 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)

Dans la section suivante, nous effectuons une analyse exploratoire des données (EDA) pour comprendre les données. Nous commençons par explorer la forme des données et des métadonnées. Pour l'authenticité, nous utilisons uniquement des avis vérifiés.

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

Nous explorons plus en détail le nombre de chaque catégorie et voyons si des données en double sont présentes.

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

Lorsque nous sommes satisfaits des résultats, nous passons à l'étape suivante de prétraitement des données. Amazon Comprehend recommande de fournir au moins 1,000 8 documents dans chaque tâche de modélisation de rubrique, chaque document contenant au moins trois phrases. Les documents doivent être dans des fichiers texte au format UTF-8. Dans l'étape suivante, nous nous assurons que les données sont au format UTF-5,000 recommandé et que chaque entrée ne dépasse pas XNUMX XNUMX octets.

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)

Nous enregistrons ensuite les données sur Amazon S3 et gardons également une copie locale dans l'instance de bloc-notes.

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

Ceci termine notre phase de traitement des données.

Exécuter une tâche de modélisation de sujet Amazon Comprehend

Nous passons ensuite à la phase suivante, où nous utilisons les données prétraitées pour exécuter une tâche de modélisation de sujet à l'aide d'Amazon Comprehend. A ce stade, vous pouvez soit utiliser le deuxième cahier (model_training.ipynb) ou utilisez la console Amazon Comprehend pour exécuter la tâche de modélisation de rubrique. Pour obtenir des instructions sur l'utilisation de la console, reportez-vous à Exécution de tâches d'analyse à l'aide de la console. Si vous utilisez le bloc-notes, vous pouvez commencer par créer un client Amazon Comprehend à l'aide de Boto3, comme illustré dans l'exemple suivant.

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

Vous pouvez soumettre vos documents pour la modélisation de sujet de deux manières : un document par fichier ou un document par ligne.

Nous commençons avec 5 sujets (nombre k) et utilisons un document par ligne. Il n'y a pas de meilleure façon de sélectionner k ou le nombre de sujets. Vous pouvez essayer différentes valeurs de k et sélectionner celle qui a la plus grande probabilité.

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

Notre travail de modélisation de sujet Amazon Comprehend nécessite que vous réussissiez un InputDataConfig objet dictionnaire avec S3, InputFormatet une DocumentReadAction comme paramètres requis. De même, vous devez fournir le OutputDataConfig objet avec S3 et DataAccessRoleArn comme paramètres requis. Pour plus d'informations, reportez-vous à la documentation Boto3 pour 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,
}

Vous pouvez ensuite démarrer une tâche de détection de rubrique asynchrone en transmettant le nombre de rubriques, l'objet de configuration d'entrée, l'objet de configuration de sortie et un rôle IAM, comme illustré dans l'exemple suivant.

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

Vous pouvez suivre l'état actuel du travail en appelant le DescribeTopicDetectionJob opération. L'état de la tâche peut être l'un des suivants :

• SOUMIS – Le travail a été reçu et est mis en file d'attente pour traitement
• IN_PROGRESS – Amazon Comprehend traite la tâche
• TERMINÉ – Le travail s'est terminé avec succès et la sortie est disponible
• FAILED - Le travail ne s'est pas terminé

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

Lorsque le travail est terminé avec succès, il renvoie une archive compressée contenant deux fichiers : topic-terms.csv et doc-topics.csv. Le premier fichier de sortie, topic-terms.csv, est une liste de rubriques de la collection. Pour chaque thème, la liste comprend, par défaut, les principaux termes par thème en fonction de leur poids. Le deuxième dossier, doc-topics.csv, répertorie les documents associés à un thème et la proportion du document concerné par le thème. Parce que nous avons précisé ONE_DOC_PER_LINE plus tôt dans la input_doc_format variable, le document est identifié par le nom du fichier et le numéro de ligne indexé 0 dans le fichier. Pour plus d'informations sur la modélisation des rubriques, reportez-vous à Modélisation de sujets.
Les sorties d'Amazon Comprehend sont copiées localement pour nos prochaines étapes.

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

Étant donné que le nombre de sujets est bien inférieur au vocabulaire associé à la collection de documents, la représentation de l'espace des sujets peut également être considérée comme un processus de réduction de la dimensionnalité. Vous pouvez utiliser cette représentation de l'espace de rubrique des documents pour effectuer un clustering. D'autre part, vous pouvez analyser la fréquence des mots dans chaque groupe pour déterminer le sujet associé à chaque groupe. Pour cet article, nous n'utilisons aucune autre technique comme le clustering.

Nous utilisons le troisième cahier (topic_mapping_sentiment_generation.ipynb) pour déterminer comment les utilisateurs de différents groupes démographiques réagissent aux produits, et également analyser les informations agrégées sur l'affinité des utilisateurs envers un produit particulier.

Nous pouvons combiner les sorties du bloc-notes précédent pour obtenir des sujets et des termes associés pour chaque sujet. Cependant, les sujets sont numérotés et peuvent manquer d'explicabilité. Par conséquent, nous préférons utiliser un humain dans la boucle avec suffisamment de connaissances du domaine et d'expertise en la matière pour nommer les sujets en regardant leurs termes associés. Ce processus peut être considéré comme un mappage des numéros de sujet aux noms de sujets. Cependant, il convient de noter que la liste individuelle de termes pour les sujets peut être mutuellement inclusive et peut donc créer plusieurs mappages. L'humain dans la boucle doit formaliser les mappages en fonction du contexte du cas d'utilisation. Sinon, les performances en aval peuvent être affectées.

On commence par déclarer les variables. Pour chaque avis, il peut y avoir plusieurs sujets. Nous comptons leur fréquence et sélectionnons au maximum trois sujets les plus fréquents. Ces sujets sont signalés comme les sujets représentatifs d'une revue. On définit d'abord une variable TOP_TOPICS détenir le maximum de sujets représentatifs. Deuxièmement, nous définissons et fixons des valeurs aux language_code variable pour prendre en charge le paramètre de langue requis d'Amazon Comprehend. Enfin, nous créons topicMaps, qui est un dictionnaire qui associe les numéros de rubrique aux noms de rubrique.

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

Ensuite, nous utilisons le fichier topic-terms.csv généré par Amazon Comprehend pour connecter les termes uniques associés à chaque sujet. Ensuite, en appliquant le dictionnaire de mappage sur cette association sujet-terme, nous connectons les termes uniques aux noms de sujets.

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

Ce mappage améliore la lisibilité et l'explicabilité des sujets générés par Amazon Comprehend, comme nous pouvons le voir dans le DataFrame suivant.

De plus, nous joignons le numéro de sujet, les termes et les noms aux données d'entrée initiales, comme indiqué dans les étapes suivantes.

Cela renvoie les termes et noms de sujet correspondant à chaque avis. Les numéros de sujet et les termes sont joints à chaque révision, puis joints au DataFrame d'origine que nous avons enregistré dans le premier bloc-notes.

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

Nous générons un sentiment pour le texte de l'avis en utilisant detect_sentiment. Il inspecte le texte et renvoie une inférence du sentiment dominant (POSITIF, NEUTRE, MIXTE ou NÉGATIF).

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)

Les sujets et les sentiments sont étroitement liés aux critiques. Étant donné que nous allons agréger les sujets et les sentiments au niveau du produit, nous devons créer une clé composite en combinant les sujets et les sentiments générés par 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']

Ensuite, nous agrégeons au niveau du produit et comptons les clés composées pour chaque produit.

Cette dernière étape nous aide à mieux comprendre la granularité des avis par produit et à les catégoriser par sujet de manière agrégée. Par exemple, nous pouvons considérer les valeurs affichées pour topicDF DataFrame. Pour le premier produit, de toutes les critiques, dans l'ensemble, les clients ont eu une expérience positive sur le retour du produit, la taille et le confort. Pour le deuxième produit, les clients avaient pour la plupart une expérience mitigée à positive sur le retour du produit et une expérience positive sur la taille du produit.

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

Notre DataFrame final se compose de ces informations de sujet et d'informations de sentiment jointes au DataFrame final nommé feedbackTopics que nous avons enregistré sur Amazon S3 dans notre premier bloc-notes.

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

Utiliser Amazon QuickSight pour visualiser les données

Vous pouvez utiliser QuickSight pour visualiser les données et générer des rapports. QuickSight est un service de Business Intelligence (BI) que vous pouvez utiliser pour consommer des données provenant de nombreuses sources différentes et créer des tableaux de bord intelligents. Dans cet exemple, nous générons une analyse QuickSight à l'aide de l'ensemble de données final que nous avons produit, comme illustré dans les exemples de visualisations suivants.

Pour en savoir plus sur Amazon QuickSight, consultez Premiers pas avec Amazon Quicksight.

Nettoyer

À la fin, nous devons arrêter l'instance de bloc-notes que nous avons utilisée dans cette expérience à partir de la console AWS.

Conclusion

Dans cet article, nous avons montré comment utiliser Amazon Comprehend pour analyser les avis sur les produits et trouver les principaux sujets en utilisant la modélisation des sujets comme technique. La modélisation de sujets vous permet de parcourir plusieurs sujets et de les organiser, de les comprendre et de les résumer à grande échelle. Vous pouvez rapidement et facilement découvrir des modèles cachés présents dans les données, puis utiliser ces informations pour prendre des décisions basées sur les données. Vous pouvez utiliser la modélisation de sujets pour résoudre de nombreux problèmes commerciaux, tels que le marquage automatique des tickets d'assistance client, l'acheminement des conversations vers les bonnes équipes en fonction du sujet, la détection de l'urgence des tickets d'assistance, l'obtention de meilleures informations à partir des conversations, la création de plans basés sur les données, la création de problèmes. -contenu ciblé, amélioration de la stratégie de vente et identification des problèmes et des frictions des clients.

Ce ne sont là que quelques exemples, mais vous pouvez penser à de nombreux autres problèmes commerciaux auxquels vous êtes confrontés quotidiennement dans votre organisation et à la manière dont vous pouvez utiliser la modélisation de sujets avec d'autres techniques de ML pour les résoudre.

---

À propos des auteurs

Gurpreet est un Data Scientist avec AWS Professional Services basé au Canada. Elle est passionnée d'aider les clients à innover avec les technologies d'apprentissage automatique et d'intelligence artificielle pour exploiter la valeur commerciale et les informations à partir des données. Dans ses temps libres, elle aime faire de la randonnée en plein air et lire des livres.i

Rushdi Shams est un scientifique des données chez AWS Professional Services, Canada. Il crée des produits d'apprentissage automatique pour les clients AWS. Il aime lire et écrire des romans de science-fiction.

Wrick Talukdar est architecte senior au sein de l'équipe Amazon Comprehend Service. Il travaille avec les clients d'AWS pour les aider à adopter l'apprentissage automatique à grande échelle. En dehors du travail, il aime lire et photographier.