Item Aggregation and Column Generation for Online-Retail ... · Annie I. Chen Marshall School of Business, University of Southern California, Los Angeles, CA 90089, [email protected]

Submitted to Operations Research

manuscript (Please, provide the manuscript number!)

Authors are encouraged to submit new papers to INFORMS journals by means of

a style file template, which includes the journal title. However, use of a template

does not certify that the paper has been accepted for publication in the named jour-

nal. INFORMS journal templates are for the exclusive purpose of submitting to an

INFORMS journal and should not be used to distribute the papers in print or online

or to submit the papers to another publication.

Item Aggregation and Column Generation for

Online-Retail Inventory Placement

Annie I. ChenMarshall School of Business, University of Southern California, Los Angeles, CA 90089, [email protected]

Stephen C. GravesSloan School of Management, Massachusetts Institute of Technology, Cambridge, MA 02139, [email protected]

This paper studies the problem of choosing in which fulfillment centers to place each item for an online

retailer, with an objective of minimizing relevant costs over a planning period. We formulate the problem as

a mixed-integer program containing thousands of items, each with deterministic demand in multiple regions,

and dozens of fulfillment centers, each with a capacity constraint. The large number of binary variables

makes the problem difficult to solve with off-the-shelf commercial software. We propose a large-scale solution

framework that uses item aggregation to approximate the problem in a column-based form, and then applies

column generation to solve it efficiently. We demonstrate the effectiveness of the solution framework with

realistic examples with 1,000,000 items, and show that it significantly outperforms a sequential placement

heuristic. We also extend the solution framework to placement problems with sparsity constraints, either on

the number of fulfillment centers allowed per item, or on the number of items allowed per fulfillment center.

Key words : online retail; inventory placement; column generation; aggregation

History :

1

Chen and Graves: Item Aggregation and Column Generation for Online-Retail Inventory Placement

2 Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)

1. Introduction

1.1. Background

Online retail is a business model of rapid growth. In the United States, online retail accounted for

8.1% of total retail sales in 2016, which increased from 7.3% in 2015 and continues a steadily rising

trend (United States Census Bureau 2017). Similar trends are observed around the world.

In online retail, inventory is held in facilities called fulfillment centers. An important feature of

online retail is that items can be shipped to customers from any fulfillment center, near or far,

at different costs. This is distinct from the traditional retail model, in which brick-and-mortar

stores serve independent regions of customers who live nearby. Online retail shipping provides

the flexibility to achieve lower costs and higher service levels. However, the resulting inventory

management problem involves the joint optimization of multiple fulfillment centers, which is large

in scale and requires new optimization paradigms.

We can categorize online-retail inventory management decisions as strategic, tactical, or opera-

tional, depending on the planning horizon:

• Strategic decisions have a long-term impact, and usually involve substantial capital invest-

ments or contractual agreements that cannot be changed easily. One example is network design,

namely, where to build (or add) fulfillment centers, and with what storage and throughput capac-

ities. Another example is sourcing, i.e., what items to carry, from which vendors to buy, and the

terms of procurement such as replenishment frequency, lead time, and minimum order quantities.

• Tactical decisions are typically made more frequently than strategic decisions, say every few

months or on a seasonal basis. These decisions may be periodically re-evaluated to adapt to the

evolving retail landscape. Examples include the placement decision that determines in which ful-

fillment centers to store each item, and the replenishment decision that determines how much

inventory to order for each item.

• Operational decisions have to do with the day-to-day deployment of inventory. Such decisions

often follow pre-determined policies that enable quick, real-time implementation. Examples include


Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!) 3

fulfillment policies that determine which inventory units to use for fulfilling customer demand, and

transshipment policies on when and how much inventory to transfer between fulfillment centers in

order to rebalance the system.

All of these decisions are interdependent. Yet due to organizational realities and complexities,

online retailers often consider these decisions separately in a hierarchical fashion.

This paper focuses on the tactical decision of inventory placement. The goal is to determine

a cost-minimizing placement plan for each item, while satisfying customer demand requirements

and fulfillment center capacity constraints. A placement plan is a selected subset of fulfillment

centers in which to place each item, along with a rough estimate of the inventory held in each

selected fulfillment center. The objective function includes two types of costs: the variable cost,

which is proportional to the volume of shipments from each fulfillment center to each customer

region, and the fixed cost, which reflects the overhead of holding an item at a fulfillment center.

The former primarily consists of the outbound shipping cost, but can also include the per-item

inbound shipping and receiving cost, as well as the handling cost of picking and packing items

before shipment. The latter may represent actual monetary costs, such as a flat-rate inbound

delivery cost charged by upstream suppliers for every additional fulfillment center they deliver to,

or internal costs incurred to split and distribute a single supplier shipment to multiple fulfillment

centers. In addition, the fixed costs can also act as a virtual modeling device, tuned to induce the

desired number of fulfillment centers holding each item. This can prevent inventory from being split

across too many fulfillment centers in fractional quantities, which may be unrealistic especially for

low-demand items with very few inventory units.

The inventory placement problem can be difficult to solve because of the large number of items,

the fixed costs, and the fulfillment center capacity constraints. To focus on these challenges, we

make the following assumptions about the other inventory management decisions. First, we assume

that fulfillment center fixed costs and capacities have been determined by the network design and

sourcing decisions. We assume deterministic demand and omit the dynamics of inventory replen-

ishment, since the replenishment decision is made after the placement decision. For fulfillment, we



approximate the shipping cost with a single-period deterministic transportation problem. We also

assume that there is no transshipment between fulfillment centers.

Under these assumptions, we model the online-retail inventory placement decision as a mixed-

integer program, with one binary variable for each pair of item and fulfillment center. The formu-

lation can be viewed as a generalization of the facility location problem, and a special case of the

multicommodity capacitated fixed-charge network flow problem. There are many existing methods

for these classes of problems, but most of them are not designed to work efficiently with a large

number of items, which can range from hundreds of thousands to many millions in online retail.

We propose a large-scale solution framework that not only overcomes the large number of

items, but in fact leverages it, turning the notorious “curse of dimensionality” into a blessing. Our

approach is to integrate two techniques: item aggregation and column generation. Item aggregation

groups items into bundles that are restricted to the same placement plan. This reduces the number

of decision variables, and also allows us to approximate the problem by reformulating it in terms of

the aggregate items. We then solve the reformulation efficiently with column generation, in which

the master problem contains capacity constraints and the column generation subproblems account

for fixed costs.

The paper is organized as follows. The remainder of this section provides a review of related

models and methods. In Section 2, the online-retail inventory placement problem is formulated as

a mixed-integer program, and various modeling considerations are discussed. Section 3 presents

a four-step large-scale solution framework that integrates the techniques of item aggregation and

column generation. Section 4 demonstrates the effectiveness of the solution framework via empirical

analysis of a realistic numerical example, and also compares it with a sequential heuristic that

places the items one at a time. Section 5 extends the solution framework to the setting in which

a sparsity constraint is imposed on each item to limit the total number of fulfillment centers in

which it can be placed. Finally, Section 6 concludes with remarks on future directions.



1.2. Related work

Related decisions in online retail. The intent of our work is most similar to that of Xu (2005),

who studies the problem of allocating inventory across fulfillment centers for low-demand items,

and characterizes the outbound-cost-minimizing allocation plan for a small problem (placing 2

units of the same item in 2 or 3 fulfillment centers), under stochastic demand. In contrast, we

take a different modeling approach by decomposing the problem into a deterministic placement

problem and a stochastic replenishment problem, the former of which is the topic of this paper, and

the latter of which can be solved subsequently (see Chen 2017). This maintains tractability while

enabling us to account for large, realistic problem instances, as well as more general conditions

such as capacity constraints and fulfillment center fixed costs.

For online-retail inventory replenishment, Acimovic (2012) and Acimovic and Graves (2017)

consider the case with identical replenishment lead times, periodic review, and lost sales. They

propose the projected base-stock policy, a heuristic that outperforms the status quo base-stock

policy in its ability to mitigate persistent inventory imbalance and reduce outbound shipping costs.

Chen (2017) further assumes non-identical lead times, and uses discrete optimization via simulation

to find low-cost replenishment policies.

Regarding the operational decisions in online retail, much of the research interest has been

focused on inventory fulfillment. Acimovic (2012) and Acimovic and Graves (2015) show that the

