Optimal Capacity Control

Single Resource Capacity Control

In this section we outline a capacity control policy that is routinely used in various industries (airlines, car rentals, hospitality) to make reservations towards a perishable capacity-constrained resource.

Your job is to determine the knobs that implement the policy in a reservation system where customers are arriving to making a booking. We treat the simplest possible problem of a single resource. The intuition behind the heavy math below is simple¹.

Capacity should be allocated to a request if and only if its revenue is greater than the value of the capacity required to satisfy the request. Second the value of capacity should be measured by its expected displacement cost or opportunity cost which is the expected loss in future revenue from using the capacity now rather than protecting it for future use.

The opportunity cost is captured using a value function $V (x)$ that measures the optimal expected revenue as a function of the remaining capacity $x$ . The opportunity cost is then the difference between the $V (x) - V (x - 1)$ . This simply means that estimating the value function accurately is the most important requirement in our problem.

Two class model

Let us assume that we are interested in allocating a resource of capacity $C$ , to two different classes of consumers.Each class is represented by a price that consumers in this class will need to pay for one unit of this resource. Let $p_{d}$ / $p_{f}$ and $D_{d}$ / $D_{f}$ represent the prices and demands for the discounted/full-price classes respectively. The assumptions behind our model are:

$p_{d} < p_{f}$
$D_{d}$ and $D_{f}$ are independent random variables i.e. $p (D_{d} | D_{f}) = p (D_{d})$ .

The type $d$ demand arrives before type $f$ demand. This time dependency is not important and in practice it has been shown that does not result into significant deviations from optimality.

Our aim is to find the a-priori protection level $y$ that represents the resource units that will be reserved for allocation to the type $f$ traffic.

The maximum number of resource units that can be allocated to type $d$ , i.e. the available capacity for type $d$ , will then be,

$C_{d} = C - y$

The units that can be occupied by type $d$ cannot exceed the corresponding demand for this type i.e.,

$S_{d} = min (C_{d}, D_{d})$

Therefore the maximum number of resource units that can be allocated to type $f$ , i.e. the available capacity for type $f$ , will then be,

$C_{f} = C - min (C_{d}, D_{d}) = max (y, C - D_{d})$

The units that will be occupied by type $f$ is then,

$S_{f} = min (C_{f}, D_{f})$

The expected revenue from the occupied resources will be

$E {p_{d} S_{d} + p_{f} S_{f}}$

where the expectation is taken over the random demands of the two types. If we maximize revenue over the protection level $y$ , we obtain

$V_{d} (C) = max_{0 \leq y \leq C} E {p_{d} S_{d} + p_{f} S_{f}} =$ $= max_{0 \leq y \leq C} E {p_{d} min (C - y, D_{d}) + p_{f} min (max (y, C - D_{d}), D_{f})}$

Intuitively, the ratio of the prices $r = \frac{p_{d}}{p_{f}}$ can help us determine some trends in setting the reservation level $y$ . For if the ratio is very small, i.e. $p_{f} >> p_{d}$ , then we would be inclined to reserve most of the overall capacity $C$ for type $f$ i.e $C_{f} >> C_{d}$ . If on the other hand the ratio is close to 1, then we would be inclined to reserve only a very small capacity for type $f$ i.e. $C_{f} << C_{d}$ , since we can get almost the same revenue with type $d$ .

Let us assume now that we set a fixed price ratio $r$ that is not close to these two extremes, and we then look at the remaining factors that can determine $y$ for optimal revenue. From the expressions above that factor seems to be the shape of the tail of the demand function for type $f$ i.e. $p (D_{f} > y)$ . This is because we can only have the revenue for the capacity we reserved, if the associated demand is there i.e. if $D_{f} > y$ . We can use Dynamic Programming (DP) to calculate the optimal reservation/protection limit.

Dynamic Programming Solution

To use a dynamic programming problem formulation, we need to define the variables at the beginning of the two periods involved.

The first period is defined as the point just before the type $d$ demand is observed i.e. when the available capacity is $C$ and we define the value function $V_{d} (C)$ that represents the optimal expected revenue starting with $C$ units of capacity. Apparently an upper bound of this value function is $V_{d} (C) \leq p_{f} C$ , and this is obtained when we protect all the available capacity for type $f$ .

Similarly, the second variable is the value function $V_{f} (x)$ that represents the optimal expected revenue starting with $x$ units of capacity just before observing $D_{f}$ or equivalently after we observe $D_{d}$ .

$V_{f} (x) = E {p_{f} min (x, D_{f})} = p_{f} \sum_{j = 1}^{x} p (D_{f} \geq j)$

