Análisis de Sentimiento de las Reseñas de los Consumidores del Restaurante
Fuente de datos: https://www.kaggle.com/datasets/vigneshwarsofficial/reviews
Descripción del dataset
La mayoría de los restaurantes solicitan reseñas a los clientes y, en función de las reseñas, el restaurante puede mejorar la satisfacción del cliente. Así que los comentarios juegan un papel vital para el crecimiento exitoso del restaurante.
El conjunto de datos consta de 1,000 filas y 2 columnas. La columna de Comentario consta de las reseñas de los clientes y la columna Me gusta consta de 0 y 1. Si la revisión es positiva, 1 y si es negativa, 0.
Instalación e importación de las librerías
!python -m spacy download en_core_web_sm
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
import string
import re
import wordcloud
import spacy
import nltk
nltk.download('stopwords')
from nltk.stem.porter import PorterStemmer
from nltk.stem import WordNetLemmatizer
nltk.download('wordnet')
nltk.download('omw-1.4')
from PIL import Image
import PIL.Image
from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.pipeline import Pipeline
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import xgboost as xgb
warnings.filterwarnings('ignore')
Importación del dataset
data = pd.read_csv("Restaurant_Reviews.csv")
data.head()
print(f'El dataset cuenta con {data.shape[0]} filas y {data.shape[1]} columnas.')
print("Tipo de dato por columna:")
print(data.dtypes)
Análisis de los valores nulos del dataset
data.isnull().sum()
Análisis Exploratorio de Datos (EDA)
y = [data["Liked"].value_counts()[0], data["Liked"].value_counts()[1]]
x = ["No Like", "Like"]
fig, ax = plt.subplots(figsize = (8,6), dpi = 70)
ax.bar(x,y, color = ["beige", "tomato"])
ax.bar_label(ax.containers[0], fontsize=9)
plt.xlabel("Etiqueta de Reseña")
plt.ylabel("Conteo")
plt.title("Conteo de Comentarios por Etiqueta\nNo Like o Like", size = 15)
for i in ['bottom', 'left']:
ax.spines[i].set_color('black')
ax.spines[i].set_linewidth(1.5)
right_side = ax.spines["right"]
right_side.set_visible(False)
top_side = ax.spines["top"]
top_side.set_visible(False)
ax.set_axisbelow(True)
ax.grid(color='gray', linewidth=1, axis='y', alpha=0.4)
plt.show()
data["Longitud_Comentario"] = data["Review"].apply(lambda x : len(x.split(' ')))
data.head()
print("En promedio, ¿Cuántas palabras escribieron por comentario en sus reseñas del restaurante?")
print(f'Escribieron {round(data["Longitud_Comentario"].mean(),0)} palabras, en promedio.')
print(f'En promedio, la longitud de cada reseña escrita al restaurante con respecto a la dimensión negativa fue {data[data["Liked"] == 0]["Longitud_Comentario"].median()} palabras.')
print(f'En promedio, la longitud de cada reseña escrita al restaurante con respecto a la dimensión positiva fue {data[data["Liked"] == 1]["Longitud_Comentario"].median()} palabras.')
Creación de la clase que tendrá los métodos para el análisis de sentimientos
class Sentimental_Analysis:
# Transformar las palabras a minúsculas
def clean_text(texto):
text = texto.lower()
return text.strip()
# Remover puntuaciones
def remove_punctuation(text):
punctuation = "".join([i for i in text if i not in string.punctuation])
return punctuation
# Tokenización
# La tokenización se utiliza para reducir el texto en palabras, frases u oraciones más cortas.
def tokenizacion(punctuation):
tokens = re.split("W+", punctuation)
return tokens
# Los stopwords hacen referencia a aquellas palabras que deben ser eliminadas
# porque no aportan valor al análisis de texto
def remover_stopwords(tokens):
stopwords = nltk.corpus.stopwords.words('english')
output = " ".join(i for i in tokens if i not in stopwords)
return output
# El stemming es método que básicamente reduce la palabra con sus derivaciones a la raíz principal.
def stemming(output):
porter_stemmer = PorterStemmer()
stem_texto = "".join([porter_stemmer.stem(word) for word in output])
return stem_texto
# Lematizar es transformar la palabra a su base
def lemmatizer(tokens):
wordnet_lemmatizer = WordNetLemmatizer()
lemm_texto = "".join([wordnet_lemmatizer.lemmatize(word) for word in tokens])
return lemm_texto
# Eliminar los paréntesis y números del texto
def clean_text_(lemm_texto):
text_ = re.sub('\[.*\]', '', lemm_texto).strip() # Remover texto entre paréntesis
text_ = re.sub('\S*\d\S*\s*', '', lemm_texto).strip() # Remover palabras que contiene números
return text_.strip()
# Lematizar el texto de entrada y eliminar las palabras vacías del texto.
def lemmatize(text_):
nlp = spacy.load('en_core_web_sm')
stopword = nlp.Defaults.stop_words
doc = nlp(text_)
sent = [token.lemma_ for token in doc if not token.text in set(stopword)]
return ' '.join(sent)
# Eliminar formato url del texto
def remove_url(texto):
texto = re.sub(r'(https|http)?:\/\/(\w|\.|\/|\?|\=|\&|\%)*\b', '', texto, flags = re.MULTILINE)
return texto
# Eliminar dígitos del texto
def remover_digitos(texto):
clean_text = re.sub(r'\b[0-9]+\b\s*', '', texto)
return (clean_text)
def remover_digitos_(texto):
clean_text = " ".join([w for w in texto.split() if not w.isdigit()])
return (clean_text)
# Eliminar emojis del texto
def remover_emojis(texto):
emoji_patter = re.compile(
"["
u"\U0001F600-\U0001F64F"
u"\U0001F300-\U0001F5FF"
u"\U0001F680-\U0001F6FF"
u"\U0001F1E0-\U0001F1FF"
"]+", flags = re.UNICODE)
return re.sub(emoji_patter, '', texto)
Aplicación de los métodos de la clase en la columna del dataframe
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.clean_text(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.remove_punctuation(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.tokenizacion(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.remover_stopwords(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.stemming(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.lemmatizer(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.remove_url(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.remover_digitos(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.remover_digitos_(x))
data["Review"]
data["Review"] = data["Review"].apply(lambda x : Sentimental_Analysis.remover_emojis(x))
data["Review"]
Pipeline del Aprendizaje Automático de Clasificación - Modelo Multinomial Naive Bayes
x = data["Review"]
y = data["Liked"]
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)
pipe = Pipeline(
[
('bow', CountVectorizer()),
('tfid', TfidfTransformer()),
('model', MultinomialNB())
]
)
pipe.fit(x_train, y_train)
y_pred_class = pipe.predict(x_test)
print(accuracy_score(y_test, y_pred_class))
print(confusion_matrix(y_test, y_pred_class))
print(classification_report(y_test, y_pred_class))
Predicción del Modelo Multinomial Naive Bayes
new_text = 'This restaurant is amazing, the food is delicious and the service is exceptional'
predicted_class = pipe.predict([new_text])
print(predicted_class)
print(pipe.predict_proba([new_text]))
Al tener un accuracy del 81.20% por parte del modelo Multinomial Naive Bayes entrenado en función de las reseñas histórica de los consumidores del restaurante, tenemos que al insertar una nueva reseña 'This restaurant is amazing, the food is delicious and the service is exceptional', el modelo es capaz de predecir al 88.9% que tal comentario emitido por un cliente es de carácter positivo en cuanto a la satisfacción de dicho consumidor con respecto al servicio y producto del restaurante.
Gráficos de Nubes de Palabras (Word Cloud)
def transform_white_backgroud(png_path):
picture = Image.open(png_path).convert("RGBA")
image = Image.new("RGB", picture.size, "WHITE")
image.paste(picture, (0, 0), picture)
plt.imshow(image)
mask = np.array(image)
return mask
image = Image.open("gorro_de_chef.png") #Aquí el path
plt.imshow(image)
mask = np.array(image)
mask = transform_white_backgroud("gorro_de_chef.png")
wc = WordCloud(
mask = mask,
background_color = 'white',
max_words = 200,
stopwords=STOPWORDS
).generate(' '.join([text for text in data.loc[data["Liked"]== 0, 'Review']]))
fig = plt.figure()
fig.set_figwidth(10)
fig.set_figheight(8)
plt.title("Top Palabras de Reseñas Negativas",
fontdict={'size':20, 'verticalalignment':'bottom'})
plt.imshow(wc, interpolation="bilinear", cmap = plt.cm.gray)
plt.axis('off')
plt.show()
chef_mask = np.array(Image.open('twitter_mask.png'))
wc = WordCloud(
background_color = 'white',
max_words = 200,
mask = chef_mask
)
wc.generate(' '.join(text for text in data.loc[data["Liked"]== 1, 'Review']))
plt.figure(figsize = (12, 6))
plt.title("Top Palabras de Reseñas Positivas",
fontdict={'size':20, 'verticalalignment':'bottom'})
plt.imshow(wc)
plt.axis('off')
plt.show()
Pipeline del Aprendizaje Automático de Clasificación - Modelo Extreme Gradient Boosting (XGBoost)
import xgboost as xgb
pipe = Pipeline([
('bow', CountVectorizer()),
('tfid', TfidfTransformer()),
('model', xgb.XGBClassifier(
learning_rate = 0.1,
max_depth = 20,
n_estimators = 10,
use_label_encoder = False,
eval_metric = 'auc'
))
])
pipe.fit(x_train, y_train)
y_pred_class = pipe.predict(x_test)
print(accuracy_score(y_test, y_pred_class))
print(confusion_matrix(y_test, y_pred_class))
print(classification_report(y_test, y_pred_class))
Predicción del Modelo XGBoost
new_text = 'This restaurant is amazing, the food is delicious and the service is exceptional'
predicted_class = pipe.predict([new_text])
print(predicted_class)
print(pipe.predict_proba([new_text]))
Al tener un accuracy del 72.80% por parte del modelo Extreme Gradient Boosting (XGBoost) entrenado en función de las reseñas histórica de los consumidores del restaurante, tenemos que al insertar una nueva reseña 'This restaurant is amazing, the food is delicious and the service is exceptional', el modelo es capaz de predecir al 78.1% que tal comentario emitido por un cliente es de carácter positivo en cuanto a la satisfacción de dicho consumidor con respecto al servicio y producto del restaurante.
Elección del modelo para el presente caso práctico
Luego de realizar el entrenamiento y la validación, tanto del modelo Multinomial de Naive Bayes y el Modelo Extreme Gradiente Boosting, concluyo que el modelo MultinomialNB tiene un mejor performance con respecto al modelo XGBoost porque alcanzó un accuracy del 81.2% frente al 72.8% del modelo XGBoost. En líneas generales, el primer modelo tiene un mayor nivel de predictibilidad en cuanto a la evaluación si un comentario de un consumidor de un restaurante es positivo o negativo.