myopic fulfillment policy (i.e., always shipping from the cheapest fulfillment center) is not optimal.

They propose a computationally-tractable heuristic fulfillment policy, and demonstrate that it

performs well in practice. Xu et al. (2009) focus on minimizing the number of split shipments for

multi-item orders, and propose a heuristic that dynamically readjusts the assignment of customer

orders to fulfillment centers. Other notable recent works include Torabi et al. (2015), who use

Benders decomposition to jointly optimize the fulfillment and transshipment decisions, and Lei

et al. (2016), who study the benefit of jointly optimizing the fulfillment and pricing decisions.

Regarding the strategic decisions, Agatz et al. (2008) review network design problems in online

retail, and Swaminathan and Tayur (2003) review sourcing problems. In recent years, new types of



facilities have emerged that add to the complexity of online-retail network design. These include

sortation centers where items from different fulfillment centers are consolidated, so as to reduce the

number of shipments (MWPVL International Inc. 2014); “lockers” where customers pick up their

items, which can reduce the cost of last-mile delivery; and specialized facilities that are dedicated

to the processing of returns. Business models such as “Fulfilled By Amazon” have also blurred the

lines between retailer, supplier and platform provider. These advances pose new challenges in the

management of inventory, contracts, and many other aspects of online retail.

This paper focuses on the online channel only. The omni-channel setting, which integrates the

online and traditional retail channels, is a topic of increasing importance, and is a promising area

for extending the large-scale solution framework we propose. For surveys on omni-channel retail

problems, see Agatz et al. (2008) and Hubner et al. (2016).

Related models and methods. Like classical facility location and network flow problems, the

online-retail inventory placement problem features multiple commodities, fixed costs, and capacity

constraints. If we omit capacity constraints, the problem separates by item and reduces to the simple

plant location problem for each item, which has been shown to be NP-hard (Krarup and Pruzan

1983). With capacity constraints, the placement problem is a generalization of the capacitated

facility location problem, reviewed by Sridharan (1995). The placement problem can also be viewed

as a special case of the warehouse location problem of Pirkul and Jayaraman (1998), a three-echelon

facility location problem, which in turn is a special case of the multi-commodity fixed-charge network

flow problem, surveyed by Gendron (2011).

Existing solution methods for facility location and network flow problems can roughly be divided

into three categories: (1) variants of branch-and-bound, e.g., Gendron (2011); (2) Benders decom-

position, e.g., Costa et al. (2012); and (3) heuristics, e.g., Crainic et al. (2000), Katayama et al.

(2009), Rodrıguez-Martın and Salazar-Gonzalez (2010), and Hewitt et al. (2010). In most mod-

els, the fixed cost is charged for the use of each facility or each arc, regardless of the number of

commodities (items) using it, and so the number of binary variables is independent of the number



of items. As a result, none of the aforementioned methods are specifically designed to handle the

large number of commodity-facility combinations, which is one of our primary challenges.

Our large-scale solution framework is a heuristic that relies on the integration of item aggregation

and column generation. Next, we briefly review some related work on these two techniques.

Existing literature for item aggregation focuses primarily on its benefit of reducing the number

of decision variables. In the context of production planning, Hax and Meal (1975) introduce the

framework of hierarchical production planning, in which items with a common production setup

are aggregated as a family for scheduling, and families with similar seasonal demand patterns and

production rates are aggregated as a type for capacity planning; see also Bitran et al. (1981), Graves

(1982) and Bitran and Tirupati (1993) for important extensions. In the context of mathemati-

cal programming, aggregation and disaggregation have been widely recognized as a technique for

reducing computational complexity; see Francis (1985), Rogers et al. (1991), and Litvinchev and

Tsurkov (2013) for surveys. For linear programs, much of the research work focuses on bounding

the error or loss as a result of aggregation, e.g., Zipkin (1980b) and Zipkin (1980a). For integer

programs, aggregation has been relatively under-explored, and our work contributes to this area.

Closest in spirit to our work is Hallefjord and Storøy (1990), who derive bounds on an integer pro-

gram by solving a relaxed problem with aggregated binary variables, stating that, “If sufficiently

many columns are aggregated, relaxation of the integer requirements is justified.” However, their

approach does not extend to the more complex problem setting we face.

Column generation has been applied to multicommodity fixed-charge network flow, for example,

in the heuristics of Crainic et al. (2000) and Katayama et al. (2009), in which columns correspond to

alternative flow paths. In the large-scale branch-and-price-and-cut method of Gendron and Larose

(2014), column generation is used for progressively expanding the set of active flow variables, which

is combined with row generation for cutting planes. These definitions of columns are all distinct

from ours. Our definition of columns is closest to that of Klose and Drexl (2005), in which columns

correspond to integer solutions of the capacitated facility location problem. However, their method



involves a rounding heuristic for processing the convex combination of columns. In contrast, a

convex combination of columns is readily interpretable in our framework, as it represents the

collective placement plan of aggregate items.

In summary, to the best of our knowledge, this paper is the first that distinguishes inventory

placement as a separate decision in online retail, and that addresses the large number of items with

a solution framework that integrates item aggregation and column generation.

2. Problem formulation

2.1. MIP model

Consider an online retailer that sells a set of items I, operates a set of fulfillment centers N , and

serves geographically segmented customers represented by a finite set of customer regions R. For

a given planning period (e.g., one month), for every i P I, n PN and r PR, we assume that the

following parameters are provided as input:

• bn, the throughput capacity of fulfillment center n for the entire planning period;

• cinr, the unit fulfillment cost (primarily the outbound shipping cost in our case) of item i from

fulfillment center n to region r;

• f in, the fixed cost of carrying any amount of item i in fulfillment center n during the planning

period;

• dir, the demand of item i in region r for the planning period. Moreover, let di �°rPR d

ir denote

the total demand across all regions.

Let the decision variables be

• xinr P r0,1s, the fraction of item i demand in region r that is served by fulfillment center n;

• yin P t0,1u, whether (yin � 1) or not (yin � 0) fulfillment center n carries item i.

We formulate the online-retail inventory placement problem as follows:

minx,y

¸iPI

¸nPN

¸rPR

cinrdirx

inr�

¸iPI

¸nPN

f inyin (P1)

subject to¸nPN

xinr � 1 @r PR,@i P I, (1)



¸iPI

¸rPR

dirxinr ¤ bn @n PN , (2)

¸rPR

dirxinr ¤ d

iyin @n PN ,@i P I, (3)

xinr ¥ 0 @n PN ,@r PR,@i P I,

yin P t0,1u @n PN ,@i P I.

The objective function is the sum of shipping and fixed costs over the entire planning period. (1)

is the set of demand satisfaction constraints; (2) is the set of capacity constraints; and (3) ensures

that for every given i and n, if xinr ¡ 0 for any r PR, then yin � 1.

2.2. Model extensions

Different classes of customers. (P1) directly captures multiple customer classes, which is com-

mon in online retail. For example, each class of customers may correspond to a different delivery

window. LetM be the set of customer classes, and let Rm be the customer regions for class m PM.

Then we can take R��mPMRm to be the set of customer regions in (P1). Under this definition,

dir and cinr reflect the demand and shipping cost, respectively, for customers of class m PM and

in region r PRm. If it is infeasible to serve customers in r PR using fulfillment center n PN (for

example, if the distance is too far for shipments to arrive in time), then we can set cinr to infinity,

or equivalently, remove the variable xinr.

Different types of capacity constraints. While (2) is most easily understood as throughput

capacity constraints, it can also represent other types of constraints. The only requirement is that

the capacity bn, demand dir, and shipping cost cinr should all be given in consistent units. For

example, to express storage capacity constraints with (2), we can let bn be the total available

storage space at fulfillment center n, dir be the average storage space required for item i demand

from region r, and cinr be the corresponding shipping cost (dollars per unit storage space).



Alternatively, we can generalize our model and solution framework to incorporate multiple sets

of linear constraints of xinr. For example, if we wish to capture storage capacity constraints while

keeping (2) as throughput capacity constraints, we can add the following expressions,

¸iPI

¸rPR

vidirxinr ¤ vn @n PN ,

where the input parameter vi is the storage space required per unit of item i demand, and vn is the

total available storage space at fulfillment center n. This formulation is consistent with the common

practice of expressing the inventory requirement as a multiple of the demand rate, through the

definition of inventory turnover. For example, if the planning period is one month and we have an

