Forem: teresa kungu

Deploying a Customer Lifetime Value (CLV) Prediction Model Using FastAPI

teresa kungu — Mon, 09 Feb 2026 14:36:52 +0000

Introduction

Businesses want to know which customers are most valuable to them. Some customers spend more money, stay longer, and interact more with the business than others. If a company can predict this early, it can make better decisions about marketing, customer support, and retention.

This is where Customer Lifetime Value (CLV) becomes important. In this project, a machine learning model was built to predict CLV using customer data. The trained model was then deployed using FastAPI, allowing predictions to be made through a simple API.

Project Objectives

Explain what Customer Lifetime Value (CLV) is
Build a regression model to predict CLV
Compare models and choose the best one
Save the trained model for future use
Deploy the model using FastAPI
Predict CLV through an APIProject Objectives
Test the API to confirm it works

Understanding Customer Lifetime Value (CLV)

Customer Lifetime Value is the total amount of money a business expects to earn from a customer during their entire relationship with the company.
For example, if a customer spends a small amount every month but stays for many years, their CLV can be high. On the other hand, a customer who spends a lot once but never comes back may have a low CLV.

Predicting CLV helps businesses to:

Identify high-value customers
Spend marketing money wisely
Improve customer retention
Plan better customer engagement strategies

Because CLV is a number, predicting it is a regression problem in machine learning.

Dataset and Business Problem

The dataset used in this project is called customer_lifetime.csv. Each row represents one customer, and each column describes something about that customer.

Important columns include:

Customer_Age – Age of the customer
Annual_Income – Yearly income
Tenure_Months – How long the customer has been active
Monthly_Spend – Average monthly spending
Visits_Per_Month – Number of visits per month
Avg_Basket_Value – Average value per purchase
Support_Tickets – Number of support issues raised
CLV – Customer Lifetime Value (target variable)

The main goal is to predict CLV for new customers before spending money on marketing or retention.

Data Preparation

The first step was to load and explore the dataset to understand the data types and structure. The CLV column was identified as the target, while the remaining columns were used as input features.

The data was then split into:

Training data – used to teach the model
Testing data – used to check how well the model performs

Splitting the data is important because it shows how the model will perform on new, unseen customers.

Building the Regression Models

Since CLV is a continuous number, regression models were used.

Two models were built:

Linear Regression

This model was used as a baseline. It is simple, fast, and easy to understand, but it may not capture complex customer behavior.

Random Forest Regressor

This model uses many decision trees to make predictions. It handles complex relationships better and usually gives more accurate results.

Regression is suitable for this problem because the goal is to predict a numeric value, not categories.

Model Evaluation and Selection

Both models were evaluated using regression metrics such as:

Mean Absolute Error (MAE)
Mean Squared Error (MSE)
R-squared (R²)

The Random Forest model performed better than Linear Regression because it captured more complex patterns in the data. For this reason, it was selected as the final model.

Saving the Model

The final trained model was saved using Joblib, along with the list of features used during training.

Saving the model is important because:

The model does not need to be retrained every time
Predictions are consistent
The API runs faster and more efficiently

The saved files are stored in a saved_model folder.

Deploying the Model Using FastAPI

FastAPI was used to deploy the model as a web API. FastAPI is a Python framework that makes it easy to create APIs and automatically validates input data.

The model is loaded when the API starts. The model is not retrained inside the API, which follows best practices for production systems.

How the API Works

The API has two main endpoints:

Health Check Endpoint

GET /
This endpoint confirms that the API is running correctly.

2.CLV Prediction Endpoint

POST /predict-clv

This endpoint:

Accepts customer data in JSON format
Checks if the input data is valid
Sends the data to the trained model
Returns the predicted CLV value

Testing the API

The API was tested using:

FastAPI Swagger UI
Postman

Successful testing showed that the API correctly accepts input data and returns CLV predictions.

Conclusion and Future Improvements

