Python Sentiment Analysis with BERT

Table of Contents

1. Introduction
2. Sentiment Analysis: What is it?
3. The Vert Model
4. Installation and Setup
5. Performing Sentiment Analysis
6. Scraping Yelp Reviews
7. Collecting and Storing Reviews in a DataFrame
8. Applying Sentiment Analysis to Yelp Reviews
9. Results and Analysis
10. Conclusion

Introduction

Have You ever wondered how people feel about you? Do you want to get a better Read on how they're feeling? In this article, we will explore sentiment analysis, a powerful technique that allows us to understand and analyze the emotions and opinions expressed in text data. We will be using a state-of-the-art model called Vert to perform sentiment analysis, and we will demonstrate how to use this model using the Transformers Package. Additionally, we will showcase how to scrape data from Yelp and run sentiment analysis on Yelp reviews. So, whether you want to analyze sentiment for your business or just gain a deeper understanding of how people perceive you, this article will provide you with the tools and knowledge to do so. Let's dive in!

Sentiment Analysis: What is it?

Sentiment analysis, also known as opinion mining, is the process of determining the sentiment or emotional tone behind a piece of text. It involves analyzing the words, phrases, and Context of the text to classify it as positive, negative, or neutral. Sentiment analysis is widely used in various domains, including market research, social media analysis, customer feedback analysis, and brand management. By understanding the sentiment expressed in text data, businesses and organizations can gain valuable insights into customer opinions, make data-driven decisions, and enhance their products or services.

The Vert Model

The Vert model is a state-of-the-art language model designed for natural language processing (NLP) tasks, including sentiment analysis. It is part of the Transformers library, a powerful and efficient tool for working with NLP tasks in Python. The Vert model is capable of analyzing sentiment in multiple languages, including English, Dutch, German, French, Spanish, and Italian. It provides sentiment scores between one and five, mimicking the rating Scale used in star ratings. This makes it easy to quantify and compare the sentiment expressed in different Texts.

Installation and Setup

To use the Vert model for sentiment analysis, we first need to install and import the necessary dependencies. The key dependencies for this project include the Transformers library, PyTorch, requests, Beautiful Soup, Pandas, and NumPy. The Transformers library is essential for working with NLP tasks, and PyTorch is a deep learning framework that powers the Vert model. Requests is used for making HTTP requests to scrape data from websites, Beautiful Soup helps to parse HTML and extract Relevant data, and Pandas and NumPy are used for data manipulation and analysis.

To install the necessary dependencies, run the following commands:

!pip install transformers requests beautifulsoup4 pandas numpy

Once the dependencies are installed, we can import them into our Python script using the following lines of code:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import requests
from bs4 import BeautifulSoup
import re
import pandas as pd
import numpy as np

Performing Sentiment Analysis

Now that we have installed and imported our dependencies, we can proceed with performing sentiment analysis using the Vert model. The first step is to initialize and download the pre-trained NLP model. We can achieve this by instantiating the tokenizer and the model classes from the Transformers library. The tokenizer allows us to convert a STRING into a sequence of numbers that the model can understand, while the model class represents the architecture of the NLP model. In this case, we will be using the auto tokenizer and the auto model for sequence classification, which are suitable for sentiment analysis tasks.

To initialize and download the model, use the following code:

tokenizer = AutoTokenizer.from_pretrained("nlp-town/bert-base-multilingual-uncased-sentiment")
model = AutoModelForSequenceClassification.from_pretrained("nlp-town/bert-base-multilingual-uncased-sentiment")

With the model initialized, we can now pass a string or prompt to the tokenizer, encode it into a sequence of numbers, and then pass it to the model to obtain the sentiment score. The sentiment score represents the probability of a particular sentiment class being expressed in the text. To calculate the sentiment score, use the following code:

prompt = "I loved the food at this restaurant, it was delicious!"
tokens = tokenizer.encode(prompt, return_tensors="pt")
result = model(tokens)
sentiment_score = torch.argmax(result.logits).item() + 1

In this example, the sentiment score will be between one and five, with higher values indicating more positive sentiment. You can experiment with different Prompts to see how the model classifies them.

Scraping Yelp Reviews

To demonstrate sentiment analysis on real-world data, we will scrape reviews from Yelp. We will use the Beautiful Soup library to parse HTML and extract the desired data. First, we need to make an HTTP request to the Yelp Website to obtain the HTML content of the page containing the reviews. We can use the Requests library to accomplish this task. Once we have the HTML content, we can use Beautiful Soup to extract the reviews from the page.

To scrape Yelp reviews, use the following code:

url = "https://www.yelp.com/beers/mexico-sydney-2"
response = requests.get(url)
html_content = response.text
soup = BeautifulSoup(html_content, "html.parser")
reviews = soup.find_all(class_=re.compile("comment"))

In this example, We Are scraping beer reviews from the Mexico restaurant in Sydney. The URL can be replaced with any other Yelp page to scrape reviews from different businesses. The find_all function is used to find all HTML elements with a class that matches our regex pattern, which in this case is "comment". The resulting reviews are stored in a list.

Collecting and Storing Reviews in a DataFrame

To organize and work with the scraped reviews, we can load them into a Pandas DataFrame. This will allow us to manipulate and analyze the data more easily. To Create a DataFrame, we can use the pd.DataFrame function and pass the reviews as a NumPy array. We can also specify the column name as "review" for Clarity.

To load the reviews into a DataFrame, use the following code:

df = pd.DataFrame(np.array(reviews), columns=["review"])

Now the reviews are stored in a DataFrame, where each row represents an individual review. This will facilitate subsequent processing and analysis.

Applying Sentiment Analysis to Yelp Reviews

With the reviews collected and stored in a DataFrame, we can now Apply sentiment analysis to each review. We will loop through the reviews, pass them individually to our sentiment analysis pipeline, and store the sentiment scores in a new column in the DataFrame.

To apply sentiment analysis to Yelp reviews, use the following code:

df["sentiment_score"] = df["review"].apply(lambda x: sentiment_score(x[:512]))

In this example, we are using a lambda function to pass each individual review to the sentiment_score function. The sentiment_score function calculates the sentiment score for a given review. We have added a slice (x[:512]) to limit the input to the first 512 tokens, as the model has a token limit. This is a quick workaround, and you may want to experiment with different approaches to handle longer reviews.

Results and Analysis

After applying sentiment analysis to the Yelp reviews, we can analyze the results and gain insights into customer opinions. The sentiment scores will provide a quantitative measure of the sentiment expressed in each review, allowing us to compare different reviews and identify Patterns. You can Visualize and analyze the sentiment scores using various statistical techniques, such as calculating the average sentiment score, plotting histograms, or conducting sentiment trend analysis over time.

By analyzing the sentiment of Yelp reviews, businesses can gain valuable insights into customer perceptions and sentiments. This information can be used to improve products, enhance customer experiences, identify areas for improvement, and make data-driven decisions.

Conclusion

In this article, we explored sentiment analysis and demonstrated how to perform sentiment analysis on Yelp reviews using the Vert model and the Transformers library. We learned how to install and set up the necessary dependencies, scrape data from Yelp, load reviews into a DataFrame, and apply sentiment analysis to these reviews. Sentiment analysis can provide valuable insights into customer opinions and can be used to make data-driven decisions and enhance business operations. By understanding and analyzing customer sentiments, businesses can create better products, improve customer experiences, and ultimately drive success.