inventory turnover of 6 times per year, i.e., we hold two months of inventory on average, then we

can set vi to be 2 times the unit storage volume of the inventory.

3. A large-scale solution framework

Directly solving (P1) appears impractical, even with a state-of-the-art commercial solver. In our

preliminary experiments on a personal laptop, a numerical example with |N | � 88, |R| � 99 and

|I| � 1000 results in an optimality gap of around 6-7% after 5 hours, and the gap does not improve

much after an additional 5 hours. Detailed results can be found in Chen (2017). For problems with

more items, even constructing the formulation drains the available memory on a personal laptop.

To overcome these challenges, we propose a large-scale solution framework that integrates two

techniques: item aggregation and column generation. It consists of four steps, labeled A to D:

Aggregation, Bundle characterization, C olumn-based reformulation, and D isaggregation. In Step

A, we aggregate similar items into bundles that adopt the same placement plan. In Step B, we

characterize the demand and cost parameters of the bundles, and formulate a placement problem

for bundles. In Step C, we derive a column-based reformulation of the problem, in which a column

represents a placement plan for a bundle, and we solve the reformulation using column generation.

In Step D, we disaggregate the column-based solution for each bundle into placement plans for

individual items. Below, we give a detailed description of each step, followed by a discussion on

the computational advantages of this solution framework.



3.1. Aggregation

Item aggregation is the act of partitioning the set of items. We denote the partition as I ��jPJ Ij,

where each j PJ is called a bundle. All items within a bundle will have the same placement plan.

The goal of aggregation is to group together the items for which similar placement plans are

desirable. Thus, we expect each bundle to contain items that are “similar,” in terms of the geo-

graphical distribution of their demand, in terms of their holding and shipping cost parameters, and

possibly in terms of other physical characteristics that may affect their storage and handling. In

addition, the appropriate aggregation may depend on several other considerations, such as:

• The business context: In many businesses, items are often already organized in a hierarchical

or categorical manner that lends itself naturally to some partition.

• Additional data about the items: If there is additional data (e.g., historical customer orders)

from which we could identify items that are likely to be purchased together, then it may be a good

idea to aggregate those items in the same bundle, so that they are more easily shipped from the

same fulfillment center.

• Computing resources: As we shall see shortly, the size and characteristics of bundles affect

the complexity of the large-scale solution framework, and should be chosen to achieve the desired

trade-off between computational effort and solution quality. For example, if parallel computing

resources are available, we may be able to accommodate more bundles.

Given these considerations, the aggregation step may involve an optimization problem to obtain

the best partitioning of items according to some measure. For instance, we may wish to aggre-

gate similar items together by minimizing some distance measure between the items in the same

bundle, where distance can be defined in terms of item characteristics and category, likelihood of

joint purchase, spatial or seasonal demand patterns, etc. For certain distance measures, clustering

algorithms such as K-means can be efficient heuristics that produce good partitions without solving

a full-fledged optimization problem.



3.2. Bundle characterization

After aggregation, we restrict items in the same bundle to take on identical decision variables values

in (P1). This corresponds to adding the bundle variables xjnr, yjn, and the constraints

xinr � xjnr, yin � y

jn, for every pi, jq P I �J such that i P Ij. (4)

This results in the following formulation of the placement problem for bundles:

minx,y

¸jPJ

¸nPN

¸rPR

cjnrdjrx

jnr�

¸jPJ

¸nPN

f jnyjn (P2)

subject to¸nPN

xjnr � 1 @r PR,@j PJ ,

¸jPJ

¸rPR

djrxjnr ¤ bn @n PN ,

¸rPR

djrxjnr ¤ d

jyjn @n PN ,@j PJ ,

xjnr ¥ 0 @n PN ,@r PR,@j PJ ,

yjn P t0,1u @n PN ,@j PJ .

It is straightforward to verify that for every bundle j PJ , the demand and cost parameters are

djr �¸iPIj

dir, dj �¸iPIj

di, cjnr �

°iPIj

cinrdir°

iPIjdir

, f jn �¸iPIj

f in. (5)

The optimal solution of (P2) is an upper bound for the optimal solution of (P1), because the

former is obtained by adding the constraints (4) to the latter.

3.3. Column-based reformulation

We now derive a column-based reformulation of (P2). For simplicity, let xj � pxjnrqnPN ,rPR and

yj � pyjnqnPN denote the decision variables of bundle j.

A column for a bundle j PJ corresponds to a placement plan in which each customer region is

fully served by a single fulfillment center, i.e., the xjnr decision variables of (P2) are either 0 or 1.

For every bundle j PJ , let

Xj �

#pxj,yjq

�� ¸nPN

xjnr � 1,¸rPR

djrxjnr ¤ d

jyjn, xjnr, y

jn P t0,1u, @n PN ,@r PR

+



be the set of all such integral placement plans.

To develop the column-based reformulation, we enumerate the placement plans in the set Xj

and label them with the index set Kj. That is, we denote the k-th placement plan of bundle j

by xjpkq � pxjnrpkqqnPN ,rPR and yjpkq � pyjnpkqqnPN , where k PKj and pxjpkq,yjpkqq PXj. We then

associate a column with each of these placement plans.

Under this definition, the cost of a column (or placement plan) k PKj, j PJ is given by

cjk �¸nPN

¸rPR

cjnrdjrx

jnrpkq�

¸nPN

f jnyjnpkq,

and the column’s capacity usage at fulfillment center n is the amount of bundle j demand served

by that fulfillment center, given by

ujkn �¸rPR

djrxjnrpkq, @n PN .

Consider the following column-based reformulation of (P2):

minλ

¸jPJ

¸kPKj

cjkλjk (P3)

subject to¸jPJ

¸kPKj

ujknλjk ¤ bn @n PN ,

¸kPKj

λjk � 1 @j PJ ,

0¤ λjk ¤ 1 @k PKj,@j PJ .

The decision variable λjk is the weight of column k PKj, in the convex combination of columns that

form the placement plan for bundle j PJ .

(P3) is an approximation of (P2) with an equivalent solution space and a different objective

function. We show in the online companion that every solution of (P2) can be converted into a

solution of (P3) (see Theorem EC.1), and vice versa (Theorem EC.2), according to the following

relationships:

xjnr �¸kPKj

xjnrpkqλjk, @n PN , r PR, j PJ , (6)

yjn �maxtyjnpkq | k PKj, λjk ¡ 0u, @n PN , j PJ . (7)



Although the feasible regions are equivalent, the objective cost functions of (P2) and (P3) are

different. For equivalent solutions that satisfy (6) and (7), the objective cost of (P3) is in fact a

lower bound on the objective cost of (P2), i.e.,

¸jPJ

¸kPKj

cjkλjk ¤

¸jPJ

¸nPN

¸rPR

cjnrdjrx

jnr�

¸jPJ

¸nPN

f jnyjn.

To see this, note that the terms on both sides involving xjnr and xjnrpkq are identical by definition.

Thus, it suffices to show that

¸jPJ

¸kPKj

λjk¸nPN

f jnyjnpkq ¤

¸jPJ

¸nPN

f jnyjn.

This inequality holds due to the fact that°kPKj

λjkyjnpkq is a convex combination of 0’s and 1’s,

and is no greater than maxtyjnpkq | k P Kj, λjk ¡ 0u, which is the definition of yknr given by (7).

Nevertheless, in our numerical experiments, we find that the objective functions are similar enough

that a low-cost solution of (P3) is often a low-cost solution of (P2).

The main advantage of (P3) over (P2) is that the former is a linear program that can be solved

at scale using column generation. To do so, we decompose (P3) into a restricted master problem

that contains a restricted subset of columns, and a collection of column generation subproblems

that identify columns with the potential to improve the objective cost. We proceed by iteratively

adding columns to the master problem until the optimal solution is found.

A detailed description of the column generation method for solving (P3) is given in Algorithm

3.1. Below, we develop the mathematical formulations of the restricted master problem and the

column generation subproblems.

Restricted master problem. The restricted master problem has the same formulation as (P3)

except that, for every bundle j P J , the set of columns Kj is replaced by the restricted subset

Ktj �Kj in the t-th iteration:

minλ

¸jPJ

¸kPKt

j

cjkλjk (RMP)



Algorithm 3.1 Stage C: Solving the column-based reformulation with column generation

1: Initialize K0j for every j PJ according to (10)

