Category: General

Do you run a professional conference that occurs periodically? Are you an owner of a cruise line or a blood drive? Perhaps you own a church. If any of these apply to you then you’re running a business that operates in a noncontractual, discrete-time context. Noncontractual discrete-time contexts are business settings where customer transactions occur at fixed intervals and where a customer can terminate their relationship with the business at anytime. If you wanted to model customer lifetime value for these type of businesses, the Pareto/NBD and BG/NBD would not cut it; both models work only in noncontractual, continuous business settings. What you can use is the Beta Geometric/Beta Bernoulli model, or BG/BB for short. In this post I’ll dive into the nuts and bolts of the model and show you how a charity can use it to predict donations.

BG/BB Modeling Assumptions

There are several assumptions that underline the use of the BG/BB model. As done before, I’ll go through each assumption and explain what they mean.

Assumption #1: A customer can be “alive” for some unobserved period of time, and become permanently inactive, aka “die”.

“Alive” in this context means that the customer is making transactions with the business. Given that this is a non contractual business setting, we are unable to determine whether the customer has ended their relationship with the business or is taking a long term hiatus. It’s therefore assumed that the customer becomes inactive after some unknown period of time.

Assumption #2:  The number of transactions that a customer will make while alive follows a binomial distribution.

Let’s look at this assumption in the context of a charity that requests donations every month from individuals who have made a contribution in the past. Each time the charity reaches out, some individuals may choose to make a donation and some may choose not to.  Given an individual and a month, the we represent the chance that he or she will make a donation using a probability. We’ll call this probability p.

We can use the binomial distribution to model the probability that an individual will make a number of donations over the course of several months.

The number of months and number of donations is represented with n and x respectively. The probability of no donation during a single month is represented by q. This is essentially the inverse of p, the probability that the individual will make a donation.

Assumption #3: The unobserved lifetime of a customer can be described using a geometric distribution.

Going back to the charity scenario I created in the previous section, we assume that each month a donor can “drop out” by some probability. We’ll represent the probability using ϴ. If we were curious about the probability a donor will drop out after x number of months we can use the geometric distribution to find out:

If we were to plot the geometric distribution using some value for ϴ and a range of values for x, we would see that the probability would decrease as x increases, which reflects what we would expect from a customer who has made many donations in the past.

Assumption #4: Heterogeneity in the transaction probability for each customer follows a beta distribution.

Each donor will have a different likihood of making a contribution each month. Some donors will contribute at every opportunity while others may choose to donate occasionally. The beta distribution can be used to model the donation probabilities for each donor.

Assumption #5: Heterogeneity in the dropout probability for each customer follows a beta distribution

We can also reasonably assume that the dropout probability will vary for each donor. We can also use the beta distribution to model this for each donor.

Assumption #6: The transaction probability and the dropout probability vary independently across customers

What this means is that there’s no relationship between the transaction probability and dropout probabilities amongst the customer base. 

The Model

The second and fourth assumptions outlined in the previous section result in the Beta Bernoulli model. Similarly, the third and fifth assumptions lead to the beta-geometric model. Together, they form the Beta Geometric/Beta Bernoulli model. For insights on the derivation of the model as well as the functions used to perform various predictions, you can read the paper here.

BG/BB In Action

As done with the other models discussed thus far, I will  show you a demonstration of BG/BB. I will be using a dataset included in the lifetimes python model that contains recency and frequency data of individuals making donations to a major nonprofit organization located in the United States.

We’ll begin by loading the donations dataset.

import pandas as pd
import lifetimes
import lifetimes.datasets as ld

donations_df = ld.load_donations()

The dataset provided by lifetimes provides all the information we need to utilize the BG/BB model.

• The frequency column in the dataset records the number of observed periods where a transaction was made.
• The recency column shows the time period where the most recent transaction was made
• The periods column indicates the number of transaction opportunities that were provided.
• The weight column indicates the number of customers with a given frequency, recency, and period combination. 

We will fit a BG/BB model using the above information.