where we have expanded $E {min (x, D)}$ using the rationale below.

{{

}} Suppose that

D

an integer quantity with

D > 0

and

x

is an integer, then,

$E {min (x, D)} = \sum_{j = 0}^{\infty} min (x, j) P r (D = j)$ $= 0 P r (D = 0) + 1 P r (D = 1) + \dots + x P r (D = x) + x P r (D = x + 1) + \dots$ $P r (D \geq 1) + P r (D \geq 2) + \dots + P r (D \geq x) = \sum_{j = 1}^{x} P r (D \geq j)$

The dynamic program formulation would involve relating $V_{d} (C)$ to $V_{f} (x)$ . If we rewrite $V_{d} (C)$ from the result of the previous section,

$V_{d} (C) = max_{0 \leq y \leq C} E {p_{d} min (C - y, D_{d})} + E {V_{f} (C_{f})} =$

$= max_{0 \leq y \leq C} E {p_{d} min (C - y, D_{d})} + E {V_{f} (max (y, C - D_{d}))} = max_{0 \leq y \leq C} W (y, C)$

The revenue difference from one unit of protection level is given by,

$Δ W (y, C) = W (y, C) - W (y - 1, C) = [p_{f} p (D_{f} \geq y) - p_{d}] p (D_{d} \geq C - y)$

{{

}}

We can prove the last equality as follows

$W (y, C) = E {p_{d} min (C - y, D_{d}) + V_{f} (max (y, C - D_{d}))}$

$W (y - 1, C) = E {p_{d} min (C - y + 1, D_{d}) + V_{f} (max (y - 1, C - D_{d}))}$

We can study two cases:

Case	Description
$D_{d} \leq C - y$	$ W(y,C) = W(y,C) - W(y-1,C)$
	$ = E {p_d D_d + V_f(C-D_d) } - E {p_d D_d + V_f(C-D_d)} $
	$ = E {0 p(D_d C-y) } =0 $
$D_{d} > C - y$	$ W(y,C) = W(y,C) - W(y-1,C)$
	$= E {p_{d} (C - y) + V_{f} (y)} - E {p_{d} (C - y + 1) + V_{f} (y - 1)}$
	$= E {V_{f} (y) - V_{f} (y - 1) - p_{d}} p (D_{d} > C - y)$

Then in all cases, the difference,

$Δ W (y, C) = W (y, C) - W (y - 1, C)$ $= E {V_{f} (y) - V_{f} (y - 1) - p_{d}} p (D_{d} > C - y)$ $= E {Δ V_{f} (y) - p_{d}} p (D_{d} > C - y)$

If we replace the marginal of the value function $V_{f} (y)$ , with $Δ V_{f} (y) = V_{f} (y) - V_{f} (y - 1) = p_{f} p (D_{f} \geq y)$ we get the final result:

$Δ W (y, C) = W (y, C) - W (y - 1, C) = E {p_{f} p (D_{f} \geq y) - p_{d}} p (D_{d} > C - y)$

The term is $Δ V_{f} (y) - p_{d}$ will start positive and then become negative i.e. the marginal value will have at least a local maximum. This can be simply shown if one replaces $y$ with $\infty$ which causes the term $p_{f} p (D_{f} \geq y) - p_{d} \to - p_{d}$ and in the other extreme, if we replace $y$ with $0$ the term $p_{f} p (D_{f} \geq y) - p_{d} \to p_{f} - p_{d}$ .

Note that the marginal value $V_{f} (x)$ itself reduces with remaining capacity $x$ . The marginal value depends on how much the tail of the type- $d$ demand exceeds the available capacity.

Calculating the Optimal Protection Limit and Maximum Revenue

The optimal $y$ , denoted by $y^{*}$ can now be found as,

$y^{*} = max {y \in N_{+} : p_{f} p (D_{f} \geq y^{*}) \geq p_{d}} = max {y \in N : p (D_{f} \geq y^{*}) \geq \frac{p_{d}}{p_{f}}}$

The optimal booking limit will then be

$b^{*} = (C - y^{*})^{+}$

The maximum possible revenue starting with capacity $C$ is given by,