2: tÐ 03: while termination criteria not met do4: Solve the restricted master problem (RMP)5: ppnqnPN Ð dual variables of (8)6: pqjqjPJ Ð dual variables of (9)7: addedÐ False8: for all j PJ do9: Solve the column generation subproblem (CGj)

10: vÐ objective value of (CGj)11: k�Ð optimal solution of (CGj) as column index12: if v 0 then � Found column with negative reduced cost13: Kt�1

j �Ktj�tk�u

14: addedÐ True15: end if16: end for17: if added� False then � All columns have non-negative reduced costs18: Go to Line 2219: end if20: tÐ t� 121: end while22: return Optimal column solution of (P3)

subject to¸jPJ

¸kPKt

j

ujknλjk ¤ bn @n PN , (8)

¸kPKt

j

λjk � 1 @j PJ , (9)

0¤ λjk ¤ 1 @k PKtj,@j PJ .

We set the initial subset for (RMP) as

K0j �

¤n1PN

k PKj | xjn1rpkq � y

jn1pkq � 1 and xjnrpkq � yjnpkq � 0 @n� n1

(, @j PJ , (10)

i.e., the set of columns in which the bundle uses only one fulfillment center. An initial feasible

solution can be obtained by setting λjk �bn1°

nPN bnif column k PK0

j uses n1 PN , and 0 otherwise.

Column generation subproblems. The column generation subproblem for bundle j PJ is

minxj ,yj

¸nPN

¸rPR

pcjnr� pnqdjrx

jnrpkq�

¸nPN

f jnyjnpkq� qj (CGj)

subject to pxj,yjq PXj,



where tpnunPN and tqjujPJ are the dual variables of constraints (8) and (9), respectively.

This problem finds the column k P Kj with the most negative reduced cost, defined as cjk �°nPN pnu

jk,n� qj, which is equivalent to the objective of (CGj). In iteration t, if a column k� with

a negative reduced cost is found by (CGj) for some j P J , it is added to the restricted master

problem, i.e., Kt�1j �Ktj

�tk�u, and the algorithm continues to iteration t� 1. If no such columns

can be found for any bundle j P J , then the algorithm terminates with the optimal solution for

(P3). It is also possible to terminate the algorithm in any iteration (Algorithm 3.1, line 3) and

obtain a feasible solution that is not necessarily optimal.

3.4. Disaggregation

We propose a disaggregation approach that handles each bundle independently. Given a bundle

j P J , let�λjk�kPKj

denote the solution of (RMP) obtained in the previous step. We construct a

placement plan for every item i P Ij based on the set of columns K�j � tk PKj | λjk ¡ 0u used in the

solution of (RMP).

The disaggregated placement plans of items must satisfy the constraints of (P1). To achieve this,

we ensure that the items do not use more capacity than the bundle. Let

ujn �¸kPK�

j

ujknλjk�

dj°jPJ d

j∆bn, j PJ , n PN

be the amount of capacity allocated to each bundle at each fulfillment center. The first term is the

capacity that is actually consumed by the bundle in the solution of (P3), and the second term is

the additional capacity that we allocate to the bundle in proportion to its total demand, where

∆bn � bn�¸jPJ

¸kPK�

j

ujknλjk, @n PN ,

is the amount of unused fulfillment center capacity, i.e., the slack in constraint (8).

Given K�j and pujnqnPN , we can formulate the following bundle-to-item disaggregation problem

for bundle j PJ :

minλi,xi,yi

¸iPIj

¸nPN

¸rPR

cinrdirx

inr�

¸iPIj

¸nPN

f inyin (Dj)



subject to xinr �¸kPK�

j

xjnrpkqλik, @n PN ,@r PR,@i P Ij,

¸iPIj

¸rPR

dirxinr ¤ u

jn @n PN ,

¸rPR

dirxinr ¤ d

iyin @n PN ,@i P Ij,

¸kPK�

j

λik � 1 @i P Ij,

λik ¥ 0 @i P Ij,@k PK�j ,

yin P t0,1u @n PN ,@i P Ij.

In this problem, the decision variables λik indicate the proportion of item i using placement plan

k. The auxiliary variables xinr and yin, as well as the constraints, all have the same definitions as

in (P1).

This disaggregation approach has two advantages. First, it produces a low-cost solution for the

items, as (Dj) accurately captures the fixed cost of the convex combination of columns. Secondly, it

is computationally tractable, since it only considers convex combinations of the bundle’s placement

plans, rather than the entire solution space of the original problem (P1). The problem is easy

to solve when |K�j | is small, which will be the case when the number of bundles is appropriately

chosen, as we show empirically in the next section. Moreover, when |K�j | � 1, i.e., if the bundle

only uses one column, then the disaggregation problem is trivial.

We remark that the disaggregation problem is always feasible. In particular, a feasible solu-

tion can be obtained by taking λik � λjk for all i P Ij and k P Kj, for all j P J . In our numerical

experiments, we set this as the initial solution when solving (Dj).

3.5. Computational advantages of the large-scale solution scheme

The proposed large-scale solution framework is much more computationally tractable than solving

the original mixed-integer program. Item aggregation reduces the dimensionality of the problem,



and also allows us to work with the convex combinations of column. Column generation solves the

approximate column-based reformulation efficiently. In addition, the solution framework has two

other computational advantages, namely, the options of parallelization and early termination.

Steps B, C and D are all parallelizable in the sense that the problems of bundle characterization

(5), column generation (CGj), and disaggregation (Dj) can all be computed independently for

each bundle. These are the most computationally intensive parts of the solution framework, as Step

A can be pre-computed offline, and the restricted master problem (RMP) in Step C is a linear

program that is relatively easy to solve. Therefore, if we have p parallel processors, we can speed

up the computation roughly by the same factor p, by dividing the bundles across the processors.

Steps C and D can also be terminated early before optimality is reached, which is a desirable

feature when there is limited computing time and resources. In Step C, early termination can

be achieved by setting a termination criteria, such as: the percentage of cost improvement, the

number of columns being added, and the total reduced cost of newly added columns in the most

recent iteration. Empirically (see Chen 2017), we have found all of these measures to decrease

in magnitude as the solution approaches optimality, i.e., less and less progress is made in the

latter iterations. In Step D, we solve the disaggregation problem with a commercial solver, which

often finds a good solution in a relatively short time, but then takes much longer to make small

improvements or to prove optimality. Such solvers usually offer configurations to terminate early.

4. Empirical analysis

We apply our large-scale solution framework to a placement problem with one million items. Our

solution framework produces a near-optimal solution in a few hours, and significantly outperforms

a sequential placement heuristic that places the items one at a time.

All numerical experiments are conducted on machines with a single processor of 2.0 GHz CPU

each, 32 GB RAM, and running the CentOS version 6 operating system. Our test programs are

written and executed in Python, version 2.7.5, and its interface to Gurobi Optimizer, version 7.0.1.

The input data and related details can be found on the first author’s webpage. For additional

numerical studies that inform the design of these experiments, see Chen (2017).



Figure 1 Fulfillment centers and customer regions in our numerical example.

Note. Red triangles indicate locations of the 88 fulfillment centers, with size proportional to square footage. Gray

dots indicate locations of the 98 customer regions, with proportional to population.

4.1. Numerical example

Fulfillment centers. We create a realistic network based on the locations and capacities of

Amazon’s fulfillment centers in the United States, taken from an unofficial public dataset (MWPVL

International Inc. 2015). There were |N | � 88 fulfillment centers as of December 2015. The location

of a fulfillment center is given by the longitude and latitude coordinates associated with its ZIP

code.

The fulfillment center capacities tbnunPN are computed by setting the total capacity to be 1%

higher than the total demand (described below) of all the items; that is, we assume that°N

n�1 bn

is 1.01 times the the total demand. The total capacity is distributed across the fulfillment centers

in proportion to its square footage given in the public dataset.

Although we are aware that some fulfillment centers are dedicated to specific product categories,

we make no such distinctions in our example, and simply allow every fulfillment center to carry all

kinds of items.

Customer regions. The customer regions are created from 2010 US Census data (United States

Census Bureau 2010). The raw data contains 3221 counties, which we group into |R| � 98 regions.

Each region has a population and a location given by longitude and latitude coordinates.



Shipping costs. The shipping cost structure is modeled after the two-day shipping services of

UPS (United Parcel Service of America, Inc. 2016). For a given UPS shipment mode (e.g., ground

or two-day air), we fit the publicly available shipping cost data to the following linear model:

UPSpw, lq � a3wl� a2l� a1w� a0,

where w is the weight of the package (pounds), and l is the the distance on the sphere of the earth

between the origin and the destination (miles). The scalars a3, a2, a1 and a0 are calculated from

the data using linear least squares. The fitted shipping cost functions are given by

UPSGroundpw, lq � 0.247847wl� 0.227878l� 0.132063w� 7.553833,

UPS2DayAirpw, lq � 1.37674wl� 4.02487l� 0.75604w� 11.10890,

with R2 � 0.9735 for UPSGroundpw, lq and R2 � 0.9682 for UPS2DayAirpw, lq.

Moreover, to capture the nonlinearity of shipping costs as a function of distance, we assume

that ground shipment is used for distances up to 1,000 miles; otherwise, second-day air shipment

is used. Thus, the shipping cost for item i with weight wi is computed by

cinr �

$'''''&'''''%UPSGroundpw

i, lnrq, if lnr ¤ 1000,

UPS2DayAirpwi, lnrq, otherwise,

(11)

where lnr is the distance from fulfillment center n to customer region r.

Random item generation. We generate 10 instances of |I| � 1,000,000 items each, by randomly

sampling the following three attributes:

• wi: the weight (in pounds), drawn uniformly at random from the interval [1, 35].

• di: the expected total demand in the planning period, drawn uniformly from the [1, 100]

interval.

• αi: the geographical distribution parameter, drawn uniformly at random from the [0,1] interval.



The weight is an input in the calculation of shipping cost parameters (11). The latter two

attributes determine the regional demand dir as follows. Let pr denote the population of region

r PR, and let mr denote the longitude of region r PR. Let m�minrPRmr and m�maxrPRmr be

the longitude of the western-most and eastern-most regions, respectively. For an item i P I, define

the auxiliary parameter

ar � αi �mr�m

m�m�p1�αiq �

�1�

mr�m

m�m

,

and let the regional demand be

dir � di �

prar°R

r�1 prar, r PR.

In other words, the regional demand of an item is proportional to its population pr and to the

auxiliary parameter ar P r0,1s, which is controlled by αi. If αi is close to 1, then ar is close to mr�m

m�m

for every r PR, which means that demand is higher in regions closer to the east coast. Similarly,

for an item with αi close to 0, demand is higher in regions closer to the west coast. When αi � 0.5,

we have ar � 0.5 for all r PR, and the regional demand depends solely on the population. Thus,

by sampling αi at random, we capture demand patterns that are biased at various levels toward

either coast. While demand patterns in reality may be far more complex, the αi attribute provides

a way to demonstrate the capability of our solution framework to handle a large set of items with

varying regional demand patterns.

For simplicity, we assume that the fixed cost parameter is f in � 1 for every item i P I and for

every fulfillment center n PN , unless otherwise stated.

Large-scale solution framework configuration. In Step A, we aggregate the items by partitioning

the space of item attributes, pwi, di, αiq P r1,35s�r1,100s�r0,1s. The default is to divide the range

of each attribute evenly into 10 segments, which create a total of 1,000 partitions. Items whose

attributes belong to the same partition are aggregated into the same bundle, and the bundles are

characterized in Step B accordingly. Steps A and B can be pre-computed and stored in memory.



We run Steps C an D on a single processor. In Step C, the column-based reformulation is solved

to optimality unless 10 hours of computation time has elapsed, in which case it terminates with

a feasible solution at the end of the current iteration. In Step D, the disaggregation problem for

each bundle is terminated as soon as the first feasible solution is found.

4.2. Overview of experiments

We conduct three sets of experiments. The first investigates the effect of varying configuration

parameters of our large-scale solution framework, namely, the number of bundles, and the item

attributes used in aggregation. The second explores the effect of the placement problem’s input

parameters, namely, excess capacity and fixed cost parameters. The third compares our solution

scheme to a sequential placement heuristic.

We compare solution methods based on two performance measures: optimality gap and compu-

tation time. For optimality gap, since the true optimal solution of (P1) is unknown, we compare

the cost of our solution to a lower bound obtained by solving the uncapacitated problem, i.e., by

removing (2) from (P1). The uncapacitated problem decomposes by item, and its solution can be

pre-computed and stored in memory.

For computation time, we report the overall computation time required to complete the solution

method on a single processor. For the computationally intensive Steps C and D, we report both

the total computation time of the step, as well as the unit computation time required to solve one

instance of an optimization problem (RMP), (CGj) or (Dj). For example, the unit computation

time for (CGj) is the average time it takes to solve it for one bundle in one iteration. The unit

computation time helps us estimate the expected computation time if parallel processors were

available for solving multiple instances of (CGj) and (Dj) concurrently.

4.3. The effect of configuration parameters: Number of bundles and aggregation attributes

Our default configuration of the large-scale solution framework uses 1,000 bundles, aggregated by

partitioning the range of the three item attributes into 10 segments each. We test other config-

urations, created in two ways. First, we vary the number of bundles, while using all three item



attributes for aggregation. This is achieved by partitioning each attribute evenly into 5, 6, 7, 8 or

9 segments (for a total of 125, 216, 343, 512 and 729 bundles, respectively). Secondly, we vary the

attributes used in aggregation, while keeping the number of bundles around 1,000. There are three

configurations that use two attributes, in which each attribute’s range is divided evenly into 32

segments (for a total of 1,024 bundles). There are three configurations that use a single attribute,

in which the attribute’s range is divided evenly into 1,000 segments. Finally, we also consider the

random assignment of items into 1,000 bundles, without using any attributes for aggregation.

Table 1 compares the different configurations. Each column represents a configuration, and each

row reports a performance measure. The table is organized as follows:

• The columns are divided into three sections. The default configuration is reported in Section

(2) in the middle. Section (1) to the left contains configurations with different numbers of bundles,

and Section (3) to the right contains configurations with different aggregation attributes.

• The rows are also divided into three sections: (1) The overall performance of optimality gap

and computation time. (2) Detailed performance measures for Step C, including the number of

iterations, the total and unit computation times, as well as the average number of columns in the

final solution of each bundle. (3) Detailed performance of Step D.

• The value in each cell of the table is the average of 10 problem instances, each of which is

based on a set of randomly generated items. We focus on comparing the average value, because

we find that the performance under the same configuration does not vary much across the 10 sets

of items. This is evidenced by the maximum coefficient of variation (CoV) shown in the far-right

column of each row, which is the row-wise maximum of each cell’s CoV across the 10 sets of items.

The CoV values are small relative to the differences between configurations.

The default configuration produces a placement plan with a 1.00% optimality gap in 4.18 hours.

We observe that as the number of bundles increases (column sections (1) and (2)), the overall

optimality gap decreases while the computation time increases. The improvement in optimality gap

can be attributed to the fact that when there are more bundles, each bundle is a finer representation



of its items, i.e., the cost of (P2) is closer to that of (P1). The overall computation time increases

with the number of bundles likely because more bundles in Step C leads to more decision variables

in (RMP) and more column generation subproblems (CGj). On the other hand, the total and

unit computation times of Step D decrease with more bundles, likely because each bundle ends up

needing fewer columns in the final solution of Step C (as shown in the row labeled Columns per

bundle), so disaggregation becomes easier.

Between different aggregation attributes (column sections (2) and (3)), unsurprisingly, the best

solution is produced by aggregating the items using all three attributes. Using fewer attributes

results in the bundles being more homogeneous, which creates a multiplicity of near-optimal solu-

tions for (P3), and thereby increases the number of iterations in Step C and the (RMP) unit

computation time. Fewer attributes also leads to greater heterogeneity of items in the same bundle,

which makes the disaggregation problem harder, leading to an increased computation time of Step

D. In addition, we observe that the optimality gap appears to be most sensitive to whether or not

the weight wi is included in aggregation, and least sensitive to the inclusion of αi.

The table provides a way to estimate the computation time if multiple parallel processors were

available. As an example, for the base case in column section (2), if there were 10 parallel processors,

then the estimated total time for Step C would be

�2.23� 0.17�

1000 bundles

10 processors

� 82.2 iterations � 1580.71 seconds � 0.44 hours,

and for Step D,

0.66�1000 bundles

10 processors� 66 seconds � 0.018 hours,

for an overall computation time of 0.458 hours, which is roughly a ten-fold reduction compared to

the single-processor case.

Chen

and

Graves:

Item

Aggreg

atio

nand

Column

Genera

tion

forOnlin

e-R

eta

ilIn

vento

ry

Place

ment

Artic

lesu

bm

itted

toOpera

tionsResea

rch;

manusc

ript

no.

(Ple

ase

,pro

vid

eth

em

anusc

ript

num

ber!)

25

Table 1 Performance of the large-scale solution framework for different configurations

Configuration (1) Number of bundles (2) Default (3) Aggregation attributes Max

CoV

(%)

Aggregation of attributes pwi, di, αiq pwi, di, αiq pdi, αiq pwi, αiq pwi, diq di αi wi None

Number of bundles, |J | 125 216 343 512 729 1000 1024 1024 1024 1000 1000 1000 1000

(1) Overall performance

Optimality gap (%) 1.39 1.22 1.12 1.05 1.02 1.00 2.22 1.19 1.04 2.37 2.58 1.27 2.83 1.63

Computation time (hours) 1.72 1.62 1.87 2.44 3.10 4.18 9.81 6.82 5.34 10.41 10.57 10.29 10.26 5.17

(2) Step C: Column-based reformulation

Iterations 96.9 90.2 86.3 84.8 82.4 82.2 147.5 85.7 108.1 191.2 163.8 123.8 232.8 3.42

Total time (hr) 0.60 0.89 1.38 2.09 2.85 4.00 9.62 6.64 5.17 10.17 10.34 10.10 10.03 5.31

(RMP) unit time (sec) 0.13 0.26 0.46 0.84 1.34 2.23 3.94 2.75 2.78 5.27 5.43 2.87 9.63 9.16

(CGj) unit time (sec) 0.18 0.16 0.17 0.17 0.17 0.17 0.23 0.27 0.17 0.19 0.22 0.29 0.15 4.80

Columns per bundle 1.68 1.39 1.25 1.17 1.12 1.09 1.08 1.08 1.08 1.08 1.08 1.08 1.08 0.09

(3) Step D: Disaggregation

Total time (hr) 1.12 0.73 0.49 0.35 0.25 0.18 0.19 0.18 0.17 0.24 0.23 0.19 0.23 5.85

(Dj) unit time (sec) 32.20 12.20 5.15 2.44 1.23 0.66 0.67 0.64 0.61 0.85 0.83 0.68 0.84 5.85



4.4. The effect of input parameters: Excess capacity and fixed cost parameter

To understand the impact of capacity constraint tightness, we vary the excess capacity from the

default 1% to 2%, 5%, 10%, 20% and 50%. In all cases, the total capacity is distributed among

fulfillment centers in proportion to their square footage, as before. Figure 2 shows the performance

of the large-scale solution framework for different amounts of excess capacity. (Dots connected

by trend line indicate the average of 10 problem instances for each capacity level. Vertical error

bars indicate one standard deviation above and below the average value.) We find that increasing

excess capacity decreases both the optimality gap and the cost, but at a diminishing rate. In other

words, as the capacity increases, the problem becomes easier to solve, and the cost approaches the

uncapacitated lower bound, as expected.

To investigate how the fixed cost parameter affects the number of fulfillment centers chosen, we

test the parameter values of f in � 1 (default), 10, and 100. We find that the fixed cost parameter

is indeed an effective tool for controlling the sparsity level of the placement plan. Figure 3a plots

the distribution of the items by the number of fulfillment centers used, for one problem instance

(other instances all exhibit similar behavior). Figure 3b plots the objective cost for different fixed

cost parameter values, averaged over all 10 sets of items (the variance is negligible). As expected, a

higher fixed cost parameter leads to sparser placement plans, i.e., items placed in fewer fulfillment

centers, which also leads to higher fixed and shipping costs.

4.5. Comparison with a sequential placement heuristic

We compare our solution framework with a sequential placement heuristic that places items one at

a time, according to some user-specified order. After each item is placed, the remaining fulfillment

center capacities are updated and given as input to the placement problem of the next item.

The main advantage of the sequential placement heuristic is its simplicity. It avoids the com-

plexity of jointly optimizing a large number of items. The placement problem for each item is easy

to compute; for the size of our network, the solution for one item can typically be obtained in less



Figure 2 Performance for varying amounts of excess capacity

(a) Optimality gap (b) Computation time

Figure 3 Performance for different fixed cost parameter values

(a) Number of fulfillment centers used (b) Objective cost breakdown

than a second. Based on informal interactions with industry professionals, the sequential placement

heuristic appears to be a reasonable proxy for what is implementation in practice.

However, we remark that the sequential and myopic nature of the heuristic can result in an

arbitrarily suboptimal cost. An example is given in the online companion EC.2.

We test three configurations of the sequential placement heuristic: placing the items in decreasing

order of the demand di, the weight wi, or the product of demand and weight.

Table 2 reports the performance of the sequential placement heuristic. Placing items by weight

leads to the smallest optimality gap, and is slightly better than placement by the product of weight

and demand. However, the computation time appears to be negatively correlated to the optimality

gap. More importantly, the total computation time is an order of magnitude greater than the



Table 2 Performance of sequential placement heuristics.

Sequential placement order di wi di �wi Max CoV (%)

Optimality gap (%) 11.23 3.10 4.06 1.05

Total computation time (hours) 32.77 43.79 36.51 4.02

default configuration of the large-scale solution framework. Although an item can be placed in

a fraction of a second on average, the sequential nature of the heuristic results in a long total

computation time. The online companion EC.2 provides further evidence on the suboptimality of

sequential placement due to its myopic nature.

From these results, we conclude that the large-scale solution scheme outperforms the sequential

placement heuristic, as the former consistently produces solutions with a smaller optimality gap in

less time, and also has the additional advantage of being readily parallelizable.

5. Extensions to sparsity-constrained placement

Instead of using fixed costs to induce sparsity in the placement plan, consider the following alter-

native. We replace the objective of (P1) by

minx,y

¸iPI

N

n�1

R

r�1

cinrdirx

inr, (12)

and add sparsity constraints on the fulfillment center usage variables yi � pyinqNn�1, i P I,

pyiqiPI P S, (13)

where the set S represents different types of sparsity constraints, as described below.

Using (12) and (13) in lieu of fixed costs has the potential benefit that, in certain business

contexts, the set S may be easier to characterize than the fixed cost parameters. However, it also

has the drawback that the presence of both sparsity and capacity constraints may result in the

problem being infeasible. There appears to be no simple way to check feasibility. One technique for

ensuring feasibility is to add a virtual fulfillment center that is uncapacitated and does not count

toward sparsity constraints, but has a high shipping cost to all regions. Then, any flow that would

not fit in the actual fulfillment centers would be redirected to the virtual one, and the resulting

solution could be used to diagnose the cause of infeasibility.



Below, we describe two exemplary types of sparsity constraints that lead to different problem

structures, and discuss how to adapt the large-scale solution scheme to each case.

Sparsity limits per item. An online retailer may wish to limit the number of fulfillment centers

carrying an item, due to considerations such as replenishment location restrictions imposed by

suppliers. This can be modeled by specifying (13) as

N

n�1

yin ¤ si @i P I,

where the sparsity limit si for each item i P I is given as input.

When performing aggregation and bundle characterization, the sparsity limit sj of the bundle

j P J should be taken as the minimum sparsity limit among its items, miniPIj si, so as to ensure

the feasibility of the disaggregated placement plans for each item. For this reason, it may be a good

idea to aggregate the items according to their sparsity limits, in addition to other attributes.

The column-based reformulation of this problem has the same reduced master problem (RMP),

while the constraint°N

n�1 yjn ¤ sj is added to the column-generation subproblem (CGj). The

resulting column solution is a convex combination of columns that satisfy the sparsity constraint.

The disaggregation problem should be an integer program that selects exactly one column for each

item, which is different from the previous formulation that selects a convex combination of columns

with fixed cost adjustments.

Sparsity limits per fulfillment center. A fulfillment center may also have a limit on the number

of items it can carry, especially if the storage space is organized by “bins” that must each carry a

unique item. In this case, we can specify (13) as

¸iPI

yin ¤ tn @n� 1, . . . ,N,

where the sparsity limit tn for each fulfillment center n is given as input.

Unlike the previous case, these sparsity constraints cannot be decomposed by items, but instead

create coupling across items. Therefore, they do not need to be considered in aggregation or bundle



characterization, but must be included in the reduced master problem along with fulfillment center

capacity constraints. One possible approach is to add the following constraint to (RMP):

¸jPJ

¸kPK1

j

|Ij|yjnpkqλjk ¤ tn @n� 1, . . . ,N,

where |Ij|yjnpkq is equal to |Ij|, the total number of items in bundle j, if the column k PKj places

items in fulfillment center n (i.e., if yjnpkq � 1), and 0 otherwise. Thus, the left-hand side of the

constraint is an estimate of the total number of items placed in the fulfillment center.

When performing disaggregation, we need to ensure that the number of items allocated to each

fulfillment center does not exceed the value dictated by the convex combination of columns. This

can be achieved by adding the constraints

¸iPIj

yin ¤ tjn @n� 1, . . . ,N,

to the disaggregation problem (Dj), where tjn :�Y°

kPK1

j|Ij|yjnpkqλ

jk

]is the number of items in