This project shows a complete machine learning process, from understanding customer data to deploying a working prediction API. Predicting CLV helps businesses make smarter and more data-driven decisions.

In a real business setting, the model could be improved by:

Adding more customer behavior data
Monitoring predictions over time
Retraining the model with new data

Overall, this project demonstrates how machine learning models can be moved from development into real-world applications using FastAPI.

Ridge Regression vs Lasso Regression

teresa kungu — Mon, 26 Jan 2026 08:01:56 +0000

Introduction

Predicting house prices is a common problem in data science. A house’s price is influenced by many factors such as its size, number of bedrooms, distance to the city, and nearby amenities. However, real-world datasets also contain noise — features that do not truly affect the price.
In this article, we use a house price dataset to explain:

Ordinary Least Squares (OLS)
Ridge Regression (L2 Regularization)
Lasso Regression (L1 Regularization)

The goal is to understand how these models work, why regularization is needed, and which model to choose in practice, using simple explanations and visual support.
1. Loading the Dataset

We begin by loading the dataset into Python using common data science libraries. This step allows us to inspect the data and understand what features are available.

The dataset contains 500 houses and includes:

House characteristics (size, bedrooms, bathrooms)
Location information (distance to city)
Social features (schools nearby)

Some noisy or weak features that do not meaningfully affect price
Figure 1: Loading the house price dataset and displaying sample rows.

2*. Understanding the Data*

Before building any model, it is important to understand the data.
Important Features

size_sqm – size of the house
bedrooms – number of bedrooms
bathrooms – number of bathrooms
distance_to_city – distance from city center
schools_nearby – number of nearby schools

Noisy / Weak Features

paint_color_code
random_id_feature
weather_noise
street_code
Target Variable
price – the value we want to predict

Some features clearly make sense, while others are random and should not affect house price.

3. Splitting Features and Target

Next, we separate:

_Input features (X) – all columns except price

Target (y) – the house price_

This prepares the data for training machine learning models.

4. Train–Test Split
To evaluate model performance properly, we split the dataset into:

Training data– used to train the model
Testing data –used to evaluate performance on unseen data

This step is critical for detecting overfitting.

5. Ordinary Least Squares (OLS)
What is OLS?

Ordinary Least Squares is the most basic linear regression method. It finds model coefficients by minimizing the sum of squared differences between actual house prices and predicted prices.
Why OLS Can Overfit

OLS:

Uses all features
Assigns coefficients to both useful and noisy variables
Can give large weights to irrelevant features

In our dataset, OLS may treat random_id_feature as important, even though it has no real meaning.

6. Detecting Overfitting with OLS

To check overfitting, we compare:

Training performance
Testing performance

If training accuracy is high but test accuracy is much lower, the model is overfitting.

Regularization: Why We Need It**

Regularization adds a penalty to the loss function to control model complexity.

It helps:

Reduce overfitting
Shrink large coefficients
Improve performance on unseen data

Two common regularization techniques are** Ridge and Lasso regression.

8. Ridge Regression (L2 Regularization)
How Ridge Works

Ridge regression adds an L2 penalty, which penalizes large coefficients by squaring them.

Ridge:

Shrinks all coefficients
Keeps all features
Reduces sensitivity to noise

Ridge on Our Dataset

In our house price data:

Important features still have strong influence

Noisy features receive very small coefficients

No feature is completely removed

9. Lasso Regression (L1 Regularization)
How Lasso Works

Lasso regression uses an L1 penalty, which can shrink coefficients to zero.

This means:

Unimportant features are removed
The model becomes simpler and easier to interpret

Lasso on Our Dataset

After applying Lasso:

Features like size_sqm and bedrooms remain
Noisy features such as weather_noise and random_id_feature are set to zero

10. Ridge vs Lasso Comparison

Aspect	Ridge Regression	Lasso Regression
Regularization	L2	L1
Feature selection	No	Yes
Handles noise	Shrinks	Removes
Interpretability	Lower	Higher