bgbb_mdl = lifetimes.BetaGeoBetaBinomFitter()
bgbb_mdl.fit(frequency=donations_df['frequency'],
             recency=donations_df['recency'],
             n_periods=donations_df['periods'],
             weights=donations_df['weights'])

Let’s say we were interested in identifying  customers that will still be active 3 months into the future. We can use the conditional_probability_alive method to do this:

donations_df['is_alive_3_months'] = bgbb_mdl.conditional_probability_alive(m_periods_in_future=3,
                                       frequency=donations_df['frequency'],
                                       recency=donations_df['recency'],
                                       n_periods=donations_df['periods'])

Assuming we were only interested in customers with a alive probability of 0.7 or greater, we can see that roughly a 1/3 of the customer base will still be active after 3 months.

We can also estimate the number of transactions each customer will make in 3 months time using the conditional_expected_number_of_purchases_up_to_time method:

donations_df['num_tx_3_months'] = bgbb_mdl.conditional_expected_number_of_purchases_up_to_time(m_periods_in_future=3,
                                                                                               frequency=donations_df['frequency'],
                                                                                               recency=donations_df['recency'],
                                                                                               n_periods=donations_df['periods'])

Looking at the same group of active customers, we can expect to receive at least 1 donation from these customers within the next 3 months.

That’s all folks!

You can find the complete code discussed in this post here.

If you’ve been following my series of posts on customer lifetime value prediction, you should be well aware of Pareto/NBD and BG/NBD. Both models can be used to estimate the lifetime of any given customer and predict the number of transactions the customer will make while alive. It would be nice if we could also get an estimate of the average spend per transaction of each of our customers. The next model I will be going over will do just that. It is called Gamma Gamma.

Gamma Gamma Modeling Assumptions

Much like Pareto/NBD and BG/NBD, Gamma Gamma models come with their own set of assumptions.

• The first assumption is that the monetary value of any given customer transaction varies randomly around the mean transaction value for the customer. We’ll go into more detail about this point later.
• The second assumption is that the average spend varies across customers, but remains consistent over time for any individual customer.
• The third assumption is that the distribution of average spend across customers is independent of the transaction process.

Going back to the first assumption, the value of each transaction is assumed to the distributed according to a gamma distribution. The gamma distribution formula again is:

Where α and β describe the shape and rate of the distribution. It just so happens that the rate parameter is also randomly distributed by the gamma distribution as well. The Gamma Gamma model got its name because of its use of two gamma distributions.

Given the assumptions we can calculate the average monetary value for any customer using the following equation:

You can read the original paper on the Gamma Gamma model for details on how the above equation was derived. Now that we’ve discussed what the model is, let’s see it in action.

Gamma Gamma Model In Action

To demonstrate the Gamma Gamma model, I will return to the Online Retail dataset used in previous posts.

I’ll start by once again reading in the transaction dataset:

transactions_df = pd.read_csv('data.csv',encoding='ISO-8859-1')

The Gamma Gamma model that I will be using comes from the lifetimes package. The model requires two pieces of information in order to provide predictions:

• The frequency of the customer transactions, and
• The total amount spend for each transaction

The required information will need to be calculated from the dataset. For the sake of brevity I will not be showing the calculation of the frequency and monetary values. You can refer to my RFM blog post for the details.

At this point, if you’ve read my previous post, we will have two pandas dataframes containing the frequency and monetary values. We will now combine them into one dataframe to make management of the data a little bit easier. We also want want to make sure that our dataframe does not contain any monetary values less than or equal to 0; the method that we will be using to calculate expected average profit will not work if such data is present.

combined_df = pd.merge(frequency_df, monetary_df, on='CustomerID')
combined_df = combined_df[combined_df['monetary'] > 0]

Now before proceeding with the model fitting we want to check for a correlation between the frequency and monetary values. This is to ensure that the third assumption of the Gamma Gamma model is valid. We won’t be able to use the model if there’s a strong correlation between the two fields.

combined_df[['frequency','monetary']].corr()