bundle j that can be placed in fulfillment center n, and t�u denotes rounding down to the nearest

integer (although it is possible for some bundles to rounded up as well, as long as°jPJ t

jn ¤ tn).

6. Conclusions

In this paper, we formulate the online-retail inventory placement problem as a mixed-integer pro-

gram, and show that the problem is difficult to solve with off-the-shelf commercial software due to

the large number of items, the presence of binary variables for modeling fixed costs, and the capac-

ity constraints that couple the items. We propose a large-scale solution framework that tightly

integrates item aggregation and column generation, which makes it computationally efficient, par-

allelizable, and viable for early termination. We demonstrate with empirical analysis that the

solution framework is capable of finding near-optimal solutions in a relatively short amount of

time, compared with a sequential placement heuristic. We also discuss how to adapt the solution

framework to handle two types of fulfillment center sparsity constraints.

One promising direction of future work is to incorporate the idea of iterative aggregation. Instead

of having only one level of aggregation (from items to bundles), it is possible to perform multiple



levels of aggregation, and iteratively refine the placement plan at each level. This technique has

been applied successfully to other aggregation-based solution frameworks, e.g., Barmann et al.

(2015), Shetty and Taylor (1987), and Dudkin et al. (1987). Iterative aggregation has the potential

of further enhancing the scalability of our solution framework without severely impacting the

