Name: HOUDA AOUSSAR

Registration Number: 239122526

Programme: Computer science
Supervisor: Neil Eliot
Introduction

1.1 Overview of the Project

Customer reviews are extremely valuable for businesses because they provide direct feedback on a
product or service. Reviews offer insights into what customers like, what they dislike, and what could
be improved. This feedback is essential for businesses to understand their customers' needs and
improve their offerings. However, with so many reviews available across various platforms, it’s nearly
impossible for businesses to manually read and analyse all of them. This is where my project comes
in.

For this project, I will use Natural Language Processing (NLP), a branch of Artificial Intelligence (AI),
to automatically analyse customer reviews. The goal is to perform sentiment analysis to classify
reviews as positive, negative, or neutral, and use topic modelling to identify specific themes in the
feedback, such as "delivery time," "product quality," or "customer support." Once I’ve analysed the
reviews, I’ll present the results in an easy-to-understand way using visualizations like graphs, charts,
and heat maps. This will allow businesses to quickly spot patterns and trends in customer feedback,
helping them make data-driven decisions.

1.2 Aims and Objectives

The aim of this project is to develop a system that helps businesses understand their customers’
opinions by analysing customer reviews using data science techniques. Specifically, the project will
focus on sentiment analysis and topic modelling to extract meaningful insights from reviews.

The SMART objectives for this project are:

1. Specific: Build a system that uses NLP to classify customer reviews as positive, negative, or
neutral, and extract key topics.

2. Measurable: Achieve at least 80% accuracy in classifying reviews as positive, negative, or

neutral.

3. Time-bound: Complete the project, including research, model development, testing, and
reporting, within the given project timeline
2.1 Outline of the Problem

The problem I’m looking into is how businesses handle and analyse customer reviews. Customer
reviews are really important because they show what people think about a product, but reading
through hundreds or even thousands of them can be really time-consuming. Right now, a lot of
businesses use basic methods or do it manually, which isn’t very efficient. The reviews are often
messy, full of different opinions, and hard to categorize. My project is all about using Natural
Language Processing (NLP) to automatically analyse these reviews, figure out if the sentiment is
positive, negative, or neutral, and even pull out common themes like product quality, delivery time,
or customer support. This will help businesses save time and get more accurate insights from their
customers.

2.2 Supervisor Details

This idea for my project came from Dr. Neil Eliot, who is the module leader for Cybersecurity at
Sunderland University. While he specializes in cybersecurity, he helped me design the project idea
and figure out how to apply machine learning and NLP to solve this problem. He suggested that using
these techniques would make the process of analyzing reviews much faster and more accurate
compared to the current methods businesses use. Dr. Eliot sees this as an important problem because
businesses need a better way to process all the customer feedback they receive, and applying AI is a
great solution for it.
3. Research Context

In this section, I will discuss the key concepts and techniques that are foundational to my project. The
goal of my project is to analyze customer reviews using Natural Language Processing (NLP) techniques
and present the results through effective data visualization. This process involves multiple steps,
including collecting review data using APIs, applying NLP techniques to process and analyze the text,
and designing clear visualizations to present the insights.

3.1 Working with APIs in Python

The first stage of my project involves gathering customer reviews from various online platforms. APIs
(Application Programming Interfaces) play a critical role in this process, as they enable programs to
interact with external systems to retrieve data. Platforms like Amazon or Yelp often provide APIs to
access product reviews, which I aim to use for collecting the data needed for analysis.

To work with APIs in Python, I have started researching popular libraries such as Requests and
BeautifulSoup. The Requests library simplifies the process of sending HTTP requests to access APIs,
while BeautifulSoup is commonly used to parse HTML content when working with web scraping
tasks. These tools are fundamental for extracting the data I need.

For example, using the Requests library, I can send a GET request to an API endpoint, passing
parameters like search terms or product IDs to retrieve specific reviews. Once the data is retrieved,
it’s often in JSON format, which is easy to process and clean in Python. If I encounter HTML content
instead of structured JSON data, BeautifulSoup will help extract and organize the necessary
information.

One challenge in working with APIs is handling authentication and rate limiting. Many APIs require an
API key for authentication, and some platforms restrict how many requests can be made in a given
timeframe. To address these issues, I am exploring techniques such as using API keys securely and
implementing delays or retry mechanisms in my code to avoid exceeding rate limits. By
understanding these challenges and preparing for them, I can ensure a smoother data collection
process.