There appears to be a moderate correlation between frequency and monetary, but definitely not strong enough to stop us from using the model. We will go ahead and proceed with the fitting.

gg_mdl = lifetimes.GammaGammaFitter()
gg_mdl.fit(combined_df['frequency'], combined_df['monetary'])

The expected average spend per transaction for each customer can be computed using the conditional_expected_average_profit method.

combined_df['average_profit'] = gg_mdl.conditional_expected_average_profit(combined_df['frequency'],combined_df['monetary'])

Estimating Customer Lifetime Value

Gamma Gamma can be combined with either the Pareto/NBD or BG/NBD to calculate a lifetime value figure for each customer. This is all possible with the customer_lifetime_value method. To use it, we’ll first need to build a transaction model. I will be demonstrating the use of the method using a Pareto/NBD model. Read my Pareto/NBD post for details on the construction of the model.

Some of the other parameters used by the method that you’d want to know about are:

• Frequency: The frequency of the customer transactions
• Recency: The amount of time passed since the customer’s most recent transaction
• Age: The amount of time since the customer’s initial purchase
• Monetary: The monetary value of each transaction
• Time: The amount of months into the future to estimate the lifetime value
• Discount Rate: The monthly adjusted discount rate
• Freq: The time unit of the age is measured in

Here, we will be estimating the 3 month customer lifetime value for each customer.

combined_df['cltv'] = gg_mdl.customer_lifetime_value(pareto_mbd_mdl,
                                                    combined_df['frequency'],
                                                    combined_df['recency'],
                                                    combined_df['age'],
                                                    combined_df['monetary'],
                                                    time=3,
                                                    freq='D')

That’s all Folks!

You can find the code for this post here.

In my last post we examined the nuts and bolts of the Pareto/NBD model. If you haven’t had a chance to read it, you can find a link to the article here. The Beta Geometric Negative Binomial Distribution, or BG/NBD for short, is another probability model that is frequently used by practitioners predict customer lifetime value in continuous, non-contractual settings. The underpinnings of the model is very similar to that of the Pareto/NBD. This post will cover the differences between the two models. Afterwards a quick demonstration of the model in action will be shown.

BG/NBD Modeling Assumptions

The modeling assumptions of BG/NBD is similar to that of the Pareto/NBD. The table below provides a side-by-side comparison of the assumptions behind both models:

As you can see the first two assumptions of BG/NBD is the same as that of the Pareto/NBD. The third assumption and onwards are where the key differences lie. Let’s take a closer look at each assumption and break down what they mean.

Assumption #3: After each transaction, a customer can drop out with probability p.

BG/NBD takes a different approach to modeling the lifetime of each customer than Pareto/NBD. After each transaction, the model assumes that a customer may choose to discontinue their patronage afterwards. If we were looking at a grocery store for example, this would be akin to a customer shopping at the grocery store one week, and then choosing not to return the following week; perhaps because the customer found another store that sells groceries at a cheaper price.  The likihood that a customer will dropout is represented with a probability p.

Assumption #4: Each customer’s dropout probability is distributed across transactions according to a geometric distribution.

Geometric distributions are used to model the number of independent trials until the first success. In our case, we are interested in modeling the number of transactions a customer will make before dropping out. We can figure out the likihood a customer will drop out after making some number of transactions using this formula:

The x in the equation is the number of transactions; p is the probability of dropping out after each transaction, as discussed in the previous assumption.

If we were to plot the geometric distribution using some value for p and a range of values for x, we would see that the probability would decrease as x increases, which reflects what we would expect from a customer who makes many repeat purchases. These customers are likely to stick around much longer, than those who make only a few purchases.

Assumption #5:  Heterogeneity in dropout probabilities follow a beta distribution.

In other words, not every customer has an equal likihood of dropping out after each transaction. Some customers may stick around much longer than others. Therefore we need a way to represent the variation in dropout probabilities for each customer. That way is the beta distribution.

Beta distributions are distributions on probabilities. It can be used to model conversion rates, how likely someone will click on a Facebook ad,  the survival rate of patients with a disease, and other similar probabilities. The parameters a and b represent the number of successes and failures we expect.