optimality gap.

Another direction of future work is the extension to the multi-period setting, in which the demand

changes, for example, from season to season. In that case, the placement solution should be a

contingency plan that accounts for the overhead of shifting from the use of one fulfillment center

to another. The resulting problem is greater in scale and complexity compared to the single-period

problem, and appropriate adaptations of our large-scale solution scheme may serve as a building

block.

References

Acimovic J, Graves SC (2015) Making better fulfillment decisions on the fly in an online retail environment.

Manufacturing & Service Operations Management 17(1):34–51.

Acimovic J, Graves SC (2017) Mitigating spillover in online retailing via replenishment. Manufacturing &

Service Operations Management 19(3):419–436.

Acimovic JA (2012) Lowering outbound shipping costs in an online retail environment by making better

fulfillment and replenishment decisions. Ph.D. thesis, Massachusetts Institute of Technology.

Agatz NA, Fleischmann M, Van Nunen JA (2008) E-fulfillment and multi-channel distribution–a review.

European journal of operational research 187(2):339–356.

Barmann A, Liers F, Martin A, Merkert M, Thurner C, Weninger D (2015) Solving network design problems

via iterative aggregation. Mathematical Programming Computation 7(2):189–217.

Bitran GR, Haas EA, Hax AC (1981) Hierarchical production planning: A single stage system. Operations