$V_{d} (C) = {\begin{cases} W (y^{*}, C) & if y^{*} \leq C \\ W (C, C) & if y^{*} > C \end{cases}$

Calculating $W (y^{*}, C)$ can be done recursively. We know that,

$W (y, C) = W (y - 1, C) + E {p_{f} p (D_{f} \geq y) - p_{d}} p (D_{d} > C - y)$

To start the iteration we need $W (0, C)$ that can be written as,

$W (0, C) = p_{d} E {min (C, D_{d})} + E {V_{f} (max (0, C - D_{d}))}$

The first expectation can be written using partial expectations as,

$E {min (C, D_{d})} = \sum_{j = 1}^{C} p (D_{d} \geq j)$

The second expectation can be written as,

$E {V_{f} (max (0, C - D_{d}))} = \sum_{j = 0}^{C} V_{f} (C - j) p (D_{d} = j)$

Then, starting from $W (0, C)$ we can calculate $W (1, C)$ and iterate until all $W (y^{*}, C)$ are calculated.

The Multiple Class Model

The value function for the multi-class problem is given by,

$V_{j} (x) = \sum_{k = 0}^{x - y - 1} [p_{j} k + V_{j - 1} (x - k)] p (D_{j} = k) + [p_{j} (x - y) + V_{j - 1} (y)] p (D_{j} \geq x - y)$

The implementation in Matlab as shown in the next listing.

{{

}}

function Resource = value_function(Resource,stage,inpstruct)

% vector of all potential states (states represent the 
% remaining capacity)
x=1:inpstruct.Num_States;


% the pdf of the demand for this stage - P(D_j == x)
demand_pdf = poisspdf(x,inpstruct.mean_D(stage));

% the complementary cdf of the demand for this stage - P(D_j >= x)
demand_ccdf = 1-poisscdf(x,inpstruct.mean_D(stage));

if stage==1
    % The optimal protection level for this initial stage
    y_star_prev = 0;
else
    % The optimal protection level for this and subsequent stages
    y_star_prev = Resource{stage-1}.Protection_Level;
end
T=zeros(inpstruct.C,inpstruct.C);
% Calculate the value function V (note that we are reusing x defining 
%it as the state index)
for x=1:inpstruct.Num_States
    Resource{stage}.T(x,:)=0;
    for k=1:x-y_star_prev        
        T(x,k)= (inpstruct.price(stage) *  k + ...
        Resource{stage-1}.V(max(1,x-k)))* demand_pdf(k);
    end
    Resource{stage}.V(x) = sum(T(x,:)) + ...
            (inpstruct.price(stage)* max(0,x-y_star_prev) + ...
             Resource{stage-1}.V(max(1,min(x,y_star_prev)))) *...
                demand_ccdf(max(1,x-y_star_prev));      
end

% Calculate the marginal value of a single resource unit (DeltaV)
deltaV = diff(cat(2,0,Resource{stage}.V));
Resource{stage}.deltaV= deltaV;
% find the point of where the marginal value is larger than the price of
% the next stage 
indeces = find(deltaV > inpstruct.price(stage+1));
Resource{stage}.Protection_Level = max(indeces);

A number of calls equal to the number of stages are made. In each call, the corresponding results are stored for usage at the next stage.

For a problem with available initial capacity $C = 100$ and 2 demand classes shown below:

Class | Price | Demand Distribution | Optimal Protection Levels |
—– | —– | ——————- | ————————- ||
1 | 1000 | Poisson(40) | 41 |
2 | 450 | Poisson(15) | 100 |

The marginal value as a function of the remaining resources.

marginal-value-multi-class The marginal value as a function of the remaining resources

The optimal protection limits are shown below.

A further example shows the straightforward application of the same DP solution for more classes. The table below outlines the results for an available initial capacity $C = 50$ and 4 demand classes.

Class | Price | Demand Distribution | Optimal Protection Levels |
—– | —– | ——————- | ————————- ||
1 | 100 | Poisson(10) | 6 |
2 | 90 | Poisson(15) | 20 |
3 | 80 | Poisson(25) | 44 |
4 | 70 | Poisson(15) | 50 |

marginal-value-multi-class The marginal value as a function of the remaining resources for the three stages of the problem

Its noteworthy to highlight the decreasing marginal value of capacity as the remaining capacity increases. This is intuitive as the more capacity we have remaining the less a unit of this capacity should be worth. Also, it is interesting to highlight the increasing value of marginal capacity with increasing stage. This is also intuitive as the earlier we are in stage i.e. the more time we have until we reach the final stage 1, the more a unit of capacity is worth if we allocate it at that stage.

The optimal protection limits are shown below.

References

[1] K. Talluri and G Van Ryzin, ‘The Theory and Practice of Revenue Management’, Springer, 2004.

Footnotes

It is probably the most essential first step as computer scientists to spend time understanding a domain / problem space and acquire such intuition as to how the system works.↩︎