The Model

The assumptions described above allow us to predict the probability that a customer will be alive after a certain time period and the number of purchases we can expect a customer to make in the future. This resource provides an excellent derivation of the equations used to calculate both.

BG/NBD In Action

An implementation of BG/NBD is provided by the lifetimes python package. The use and setup of the model is the same as that of the Pareto/NBD. The only difference of course is the instantiation of the model:

mdl = lifetimes.BetaGeoFitter()

My previous post provides a run through of the Pareto/NBD model on a sample dataset. Just replace the instatiation of the model with the code snippet above and you’re all set!

That’s all folks!

Next time I will show you another model that can be used in to predict monetary value of the customer transactions, giving us a complete picture of the customer lifetime value. Talk to you then!

If you’re looking for quick and dirty methods for calculating the lifetime value of your customer base, the first and second post in my series are just what you’re looking for. In this post we will dive into probability models and how they can provide a more sophisticated method for estimating LTV than the simple averaging methods discussed thus far.

Enter Probability Models

If we examine the purchasing activity of any group of consumers, we’ll see that there’s a natural variation in behavior between individuals. We can use probability models to take this variation into account when calculating lifetime value for any customer.

The probability model you’d want to use will depend on the business context it will be applied in. Ask yourself two questions:

1. Do my customers have a contractual relationship with my business?
2. Do customer transactions happen at specific times  or can they happen at any time?

Let’s go over these two questions real quick and explain what they mean.

Contractual vs. Non Contractual

The first question you want to ask yourself when determining the optimal model to use for your problem if customers interact with your business on a contractual basis. Companies that operate on a subscription business model fall into this category. In contractual settings, the moment in which a customer ends their patronage can be observed. This is typically indicated by a customer deciding to cancel their subscription.

Customer lifetime value for contractual engagements can be estimated using survivor based models.

As for non contractual businesses, where the end of a customer’s patronage is not known, the customer lifetime value is often modeled using exponential models.

Discrete vs. Continuous

After determining if you’re dealing with a contractual or non-contractual problem, you next want to think about how customers will be making transactions with your business.

If your customers make transactions at fixed periods of time (i.e. weekly or monthly) than we call these transactions discrete. SaaS companies that bill their customers for services every month would fall under this category.

If on the other hand a customer can make a transaction at your business at any time the transactions are considered to be continuous. Purchases made at an electronic store would fall under this category.

The Business Contexts At a Glance

Combining the answers to the two questions previously covered you’ll notice that there’s four types of business contexts that can come up. Below are the four contexts and examples of businesses that fall under each.

Non-contractual settings with continuous purchases

• Movie rentals
• Medical appointments
• Hotel stays
• Grocery purchases

Contractual settings with continuous purchases

• Costco membership
• Credit cards

Non-contractual settings with discrete purchases

• Prescription refills
• Event attendance

Contractual settings with discrete purchases

• Magazine subscriptions
• Gym membership
• Netflix, Hulu, and other streaming websites

That’s all folks!

In my next post I will discuss the Pareto/NBD model, a model that can be used to describe continuous transactions in non contractual business settings. Until next time.

A challenge faced by many companies is properly budgeting for marketing campaigns. Recently I’ve been digging into quite a bit of literature on customer lifetime value in preparation for a project I will be taking on with a client. In this post I will provide an quick overview of methods for modeling customer lifetime value for business. I will also show a simple calculation of customer lifetime value in python. Many of the methods highlighted in this post will be explored more in detail in future posts.

What is customer lifetime value?

Customer lifetime value, or CLTV, is a metric that measures the total value a customer will bring to a company over his/her lifetime. Customer lifetime value is an important metric that helps companies gauge the health of their business.

For starters, the cost of acquiring new customers is typically high for many organizations. Retaining these customers is therefore a huge interest to a company. CLTV allows companies to effectively allocate resources in order to prevent churning.