Research 29(4):717–743.

Bitran GR, Tirupati D (1993) Hierarchical production planning, volume 4, 523–568 (Elsevier).

Chen AI (2017) Large-scale optimization in online-retail inventory management. Ph.D. thesis, Massachusetts

Institute of Technology.



Costa AM, Cordeau JF, Gendron B, Laporte G (2012) Accelerating benders decomposition with heuristic

master problem solutions. Pesquisa Operacional 32(1):03–20.

Crainic TG, Gendreau M, Farvolden JM (2000) A simplex-based tabu search method for capacitated network

design. INFORMS Journal on Computing 12(3):223–236.

Dudkin L, Rabinovich I, Vakhutinsky I (1987) Iterative aggregation theory: mathematical methods of coor-

dinating detailed and aggregate problems in large control systems. Monographs and textbooks in pure

and applied mathematics (Dekker, New York).

Francis VE (1985) Aggregation of Network Flow Problems. Ph.D. thesis, University of California, Los Angeles.

Gendron B (2011) Decomposition methods for network design. Procedia-Social and Behavioral Sciences

20:31–37.

Gendron B, Larose M (2014) Branch-and-price-and-cut for large-scale multicommodity capacitated fixed-

charge network design. EURO Journal on Computational Optimization 2(1-2):55–75.

Graves SC (1982) Using lagrangean techniques to solve hierarchical production planning problems. Manage-

ment Science 28(3):260–275.

Hallefjord A, Storøy S (1990) Aggregation and disaggregation in integer programming problems. Operations

Research 38(4):619–623.

Hax AC, Meal HC (1975) Hierarchical integration of production planning and scheduling. Geisler MA,

ed., North-Holland/TIMS Studies in Management Sciences, Vol. 1: Logistics, 53–69 (North-Holland,

Amsterdam and American Elsevier, New York).

Hewitt M, Nemhauser GL, Savelsbergh MW (2010) Combining exact and heuristic approaches for the capac-

itated fixed-charge network flow problem. INFORMS Journal on Computing 22(2):314–325.

Hubner A, Holzapfel A, Kuhn H (2016) Distribution systems in omni-channel retailing. Business Research

9(2):255–296.

Katayama N, Chen M, Kubo M (2009) A capacity scaling heuristic for the multicommodity capacitated

network design problem. Journal of computational and applied mathematics 232(1):90–101.

Klose A, Drexl A (2005) Lower bounds for the capacitated facility location problem based on column gen-

eration. Management Science 51(11):1689–1705.



Krarup J, Pruzan PM (1983) The simple plant location problem: survey and synthesis. European journal of

operational research 12(1):36–81.

Lei Y, Jasin S, Sinha A (2016) Dynamic joint pricing and order fulfillment for e-commerce retailers. Available

at SSRN: https://ssrn.com/abstract=2753810 .

Litvinchev I, Tsurkov V (2013) Aggregation in large-scale optimization (Springer Science & Business Media).

MWPVL International Inc (2014) Amazon is building a new distribution network quickly

and quietyly. URL http://www.mwpvl.com/html/amazon_building_new_sortation_network.html,

accessed April 2017.

MWPVL International Inc (2015) The amazon fulfillment center and distribution center network in the

united states. URL http://www.mwpvl.com/html/amazon_com.html, accessed December 2015.

Pirkul H, Jayaraman V (1998) A multi-commodity, multi-plant, capacitated facility location problem: for-

mulation and efficient heuristic solution. Computers & Operations Research 25(10):869–878.

Rodrıguez-Martın I, Salazar-Gonzalez JJ (2010) A local branching heuristic for the capacitated fixed-charge

network design problem. Computers & Operations Research 37(3):575–581.

Rogers DF, Plante RD, Wong RT, Evans JR (1991) Aggregation and disaggregation techniques and method-

ology in optimization. Operations Research 39(4):553–582.

Shetty C, Taylor RW (1987) Solving large-scale linear programs by aggregation. Computers & Operations

Research 14(5):385–393.

Sridharan R (1995) The capacitated plant location problem. European Journal of Operational Research

87(2):203–213.

Swaminathan JM, Tayur SR (2003) Models for supply chains in e-business. Management Science 49(10):1387–

1406.

Torabi S, Hassini E, Jeihoonian M (2015) Fulfillment source allocation, inventory transshipment, and cus-

tomer order transfer in e-tailing. Transportation Research Part E: Logistics and Transportation Review

79:128–144.

United Parcel Service of America, Inc (2016) Daily rate and service guide. URL https://www.ups.com/

content/us/en/shipping/cost/zones/daily_rates.html, accessed October 2016.



United States Census Bureau (2010) 2010 census gazetteer files: Counties. URL http://www.census.gov/