3.2 Introduction to Natural Language Processing (NLP)

I’ve recently started diving into Natural Language Processing (NLP), which is one of the key elements
in my project. NLP is basically a branch of artificial intelligence that’s all about how computers can
understand and interact with human language. Right now, I’m in the early stages of learning—
watching videos, taking beginner courses, and just trying to get a handle on the basics.

In my project, I want to use NLP to analyze customer reviews, specifically focusing on two main areas:
sentiment analysis and topic modeling. These are both powerful techniques for breaking down text
data and making sense of it.

For sentiment analysis, the goal is to figure out whether a review is positive, negative, or neutral. This
can give businesses valuable insight into how customers feel about their products or services. For
example, if most reviews are complaining about product quality, that’s a clear sign the company
needs to make improvements. I’ve been exploring tools like Hugging Face Transformers, which offer
pre-trained models like BERT and RoBERTa. These models have already been trained on massive
amounts of text data, so they’re a great starting point. At some point, though, I might need to fine-
tune one of these models on a smaller dataset of reviews specific to my project, just to make sure it’s
as accurate as possible for this use case.

The other part of my project is topic modeling. This is about finding common themes in customer
reviews—basically, grouping together words or phrases that tend to appear together. Techniques like
Latent Dirichlet Allocation (LDA) are useful here because they can uncover patterns that might not be
immediately obvious. For instance, reviews might frequently mention things like "delivery time,"
"price," or "user experience." By identifying these themes, businesses can see exactly where they’re
doing well and where they need to step up.

One thing I’ve realized, though, is that working with text data isn’t as straightforward as it sounds.
Customer reviews can be messy—there’s slang, abbreviations, mixed opinions, and sometimes even
emojis! To handle this, I’ve been looking into preprocessing techniques like tokenization (breaking
text into words or phrases), removing unnecessary words like “the” or “and,” and lemmatization
(basically simplifying words to their base forms). These steps are crucial for cleaning up the data
before I can actually start analyzing it.

It’s still early days for me with NLP, and I know there’s a lot to learn, but I’m excited about the
possibilities. As I continue studying and experimenting, I’m hoping to build a solid understanding of
how to apply these tools effectively in my project.

3.3 Data Visualization Techniques

For the final step of my project, I’ll be focusing on presenting the results of my analysis in a way that’s
clear and easy to understand for businesses. Since I’m doing everything in Jupyter Notebook, I plan to
use it for the visualization part as well. My goal isn’t to create overly complicated visuals but rather to
use simple graphs and plots that make it easier to draw meaningful insights from the data.

I’ve been exploring Python libraries like Matplotlib, Seaborn, and Plotly for this purpose. Matplotlib is
great for creating basic charts like bar graphs, line plots, and scatter plots. For instance, I could use it
to show the breakdown of positive, negative, and neutral reviews for a product in a straightforward
bar chart.

Seaborn, on the other hand, is perfect for making my plots look more polished and for creating
slightly more advanced visuals like heatmaps or box plots. For example, I could use a heatmap to
highlight which topics or keywords are most frequently mentioned across different product
categories.

I’m also considering using Plotly for a few interactive visualizations, like sentiment trends over time,
so businesses can explore the data a bit more. However, most of my visualizations will probably be
simple and static, focusing on clarity and ease of interpretation.

By sticking to Jupyter Notebook and combining these tools, I aim to create visuals that are practical
and help businesses quickly understand their customer feedback. The idea is to keep things clean and
focused so the insights are as actionable as possible.

3.4 Challenges and Future Work

While I have made significant progress in understanding the techniques needed for this project, there
are still challenges to address. One challenge is ensuring the accuracy of sentiment analysis and topic
modeling. The quality of these results depends heavily on the quality of the training data and the
preprocessing steps. I plan to spend more time learning about fine-tuning models and selecting the
best preprocessing techniques to handle the unique characteristics of customer reviews.

Another challenge is dealing with large volumes of data. Customer reviews can be extensive, and
processing them efficiently requires optimizing both the code and the computational resources. I am
exploring methods to batch process the data and use cloud services if needed to handle scalability.

In the coming weeks, I plan to:

• Start collecting review data using APIs.

• Experiment with sentiment analysis models and topic modeling techniques.

• Develop the first version of the visualization dashboard.

• Refine the NLP pipeline to handle specific challenges, such as mixed sentiments or noisy text.

4.1 Solution Exploration

