Forem: Akanle Tolulope

Classifying Amazon Reviews with Python: From Raw Text to 88% Accuracy

Akanle Tolulope — Thu, 05 Mar 2026 11:23:02 +0000

Ever wondered how businesses know if customers are happy or not? In this project, I built a machine learning model that classifies Amazon product reviews as Positive or Negative using NLP techniques. Here's how I did it.

The Dataset
I used the Amazon Review Polarity Dataset — sampling 200,000 reviews for training and 50,000 for testing. The dataset was perfectly balanced between positive and negative reviews, which is ideal for classification.
Cleaning the Text
Raw reviews are messy. I wrote a preprocessing function to lowercase text, strip punctuation, numbers, and remove stopwords using NLTK. This is really helpful for the model to identify words properly.

def clean_text(text):
    text = str(text).lower()
    text = re.sub(r"[^\w\s]", "", text)
    text = re.sub(r"\d+", "", text)
    words = [word for word in text.split() if word not in stop_words]
    return " ".join(words)

Converting Text to Numbers with TF-IDF Machine learning models need numbers, not words. TF-IDF weighs words by how unique they are to each review — common words like "the" get ignored, meaningful words like "terrible" get prioritised.

vectorizer = TfidfVectorizer(max_features=5000, min_df=5, max_df=0.9)
X_train = vectorizer.fit_transform(train_df["clean_text"])
X_test = vectorizer.transform(test_df["clean_text"])

Training & Comparing Models
I trained and compared three models — Logistic Regression , Naive Bayes, and Linear SVM. Logistic Regression performed best and was used for the final evaluation.
Results
Tested on 50,000 reviews:
Metric Negative - Positive
Precision = 0.89 - 0.88
Recall = 0.88 - 0.89
F1-Score = 0.88 - 0.89
Overall Accuracy: 88% — balanced performance across both classes.
Real-Time Predictions

def predict_sentiment(text):
    cleaned = clean_text(text)
    vectorized = vectorizer.transform([cleaned])
    prediction = model.predict(vectorized)[0]
    return "Positive" if prediction == 1 else "Negative"

"This product is amazing!" -> Positive
"Completely useless, waste of money" -> Negative

Visualizations Three charts helped tell the story:

Sentiment distribution — confirmed the dataset was balanced

Word cloud — top positive words: great, love, best

Confusion matrix — symmetric errors, no class bias

What I Learned
Working at this scale (250k reviews) taught me that clean data and a balanced dataset matter more than model complexity. Logistic Regression beat fancier approaches simply because the data was well prepared.
Next steps: hyperparameter tuning, cross-validation, and eventually a BERT-based model for higher accuracy.
Full code on my GitHub — feel free to clone and try it on your own dataset!

Found this helpful? Drop a like or leave a comment below!

I Created My First AI Tool-Using Agent with LangGraph and Groq

Akanle Tolulope — Sun, 25 Jan 2026 20:14:16 +0000

When you are just starting out, you can easily become overwhelmed when trying to figure out how to create an intelligent agent (AI).

In this article, I will share my experience in building my first tool-using agent, based on Python and the technologies LangChain, LangGraph, and Groq.

As well as providing an overview of my project, I will also highlight the mistakes I made, as well as provide some of the learning experiences I went through while developing my AI agent.

This project also provided me with valuable insight into the technical workings behind modern intelligent agents.

What Is an Intelligent Agent?

Intelligent agents do much more than just provide a conversational experience.

The chatbot is limited to responding to questions posed by users.

Intelligent agents are capable of:

Finding your request based on task-related knowledge, Making decisions regarding how they should respond to your request, Providing the ability to call upon or use other tools, resources, and services when needed, Providing you with the results of the interaction to your request.

The project I worked on employed the ReAct pattern (Reason and Act).
The ReAct pattern refers to the process used to build intelligent agents in the real world.

The technology stack I utilized to develop this project was:

Python
LangChain (using LLMs to create abstractions for LLMs)
LangGraph (creating workflows to support agent-oriented tasks)
Groq (providing fast, free inference of LLMs)
Git / GitHub (for version control and publishing)

One key takeaway from this project is that the LLM model itself may become obsolete and therefore it is important to build a flexible configuration.

Building the Tool

Here’s an example of the calculator tool I added to the agent:

@tool
def calculator(a: float, b: float) -> str:
    """Useful for performing basic arithmetic calculations with numbers"""
    return f"The sum of {a} and {b} is {a + b}"

The Agent uses the docstring to determine when to make use of the tool, which is a crucial piece for its functioning and decision-making process.

The Agent in Action

User: Can you add 7 and 9? Agent: (reasons about the task) Tool called: calculator Result: 16

The Moment When I Saw the Agent Using the Tool Independently Was a Surprising and Eye-Opening Experience for Me.

Lessons Learned
Some Key Takeaways that Come Out of This Experience Include:

Developing Artificial Intelligence Requires a Significant Amount of Debugging and That It Is Not a Simple Process.
The Way in Which a Tool is Documented Has a Major Impact on the agent's Decision-Making Process When Using the Tool.
It Is Essential to Use Git, and It Is Not Optional.
By Accurately Reading the Error Messages You Receive When Debugging, You Can Save Yourself a Lot of Time.

The Project's Source Code Is Available on GitHub by Following the Link Below:
🔗 [https://github.com/Akansrodger/ai-agent-with-tools]

From CSV to Insights: Analysing Walmart Sales with Python & PostgreSQL

Akanle Tolulope — Mon, 15 Dec 2025 11:31:26 +0000

During my journey to learn Data Analysis, I decided to start a project that actually seems real, not just another tutorial project. The project I chose is to analyse Walmart Sales Data using Python for Data Cleaning and PostgreSQL (SQL) for SQL Analysis, taking data from a RAW CSV file and providing Business Insights.

Project Overview:
To take raw (incomplete) sales data and prepare it for storage in a database (where it can be organized), and run SQL queries to obtain key business insights from the prepared data.

I used Panda's Python library to prepare the sales data for storage; then I imported it into PostgreSQL, so I could perform structured queries on it.

Tools Utilized: Pandas, SQLAlchemy, PostgreSQL, SQL, and VSCode; and the source was Kaggle, from which I obtained Walmart's sales data set.

Description of DataSet: The dataset contains detailed transaction-related information for a specific period, including product family, store/branch information, price and quantity that were sold; customer ratings; time the product was purchased.

How I did it: Data Preparation with Python - I utilized the Pandas Library to remove duplicates, alter data types, convert currency amounts into numbers, and create a new column that totals up all sales.

Load the Data into PostgreSQL - I imported the cleaned sales data into PostgreSQL utilising SQLAlchemy. This allowed me to create a similar environment for analyzing sales data to how it would be managed within a business.

SQL Analysis - Using SQL, I was able to answer some essential business inquiries, including which day of the week is the busiest for each store and what type of product sells the most, the categories generating profits, and the patterns of product sales throughout each store's operating hours (using Window Functions and Aggregate Functions in SQL).

Key Takeaways: For cleaning and preparing datasets to enable structured analysis, Pandas is an excellent tool. The power of SQL is its ability to do structured analysis across different datasets. Complex organizational queries can be answered with the help of SQL window functions.

🔗 Complete project source code (GitHub): https://github.com/Akansrodger/Walmart_sales_SQL_PYTHON

My last words on this journey...

This project provided me with the ability to integrate all of the technologies (Python/SQL/Databases) into one consolidated process (workflow) and provided me with another important step in becoming a better data analyst.

Building a Library Management System with SQL: My Journey, Insights, and Best Practices ✨

Akanle Tolulope — Tue, 28 Oct 2025 11:23:08 +0000

As a data analyst passionate about turning raw data into structure and insight, I recently completed a project that truly strengthened my SQL skills, a Library Management System built entirely using SQL. The goal was simple: to create a relational database that could efficiently manage books, members, employees, and issued records, just like in a real-world library setup.

What started as a basic idea quickly became a full-fledged learning experience. I designed tables for books, members, and employees, then implemented joins and relationships to connect them through issued and returned transactions. One of the key lessons I learned was how data normalisation and relationships bring structure and clarity to even the most complex systems.

For example, this simple query helped me identify members who borrowed more than one book:

SELECT 
  m.member_name,
  COUNT(ist.issued_id) AS total_books
FROM issued_status AS ist
JOIN members AS m 
  ON m.member_id = ist.issued_member_id
GROUP BY m.member_name
HAVING COUNT(ist.issued_id) > 1;

It was exciting to see how a few lines of SQL could transform raw data into real insights. I also explored ways to count how many books each employee had issued, which deepened my understanding of JOINs and GROUP BY logic:

SELECT 
  e.emp_name,
  COUNT(ist.issued_id) AS books_issued
FROM issued_status AS ist
JOIN employees AS e 
  ON e.emp_id = ist.issued_emp_id
GROUP BY e.emp_name;

Beyond queries, I implemented a stored procedure to automate repetitive tasks like tracking issued and returned books. This step gave the project a more practical feel — similar to how database operations work behind the scenes in real organisations.

Overall, this project reminded me that even seemingly simple systems can teach deep analytical and structural thinking. If you’re learning SQL or data management, I’d highly recommend trying to build something like this. It’s not just about writing queries — it’s about thinking through real-world data problems, relationships, and efficiency.

👉 You can check out the full project on my GitHub here: https://github.com/Akansrodger/Library-Management-System-using-SQL-Project---prj2

You can check me out on other social media platforms:

Instagram: https://www.instagram.com/jackiiee_.__/

X: https://x.com/Akansrodgers

How I Analyzed Retail Sales Data Using SQL

Akanle Tolulope — Fri, 11 Jul 2025 14:28:23 +0000

Hello everyone, it's me again. Today I’m excited to share another practical project I worked on to strengthen my SQL and data analysis skills: a retail sales data analysis built entirely with SQL!

**
Now lets look at Why Sales Data Analysis is Important **

Retail businesses rely heavily on sales data to track product performance, monitor revenue growth, and make informed business decisions. As a data analyst, the ability to efficiently query and summarize sales data is a must-have skill—which this project allowed me to practice.

** Project Overview **

I created a simple retail sales database consisting of two tables:

Products: Contains product details like name, category, and unit price.
Sales: Records sales transactions, including product ID, quantity sold, and sale date.

From there, I wrote SQL queries to answer critical business questions such as

What’s the total quantity sold and revenue for each product?
What’s the average quantity sold per product?
Which products generated revenue above a target threshold?
Which product was the top seller by total revenue?

*Tools and Skills Used *

SQL (DDL, DML, Aggregate functions, HAVING, JOIN, Subqueries)**
GitHub for project hosting and code management

** Tables I Created **

CREATE TABLE Products(
ProductID INT PRIMARY KEY,
ProductName VARCHAR(50),
Category VARCHAR(50),
UnitPrice DECIMAL(10, 2)
);

CREATE TABLE Sales(
SalesID INT PRIMARY KEY,
ProductID INT,
Quantity INT,
SaleDate DATE
);
Then i inserted values into these tables using 'INSERT INTO'

Key Queries and Insights

View all sales transactions with product names and total sale amounts
Calculate total quantity sold and total revenue per product
Compute average quantity sold per product
Identify products with total revenue above 3,000
Find the product with the highest total sales revenue

Example: SELECT ProductName, SUM(S.Quantity) AS total_quantity_sold,
SUM(S.Quantity * P.UnitPrice) AS total_revenue
FROM Sales S
JOIN Products P ON S.ProductID = P.ProductID
GROUP BY ProductName
ORDER BY total_revenue DESC;

Lessons I Learned
SQL aggregate functions are powerful tools for summarizing business data.

Always double-check your JOIN conditions when combining tables.

Subqueries can simplify complex logic if structured correctly.

Project Link
Check out the full project and SQL scripts on GitHub:
https://github.com/Akansrodger/retail-sales-data-analysis-sql

Final Thoughts
This was a rewarding small project that reinforced core SQL skills and demonstrated how straightforward queries can provide valuable business insights.

I recommend similar practical projects to anyone starting out in SQL or data analysis; you’ll gain useful skills fast and have solid portfolio material to show for it.

If you found this useful, check out my Hospital Patient Management System SQL project too.

How I Built a Hospital Patient Management System Using SQL

Akanle Tolulope — Tue, 08 Jul 2025 21:59:56 +0000

Article Outline:
Introduction

Project Overview

Tools and Skills Used

Database Design (ERD)

Key Features of the System

Sample Queries I Ran

Challenges I Faced

Lessons Learned

GitHub Project Link

Closing Thoughts

Hello everyone, in today’s post, I’ll be sharing how I designed and built a Hospital Patient Management System using SQL as part of my data analyst learning journey and public project portfolio.

I built this project to strengthen my database management and SQL querying skills, while preparing for open-source opportunities like Outreachy.

Project Overview

The project involved creating a relational database to manage:

Patient's personal information
Departments
Diagnoses
Visit history
Risk assessments

The system makes it easy for a hospital to store, retrieve, and analyse patient data efficiently.

🛠️ Tools and Skills Used

SQL (DDL, DML, and queries)
Database design
ERD (Entity Relationship Diagram)
GitHub for project hosting and version control

Database Design

I designed a normalised database with the following tables:

'Patients'
'Doctors'
'Visit'

They’re connected through primary and foreign key relationships.

ERD Diagram:

Key Features of the System

Proper use of primary and foreign keys
Inserted realistic sample patient and visit records
Wrote clean SQL queries to analyse:
- Patient visits
- Risk level distributions
- Department workload reports

Sample Queries I Ran

Number of visits per patient
SELECT p.Full_Name, COUNT(v.VisitID) AS Number_of_Visits
FROM patients p
JOIN Visit v ON p.PatientID = v.PatientID
GROUP BY p.FullName;

Get All Visits with Patient & Doctor Names

SELECT V.VisitDate, P.FullName AS Patient, D.FullName AS Doctor, V.Diagnosis
FROM Visit V
JOIN Patients P ON V.PatientID = P.PatientID
JOIN Doctors D ON V.DoctorID = D.DoctorID;

Lessons Learned

Plan your database structure first
Always set up primary and foreign keys
Use sample data to test your queries

GitHub is a great place to showcase SQL projects publicly

Project Link
Check out the full project on GitHub:

https://github.com/Akansrodger/hospital-patient-management-system-sql

Feel free to download the .sql files and try out the queries!

Closing Thoughts
This project has improved my confidence in database design and SQL query writing. It’s one of the first of many I’ll be adding to my public portfolio.

Thanks for reading!

How I Built a Sales Dashboard in Excel and Published It on GitHub

Akanle Tolulope — Thu, 03 Jul 2025 14:02:46 +0000

How I Built a Sales Dashboard in Excel and Published It on GitHub

Hello everyone 👋 — I'm excited to share one of the first projects in my data analysis portfolio: a fully interactive Sales Dashboard built with Microsoft Excel

As part of my journey to sharpen my data skills and prepare to solve problems with data.

Project Overview

This project involved analysing a fictional sales dataset to track:

Monthly sales performance
Regional breakdown
Product category trends
Key sales metrics like Total Sales and Profit

I designed an interactive Excel dashboard that uses pivot tables, pivot charts, KPI cards, and slicers to create a simple yet powerful data visualisation tool for business decision-making.

Tools and Skills Used

Microsoft Excel: for data cleaning, analysis, and dashboarding
Pivot Tables: to quickly summarise sales by month, region, and category
Pivot Charts: for dynamic visualisations
Slicers: for interactive filtering
GitHub: to host and share the final project

Key Features of the Dashboard

Dynamic KPI cards for Total Sales, Total Profit, and Sales Target
Bar and column charts for monthly and regional performance
Category breakdown pie chart
Slicers to filter by Region, Product Category, or Sales Period
Clean, business-style layout

🛑 Of course,
I had challenges!

At first, I struggled with:

Setting up multiple pivot tables on the same worksheet
Designing a clean, clutter-free dashboard layout
Making sure the slicers worked across all charts

But after a few tweaks and learning from some tutorials, I got it working smoothly.

What Lessons Learned have I learned?

Pivot tables are incredibly powerful for summarising large data sets
A simple, clean dashboard layout communicates insights faster
Sharing your projects publicly helps build confidence and opens opportunities

Project Link

Check out the full project on my GitHub:

📊 Sales Dashboard Repository

Feel free to download the file, explore the pivot tables, and interact with the dashboard.

👋 Closing Thoughts

This was my first step toward building a strong public data analysis portfolio. I’ll be sharing more projects soon, including patient record analysis, survey data summaries, and a personal budget tracker.

If you have feedback or suggestions, I'd love to connect!