Much like the RFM technique discussed in my last post, customer lifetime value helps a company identify customers identify customers that are more valuable to the business and optimize their marketing spend. By analyzing historical purchases made by customers, CLTV allows companies to predict what kind of purchases they can expect their customers to make in the future.

How customer lifetime value is calculated?

As I mentioned at the beginning of this post, there are several methods for calculating and predicting customer lifetime value. I’ll now go through each method in order of simplest to most complex.

Method 1: Simple Average

This method involves calculating a single value that represents the average customer lifetime value for the entire customer base. Calculating customer lifetime value is pretty straight forward. You’ll need to know three things:

• The average monetary value for each transaction (AOV)
• The average customer lifespan (ACL)
• The average purchase frequency rate (APF)

The formula for customer lifetime value is as follows:

Calculating CLTV in Python

As a demonstration I will walk you through the computation of customer lifetime value using the CDNow dataset.

The CDNow dataset contains the purchase history up until the end of June 1998 of a cohort of individuals who made their first purchase at CDNow in the first quarter of 1997. The text file containing the data provides the unique identifier for the customer, the date of the transaction, the number of CDs purchased, and the dollar value of the transaction.

We’ll start by reading the text file and creating a dataframe:

with open('CDNOW_master.txt') as f:
    dataset = f.read().split("\n")

records = []
for line in dataset:
    if line == '':
        continue
    row = list(filter(lambda token: token != '', line.split(' ')))
    rec = {}
    rec['customerID'] = row[0]
    rec['purchaseDate'] = datetime.strptime(row[1], '%Y%m%d')
    rec['quantity'] = int(row[2])
    rec['price'] = float(row[3])
    records.append(rec)
transactions_df = pd.DataFrame(records)

Next we will calculate the average purchase frequency:

transactions_per_customer = transactions_df.groupby('customerID')['purchaseDate'].count()
avg_frequency = transactions_per_customer.mean()

Now for the average customer lifespan:

minmax_purchase_dates_by_customer = transactions_df.groupby('customerID')['purchaseDate'].agg(['min','max'])
customer_lifetimes = minmax_purchase_dates_by_customer.apply(lambda row: (row['max'] - row['min']).days, axis=1)
avg_lifetime = customer_lifetimes.mean()

Last but not least the average dollar value per transaction:

transactions_df['total'] = transactions_df['price'] * transactions_df['quantity']
avg_order_value = transactions_df['total'].mean()

Finally we will calculate the customer lifetime value using all the pieces:

As you can see the final number amounts to $64,906. This method, while simple can severely overestimate CLTV for many customers. Using pandas we can examine the distribution of the purchases for each customer.

avg_order_value_per_customer = transactions_df.groupby('customerID')['total'].mean()
avg_order_value_per_customer.describe()

As you can see we have some big spending customers who are making the CLTV much higher than it should be. This is even more apparent when we look at a boxplot of the same data.

Method 2: Cohort Average

This method involves dividing customers into cohorts and computing customer lifetime value for each. A cohort defined as customers who made the purchase during the same time period. Not only does this method provides a better estimation of CLTV just using a simple average, but it also allows us to study the behavior patterns of customers as a result of different marketing campaigns. I’ll cover this method more in detail in a future post.

Method 3: Predictive Probabilistic Models

The more sophisticated modeling techniques cited in literature use probability distributions to estimate the frequency, lifetime, and monetary components of the customer lifetime value equation. There are a number of methods that can be used, each ideal for specific business contexts. The Beta Geometric/Negative Binomial Distribution, Pareto/Negative Binomial Distribution, and Gamma-Gamma models are a few of the most popular probabilistic models used by companies today. Look out for future posts on this blog about all of these models.

Method 4: Machine Learning

All the approaches I highlighted utilize recency, purchase frequency, and order values for each customer to predict customer lifetime value. What if you’d like to incorporate other variables beyond these in your prediction? This is where machine learning comes in handy. Machine learning algorithms can find patterns in the data to accurately predict future customer behaviors.

That’s all folks!

The code shown in this post can be found here. Until next time!