For my final-year project, I’m focusing on creating a sentiment analysis system to evaluate customer
reviews using existing, well-established NLP models like BERT or RoBERTa. These models are powerful
because they have already been trained on massive datasets, which helps them understand the
nuances of language well. Instead of building a model from scratch, which would be too time-
consuming and complex for this project, I’ll use a pre-trained model and fine-tune it for analyzing
customer reviews. This approach will save time and resources while still allowing me to achieve highly
accurate results. Given that sentiment analysis can be complex, using BERT or RoBERTa seems like the
best option, as it gives me a solid starting point and allows me to focus on fine-tuning for the specific
task.

4.2 Solution Tasks and Milestones

I plan to break the project into smaller tasks that are easy to manage. The first step will be collecting
and preparing the data, which involves cleaning the text and preparing it for analysis (like removing
stopwords and normalizing the text). After that, I’ll fine-tune the pre-trained model (BERT or
RoBERTa) on the dataset, so it can classify the reviews into categories such as positive, negative, or
neutral. Once the model is ready, I’ll focus on visualizing the results using Python libraries like
Matplotlib and Seaborn in Jupyter Notebook. The final phase will be evaluating the model’s
performance and writing up the results in a detailed report. I’ve already created a timeline for this
project, and I’ll follow it to make sure I stay on track with each task.

4.3 Functional Requirements

The main functional requirements for this project are:

• Classifying customer reviews into sentiment categories (positive, negative, neutral).

• Fine-tuning a pre-trained model like BERT or RoBERTa to make it specific to this task.

• Creating clear and understandable visualizations of the sentiment analysis results.

• Ensuring that the system can handle different types of customer review data without issues.

4.4 Non-Functional Requirements

The non-functional requirements focus on things like quality and performance:

• The model should perform well, processing reviews quickly and accurately.

• The solution should be scalable, meaning it can handle larger datasets if needed in the
future.

• The results and visualizations should be easy for business users to understand, even if they
don’t have technical knowledge.

• Accuracy is crucial, so the sentiment analysis needs to be as reliable as possible.

4.5 Resources

For resources, I’ll need:

• A labeled dataset of customer reviews, which will help train the sentiment analysis model.

• Pre-trained models like BERT or RoBERTa that I can fine-tune.

• Python libraries, including Hugging Face Transformers for the model, Matplotlib and Seaborn
for visualization, and scikit-learn for evaluation.

• Documentation tools to write up the final project report.

4.6 Hardware & Software Requirements

To run the project efficiently, I’ll need a computer with a decent GPU, as training these large models
requires quite a bit of computational power. For software, I’ll use:

• Python, as it’s the language I’ll be coding in.

• Jupyter Notebook to experiment and visualize data.

• Libraries like Hugging Face Transformers for working with the model, Matplotlib and Seaborn
for creating visualizations, and scikit-learn for model evaluation.

4.7 Constraints

The main constraint is time, as I have a fixed deadline for my final-year project. This means I’ll need to
balance learning and implementing NLP techniques while staying on track with my timeline.
Additionally, even though I’m using pre-trained models, they may need some fine-tuning to perform
well on customer reviews, which can be challenging. The availability of a high-quality labeled dataset
is another potential constraint that could impact the model’s performance. Finally, since NLP is a
complex field and I’m still learning about it, there will be a learning curve to work through, but I’m
confident I can manage it within the project’s time frame.
5. Procedure

Social, Ethical, Professional, and Legal (SEPL) Considerations

Social

The project focuses on analyzing customer sentiment through reviews, which can influence decision-
making for both businesses and users. It’s important to ensure that the system does not promote bias
or misinformation. The results must be clear and fair, avoiding harm to any individual or group.

Ethical

There are ethical concerns related to handling sensitive data from user reviews. To address this:

• User privacy will be prioritized, and all data will be anonymized.

• The system will be designed to prevent bias or manipulation of results.

• The training data for the sentiment model will be diverse to ensure fairness and minimize
bias.

Professional

Professionalism will guide all interactions and processes in the project. This includes:

• Preparing thoroughly for meetings or presentations with stakeholders or supervisors.

• Communicating clearly and professionally about the project’s goals, challenges, and progress.

• Ensuring any participant involved in testing or feedback fully understands the purpose and
provides consent.

Legal

To stay compliant with relevant laws:

• All data handling will align with data protection regulations like GDPR.

• Third-party APIs used for reviews will be accessed according to their terms and conditions.