11. Model Evaluation Using Residuals

Residuals are the differences between:

Actual house prices
Predicted house prices

By plotting residuals:

Random scatter → good model
Clear patterns → poor model fit

12. Choosing the Right Model
If all features are believed to matter

Choose Ridge Regression

Keeps all features
Controls overfitting
Works well with correlated variables

If only a few features are important

Choose Lasso Regression

Removes noisy features
Produces a simpler model
Easier to explain and interpret

Conclusion

Using the house price dataset, we observe that:

OLS is simple but prone to overfitting

Ridge regression improves stability by shrinking coefficients

Lasso regression simplifies the model by removing irrelevant features

Understanding Classes in Object-Oriented Programming: A Beginner's Guide

teresa kungu — Sun, 14 Dec 2025 17:30:48 +0000

Object-Oriented Programming (OOP) is a programming approach that helps us organize code by modeling real-world concepts. One of the most important ideas in OOP is the class.
What Is a Class?

A class is a blueprint or template used to create objects. It defines what data an object should store and what actions it can perform. The class itself is not an object; instead, it describes how objects of that type should behave.

For example, if we want to represent a bank account in a program, we can create a BankAccount class. This class will describe what every bank account has (such as an account number and balance) and what it can do (such as depositing or withdrawing money).
Why Are Classes Useful?
Classes help programmers:

Organize code in a clear and logical way
Avoid repeating the same code multiple times
Model real-world entities more naturally
Make programs easier to read, maintain, and extend

Instead of writing many unrelated variables and functions, classes group related data and behavior together.
Attributes and Methods

Attributes are variables that store data about an object.
Example: account number, owner name, balance.

Methods are functions defined inside a class that describe what the object can do.
Example: deposit money, withdraw money, check balance.

Together, attributes and methods describe both the state and behavior of an object.

Example: A BankAccount Class

Below is a simple example using Python:

The init method is a special method that runs when a new object is created. It initializes the account number, owner, and balance.
deposit() adds money to the account.
withdraw() removes money if there is enough balance.
check_balance() displays the current balance.

Creating an Object from the Class

Once the class is defined, a student can create an object (also called an instance) from it:

Now account1 is a real bank account created from the blueprint.
Using the Object

The student can now call the methods of the object:

Each object created from the class has its own data and can perform actions independently.

Conclusion

Classes are a powerful way to structure programs by modeling real-world problems. They combine data (attributes) and behavior (methods) into a single, logical unit. By using classes like BankAccount, beginners can clearly see how OOP helps create organized, reusable, and easy-to-understand code. As programs grow larger, classes become essential for building clean and maintainable software.

##How to Connect Power BI to Aiven PostgreSQL

teresa kungu — Sun, 23 Nov 2025 05:42:08 +0000

📌 Prerequisites

Power BI Desktop installed
PostgreSQL (local or Aiven)
Basic understanding of database credentials (host, username, password)

🟦 1. Connect Power BI to Local PostgreSQL

1. Install PostgreSQL ODBC Driver

Download and install the PostgreSQL ODBC driver (psqlODBC) from the official PostgreSQL website.

2. Gather Local Connection Details

Make sure you have:

Host: localhost
Port: 5432
Database: your_database_name
Username: your_username
Password: your_password

3. Connect Power BI to Local PostgreSQL

Open Power BI Desktop
Click Get Data → More...
Select PostgreSQL database

Enter your connection details:

Server: localhost
Database: your_database_name

Click OK and enter your username & password.

4. Load Tables

Power BI will display all tables in your PostgreSQL database.

Select the tables you want → click Load.

🟦 2. Connect Power BI to Aiven PostgreSQL (Cloud)

Aiven requires SSL, but the setup is straightforward.

1. Get Aiven PostgreSQL Credentials

From your Aiven dashboard:

Open your PostgreSQL service
Go to Overview
Copy your connection details:
- Host
- Port
- Database
- Username
- Password
- SSL mode (Required)

2. Connect Power BI to Aiven with SSL Enabled

Open Get Data → PostgreSQL database
Enter:

Server: your-service-name.aivencloud.com Database: defaultdb Port: your_port

Open Advanced options and add:

SSL Mode=Require

Click OK → Enter your password.

3. SSL Troubleshooting

If you get certificate errors, try:

SSL Mode=Verify-Full

or download the Aiven CA certificate and configure it.

🟦 Optional: Use Connection Strings

Local PostgreSQL:

Server=localhost;Port=5432;Database=myDB;UID=myUser;PWD=myPassword;

Aiven PostgreSQL:

Server=your-host.aivencloud.com;Port=12345;Database=defaultdb;UID=avnadmin;PWD=yourPassword;SSL Mode=Require;

🟦 Power Query (M Code) Example

m let Source = Postgres.Database( "your-host.aivencloud.com", "defaultdb", [ Port=12345, SSLMode=1, User="avnadmin" ] ) in Source

🟦 Best Practices

🔐 Security

Never publish passwords in articles or dashboards
Use Power BI Gateway for scheduled refresh

⚡ Performance

Use DirectQuery for real-time dashboards
Use Import mode for better performance on large mode

🟦 Conclusion

You now know how to connect Power BI to:

Local PostgreSQL
Aiven PostgreSQL (with SSL)

This simple setup allows you to start building powerful dashboards quickly.

Power BI and DAX: Making Data Easy to Understand

teresa kungu — Wed, 08 Oct 2025 22:21:03 +0000

What is Power BI and Why is it Important?

Imagine you have a lot of numbers and information, like records of crops grown in different Kenyan counties. It can be hard to see the story in all that data. Power BI is a tool from Microsoft that turns this raw data into easy-to-understand visuals like charts and maps. Instead of looking at confusing spreadsheets, you can see a clear dashboard that shows you exactly what’s happening.

What is DAX and What Makes it Powerful?

DAX (Data Analysis Expressions) is the special language used in Power BI to create calculations. Think of it as the "brain" that works behind the scenes. If Power BI is the car, DAX is the engine. It helps you ask complex questions about your data and get clear answers.

Here are some simple examples using a Kenya Crops dataset:

Mathematical Functions

SUM: Adds up the total harvest.
Example: Total Harvest = SUM(Crops[Yield])

AVERAGE: Finds the average yield per farm.
Example: Average Yield = AVERAGE(Crops[Yield])

Text Functions

LEFT / RIGHT: Gets part of a text. You could extract a county code from a longer name.

CONCATENATE: Joins text together, like combining a county name and a crop type into one description.

Date & Time Functions

YEAR: Extracts the year from a date to see trends over time.

TOTALYTD: Calculates the total yield from the start of the year up to today.
Example: Year-to-Date Harvest = TOTALYTD(SUM(Crops[Yield]), Dates[Date])

SAMEPERIODLASTYEAR: Compares this season's harvest to the last one.
Example: Sales LY = CALCULATE(SUM(Crops[Yield]), SAMEPERIODLASTYEAR(Dates[Date]))

Logical Functions

IF: Makes decisions with data.
Example: High Yield = IF(Crops[Yield] > 1000, "High", "Low")

SWITCH: Chooses from multiple options, like categorizing crops into types.

How Does This Help?

For a farmer or agribusiness, this is a game-changer. With Power BI and DAX, they can:

Instantly see which crop is most profitable in their region.

Compare this year's harvest to last year's to measure progress.

Identify the best and worst-performing seasons.

My Personal Insight

The real value of Power BI and DAX isn't just in making pretty charts. It's in saving time and making smarter decisions. Instead of guessing, farmers and business owners can use data to know exactly what to plant, when to sell, and where to focus their efforts. It turns uncertainty into a clear plan for success