geo/maps-data/data/gazetteer2010.html, accessed December 2015.

United States Census Bureau (2017) 4th quarter 2016 retail e-commerce sales report. URL https://www.

census.gov/retail/index.html, accessed April 2017.

Xu P (2005) Order fulfillment in online retailing: what goes where. Ph.D. thesis, Massachusetts Institute of

Technology.

Xu PJ, Allgor R, Graves SC (2009) Benefits of reevaluating real-time order fulfillment decisions. Manufac-

turing & Service Operations Management 11(2):340–355.

Zipkin PH (1980a) Bounds for row-aggregation in linear programming. Operations Research 28(4):903–916.

Zipkin PH (1980b) Bounds on the effect of aggregating variables in linear programs. Operations Research

28(2):403–418.

e-companion to Chen and Graves: Item Aggregation and Column Generation for Online-Retail Inventory Placement ec1

Appendices

EC.1. Feasible region equivalence of the column-based reformulation

Theorem EC.1. Let pxj,yjqjPJ be a feasible solution of (P2). Then there exists a feasible solution

of (P3), denoted pλjkqkPKj ,jPJ , such that (6) and (7) hold.

Proof. First, we establish that for every feasible solution of (P2), the continuous variables can

always be expressed as a convex combination of integral points in the set

X �

#pxjqjPJ

��¸nPN

xjnr � 1, xjnr P t0,1u @n, r, j

+.

We show this by induction on the number of continuous variables with fractional values, which we

denote Fpxq; i.e.,

Fpxq � cardinality of the set pn, r, jq PN �R�J | 0 xjnr 1

(.

We have Fpxq � 0 for every x PX . Now suppose x� pxjqjPJ is the vector of continuous variables

in a given feasible solution of (P2) for which Fpxq ¡ 0. Let pn1, r1, j1q PN �R� J be such that

0 xj1

n1r1 1. Then, because°nPN x

j1

nr1 � 1, there exists another n2 such that 0 xj1

n2r1 1. Let

v� xj1

n1r1 �xj1

n2r1 and let x1,x2 be continuous variable values such that

xj1,nr � xj2,nr � x

jnr @pn, r, jq � pn1, r1, j1q and pn, r, jq � pn2, r1, j1q,

xj1

1,n1r1 � v, xj1

1,n2r1 � 0,

xj1

2,n1r1 � 0, xj1

2,n2r1 � v.

It is straightforward to verify that

x�xj

1

n2r1

vx1 �

xj1

n1r1

vx2,

and that x1 and x2 still constitute feasible solutions of (P2). Moreover, we have Fpx1q �Fpx2q �

Fpxq � 1. In other words, x can be expressed as a convex combination of continuous variables of

ec2 e-companion to Chen and Graves: Item Aggregation and Column Generation for Online-Retail Inventory Placement

which there are fewer fractional values. By induction, repeated application of this procedure results

in an expression of x that is a convex combination of integral points in X .

Next, we construct a feasible solution of (P3) that satisfies (6) and (7). The convex combination

obtained by the inductive procedure above already implies the existence of a feasible solution

pλjkqkPKj ,jPJ that satisfies (6). It remains to show that (7) can be satisfied as well. This is achieved by

taking yjnpkq � yjn for every j PJ and every k PKj such that λjk ¡ 0. Then we have pxjpkq,yjpkqq PXj

because if xjnrpkq � 1 for some n and r, then (6) implies xjnr ¡ 0, which in turn implies yjn � yjnpkq � 1

by the feasibility requirement of (P2).

Finally, we complete the proof with the remark that the capacity constraint of (P3) is satisfied

due to the capacity constraint of (P2) and the definition of ujkn.

Theorem EC.2. Let pλjkqkPKj ,jPJ be a feasible solution of (P3). Then the corresponding placement

plan given by (6) and (7) is a feasible solution of (P2).

Proof. We proceed by substituting (6) and (7) into each set of constraints in (P2) and verifying

that the constraints hold.

The demand satisfaction constraint is met for every r PR, j PJ because

¸nPN

xjnr �¸nPN

¸kPKj

xjnrpkqλjk �

¸kPKj

λjk

�¸nPN

xjnrpkq

��

¸kPKj

λjk � 1,

where the second-to-last equality is by the definition of Xj, and the last equality is by the second

constraint of (P3).

The capacity constraint for every n PN is met because

¸jPJ

¸rPR

djrxjnr �

¸jPJ

¸rPR

djr¸kPKj

xjnrpkqλjk �

¸jPJ

¸kPKj

λjk

�¸rPR

djrxjnrpkq

��

¸jPJ

¸kPKj

ujknλjk ¤ bn,

where we invoke the definition of ujkn and the capacity constraint of (P3) in the latter two equality

and inequality, respectively.

For the relationship between the continuous and binary variables of every n PN and j P J , we

have

¸rPR

djrxjnr �

¸kPKj

λjk¸rPR

djrxjnrpkq ¤

¸kPKj

λjkdjyjnpkq ¤ dj maxtyjnpkq | k PKj, λ

jk ¡ 0u � djyjn,

e-companion to Chen and Graves: Item Aggregation and Column Generation for Online-Retail Inventory Placement ec3

where the first inequality is due to the definition of Xj, and the second inequality is due to the

constraints of (P3) on pλjkqkPKj.

Finally, the constraints that xjnr ¥ 0 and yjn P t0,1u are trivially true.

EC.2. Suboptimality of the sequential placement heuristic

The sequential placement heuristic can result in an arbitrarily suboptimal cost. To see this, consider

a small example with N � 2 fulfillment centers, R � 1 region, and two items I � t1,2u. Suppose

both fulfillment centers have capacity 1 � ε, where ε ¡ 0, and that the fixed costs are all zero.

Suppose also that the demand of items are d1 � 1 � ε, d2 � 1, and that the shipping costs are

pc111, c

121q � p1,2q for Item 1, and pc2

11, c221q � p1,Cq for Item 2, where C ¡ 2 is a large number. In

other words, it is better to ship both items from the first fulfillment center, and in the case that

they need to be shipped from the second fulfillment center, the additional cost for Item 2 is greater

than that of Item 1.

Now consider a sequential placement heuristic that places items in the order of decreasing

demand. It starts by placing Item 1 entirely in the first fulfillment center; then, it places Item 2

entirely in the second fulfillment center. This results in a total shipping cost of d1c111 � d2c

221 �

1� ε�C.

A better solution would be to place Item 2 fully in fulfillment center 1, along with ε units of

Item 1, and place the remaining 1 unit of Item 1 in fulfillment center 2, for a total cost of 3� ε.

Depending on the value of C, the former cost could be arbitrarily higher than the latter.

Figure EC.1 provides evidence on the suboptimality of placement plans produced by the sequen-

tial placement heuristic. The figure shows the final solution of one of the 10 problem instances, and

represents each item with a dot whose x-axis is its optimality gap (defined as the cost of the item’s

placement plan produced by the specified solution method, relative to the uncapacitated lower

bound), and whose y-axis is the item’s attribute (demand or weight). Figure EC.1a shows that the

large-scale solution scheme distributes the suboptimality of placement plans evenly across items,

except that extremely low-demand items are placed with relatively larger gaps. In contrast, in the

ec4 e-companion to Chen and Graves: Item Aggregation and Column Generation for Online-Retail Inventory Placement

Figure EC.1 Optimality gap versus item attributes (one representative problem instance)

(a) Large-scale solution framework

(b) Sequential placement by demand (c) Sequential placement by weight

sequential placement heuristic, the optimality gap is negligible for the items that are placed first,

but continues to increase as placement progresses. Moreover, we empirically observe a significant

surge in suboptimality for items that are placed towards the end, which is in line with the small

illustrative example given earlier. For example, in Figure EC.1b, after placing 861,564 items in

sequential order of decreasing demand, all the centrally located and east-coast fulfillment centers

run out of capacity, leading to a surge in the per-item optimality gap for the remaining items,

which can only use fulfillment centers on the west coast. Similarly, Figure EC.1c shows that after

placing 979,866 items in sequential order of decreasing weight, there is a surge in the per-item

optimality gap, although it is less dramatic than in Figure EC.1b and thus the overall optimality

gap is also smaller.

Documents

Item Aggregation and Column Generation for Online-Retail ... · Annie I. Chen Marshall School of Business, University of Southern California, Los Angeles, CA 90089, [email protected]