• Permissions will be obtained for any datasets, tools, or resources utilized in the project.

Development Methodology

The project will follow an Agile methodology to allow for flexibility and iterative progress. This
approach makes it easier to adapt to challenges and incorporate feedback.

1. Planning: Define clear goals and create a detailed project plan with key milestones.

2. Design: Outline the system’s structure, focusing on features like data security and usability.

3. Implementation: Break the project into smaller tasks, each completed within a sprint, to
ensure steady progress.

4. Testing: Regularly test the system for accuracy, reliability, and compliance with SEPL
requirements.
 5. Deployment and Feedback: Launch the system, gather user feedback, and refine the solution
based on their input.

5.2 Methodology

For this project, I will follow the Agile methodology because it’s flexible and works well for projects
where requirements may change or evolve. Agile focuses on breaking down the work into smaller,
manageable tasks and delivering them in iterations, called sprints. This makes it easier to stay
organized and adjust the project based on feedback or new insights.

One of the key reasons I chose Agile is that it’s user-focused. By working in short sprints, I can
consistently evaluate progress and ensure the system meets user needs. For example, after
integrating the reviews API or testing the sentiment analysis model, I can get feedback and make
improvements before moving on to the next stage. This way, the project develops in a controlled,
step-by-step manner without overwhelming me or missing critical details.

The process will involve several key stages. First, I’ll create a plan that outlines all the tasks and breaks
them into sprints, prioritizing the most important features. Then, during each sprint, I’ll focus on
specific components, like setting up API access or improving the accuracy of the sentiment analysis.
Once a sprint is done, I’ll test the progress, get feedback from my supervisor, and make adjustments
as needed. This loop of development and feedback will continue until the project is completed.

Agile also helps minimize risks because it encourages testing and evaluation at every step. If
something isn’t working, I can address it right away rather than finding out too late. It also keeps the
workload manageable by focusing on one part of the project at a time. Overall, Agile is a practical
choice that ensures the project stays on track while remaining adaptable to changes or new ideas.

This approach is supported by software engineering practices, which emphasize how iterative
methods like Agile improve project outcomes by keeping communication open and addressing
problems early. It’s a methodology that fits the dynamic nature of this project and ensures a higher
chance of success.

6. Progress Report

Activities Completed So Far

Finalized Project Proposal (17.10.2024)

I have completed and finalized the project proposal, outlining the problem statement, objectives, and
proposed solution. The finalized proposal has been reviewed and approved by my supervisor.

Supervisor Meetings
I have held two meetings with my supervisor so far:

1. First Meeting (04.11.2024): Discussed the overall project concept, refined the problem
statement, and received feedback on the proposed solution. Key outcomes include agreeing
on the project scope and identifying initial resources for API exploration. (Appendix C)

Preliminary Analysis (xx.xx.xx)

I have completed a PACT analysis (People, Activities, Context, and Technology) to better understand
the user requirements and potential constraints. This analysis has been documented and is included
in Appendix D.

Initial Design Documentation (10.11.2024)

The project structure and flow have been outlined in a programme route diagram. This includes a
breakdown of key components such as the reviews API integration, sentiment analysis, and user
interface design. (Appendix A)

Exploration of Development APIs (12.11.2024)

I have started investigating various APIs for accessing reviews, including their documentation,
functionality, and integration process. Early tests have been conducted to verify their suitability for
the project.

Next Steps

• Begin coding the sentiment analysis component using the identified API.

• Conduct the next supervisor meeting to review progress and finalize development
milestones.

References

Olah, C. (2018). Introduction to Transformer Models for NLP: Using BERT, GPT, and More to Solve
Modern Natural Language Processing Tasks. [Video]. YouTube. Available at:
https://youtu.be/dIUTsFT2MeQ (Accessed: 25 November 2024).

Doe, J. (2021). Python API Development Fundamentals. 2nd edn. San Francisco: O'Reilly Media.

Appendices

Appendix A: Programme Route Diagram

Contains a personalized diagram outlining my academic pathway and selected project components.

Appendix B: Schedule
Detailed schedule template indicating tasks, milestones, and time allocation.

Appendix C: Supervisor Meetings

Includes evidence of meeting minutes and signed supervision forms.

Appendix D: Analysis & Design Diagrams

PACT analysis, heuristic inspection results, and wireframes for the proposed design.

Appendix E: Presentation Slides

Slides summarizing the project overview and progress to date.