U.S. patent application number 17/343612 was filed with the patent office on 2021-12-09 for systems and methods for controlling automated systems using integer programming and column generation techniques.
This patent application is currently assigned to Insurance Services Office, Inc.. The applicant listed for this patent is Insurance Services Office, Inc., University of Southern California. Invention is credited to Claudio Contardo, Naveed Haghani, Sven Koenig, Gautam Kunapuli, Jiaoyang Li, Julian Yarkony.
Application Number | 20210382479 17/343612 |
Document ID | / |
Family ID | 1000005693965 |
Filed Date | 2021-12-09 |
United States Patent
Application |
20210382479 |
Kind Code |
A1 |
Haghani; Naveed ; et
al. |
December 9, 2021 |
Systems and Methods for Controlling Automated Systems Using Integer
Programming and Column Generation Techniques
Abstract
Systems and methods for controlling automated systems, such as
robots and other devices/resources, using integer programming and
column generation techniques, are provided. The system retrieves
location and movement data corresponding to at least one automated
system, and processes the location and movement data using an
integer linear programming algorithm. The system also optimizes the
integer linear programming algorithm using a column generation
algorithm, and solves a pricing problem associated with generating
routes for the at least one automated system. Then, the system
generates a route based on outputs of the integer linear
programming algorithm, the column generation algorithm, and solving
of the pricing problem, and transmits the route to the at least one
automated system, the at least one automated system executing the
route to control a location or a movement of the at least one
automated system.
Inventors: |
Haghani; Naveed; (Fulton,
MD) ; Li; Jiaoyang; (Jiangsu, CN) ; Koenig;
Sven; (Pasadena, CA) ; Kunapuli; Gautam;
(Brooklyn, NY) ; Contardo; Claudio; (Montreal
(PQ), CA) ; Yarkony; Julian; (Jersey City,
NJ) |
|
Applicant: |
Name |
City |
State |
Country |
Type |
Insurance Services Office, Inc.
University of Southern California |
Jersey City
Los Angeles |
NJ
CA |
US
US |
|
|
Assignee: |
Insurance Services Office,
Inc.
Jersey City
NJ
University of Southern California
Los Angeles
CA
|
Family ID: |
1000005693965 |
Appl. No.: |
17/343612 |
Filed: |
June 9, 2021 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
63036600 |
Jun 9, 2020 |
|
|
|
Current U.S.
Class: |
1/1 |
Current CPC
Class: |
G01C 21/3453 20130101;
G05D 1/0212 20130101; G05B 19/042 20130101; G05D 1/0088 20130101;
G05B 2219/2637 20130101 |
International
Class: |
G05D 1/00 20060101
G05D001/00; G05B 19/042 20060101 G05B019/042; G05D 1/02 20060101
G05D001/02; G01C 21/34 20060101 G01C021/34 |
Goverment Interests
STATEMENT OF GOVERNMENT INTERESTS
[0002] This invention was made with government support under
Contract Nos. 1409987, 1724392, 1817189, and 1837779 awarded by the
National Science Foundation (NSF). The government has certain
rights in the invention.
Claims
1. A system for controlling at least one automated system,
comprising; a database storing location and movement data of the at
least one automated system; and a processor in communication with
the database, the processor programmed to: retrieve the location
and movement data from the database; process the location and
movement data using an integer linear programming algorithm;
optimize the integer linear programming algorithm using a column
generation algorithm; solve a pricing problem associated with
generating routes for the at least one automated system; generate a
route based on outputs of the integer linear programming algorithm,
the column generation algorithm, and solving of the pricing
problem; and transmit the route to the at least one automated
system, the at least one automated system executing the route to
control a location or a movement of the at least one automated
system.
2. The system of claim 1, wherein the processor pre-processes the
location and movement data prior to processing the location and
movement data using the integer linear programming algorithm.
3. The system of claim 1, wherein the at least one automated system
comprises one or more of a robot, an automated guided vehicle, or a
drone.
4. The system of claim 1, wherein the location and movement data is
obtained in real time from the at least one automated system.
5. The system of claim 1, wherein the location and movement data
comprises space and time data.
6. The system of claim 5, wherein the integer linear programming
algorithm processes the space and time data to generate a location
and time pair for each of the at last one automated system.
7. The system of claim 6, wherein the integer linear programming
algorithm connects location and time pairs by a space-time edge
between each pair and generates a candidate route using the
edges.
8. The system of claim 1, wherein the column generation algorithm
establishes a set of feasibility constraints and cost terms for
each route.
9. The system of claim 1, wherein the processor solves the pricing
problem as a resource-constrained shortest-path problem (RCSP) over
a graph whose nodes correspond to space-time positions and
resources correspond to items picked up.
10. The system of claim 9, wherein the processor accelerates
computation by coarsening the graph and limiting times considered
by the processor.
11. A method for controlling at least one automated system,
comprising the steps of: retrieving by a processor location and
movement data of at least one automated system; processing the
location and movement data using an integer linear programming
algorithm executed by the processor; optimizing the integer linear
programming algorithm using a column generation algorithm executed
by the processor; solving by the processor a pricing problem
associated with generating routes for the at least one automated
system; generating a route based on outputs of the integer linear
programming algorithm, the column generation algorithm, and solving
of the pricing problem; and transmitting the route to the at least
one automated system, the at least one automated system executing
the route to control a location or a movement of the at least one
automated system.
12. The method of claim 1, further comprising pre-processing the
location and movement data prior to processing the location and
movement data using the integer linear programming algorithm.
13. The method of claim 11, wherein the at least one automated
system comprises one or more of a robot, an automated guided
vehicle, or a drone.
14. The method of claim 11, wherein the location and movement data
is obtained in real time from the at least one automated
system.
15. The method of claim 11, wherein the location and movement data
comprises space and time data.
16. The method of claim 15, wherein the integer linear programming
algorithm processes the space and time data to generate a location
and time pair for each of the at last one automated system.
17. The method of claim 16, wherein the integer linear programming
algorithm connects location and time pairs by a space-time edge
between each pair and generates a candidate route using the
edges.
18. The method of claim 11, wherein the column generation algorithm
establishes a set of feasibility constraints and cost terms for
each route.
19. The method of claim 11, further comprising solving the pricing
problem as a resource-constrained shortest-path problem (RCSP) over
a graph whose nodes correspond to space-time positions and
resources correspond to items picked up.
20. The method of claim 19, further comprising accelerating
computation by coarsening the graph and limiting times.
Description
RELATED APPLICATIONS
[0001] This application claims priority to U.S. Provisional Patent
Application Ser. No. 63/036,600 filed on Jun. 9, 2020, the entire
disclosure of which is hereby expressly incorporated by
reference.
BACKGROUND
Technical Field
[0003] The present disclosure relates generally to the field of
systems automation. More specifically, the present disclosure
relates to systems and methods for controlling automated systems,
such as robots and other devices/resources, using integer
programming and column generation techniques.
Related Art
[0004] In today's highly automated world, the ability to rapidly an
efficiently control the routing and operations of automated
systems, such as fleets of robots and other automated
systems/resources, is highly beneficial. Being able to route and
control routing and operations of such systems efficiently results
in not only the efficient and timely completion of tasks, but also
saving energy, reducing equipment wear, contributing to overall
operational efficiency, and reducing costs. Such improvements are
advantageous in a number of environments, including warehouses,
logistics operations, manufacturing, supply chain fulfillment, and
other environment where the rapid and accurate movement of objects
in a facility are of utmost importance.
[0005] Numerous attempts have, in the past, been made to address
efficient control of device routing, such as robots. For example,
routing problems for a fleet of robots in a warehouse are often
treated as Multi-Agent Pathfinding problems (MAPF). In MAPF, a set
of agents are provided, each with an initial position and
destination. The goal is to minimize the sum of the travel times
from the initial position to the destination over all agents such
that no collisions occur. MAPF can be formulated as a minimum cost
multi-commodity ow problem on a space-time graph. Optimization can
be addressed using multiple heuristic and exact approaches,
including search, linear programming, branch-cut-and-price,
satisfiability modulo theories, and constraint programming.
[0006] One common shortcoming in MAPF approaches is that they
require that robot assignments be set before a robot route can be
solved. The delegation of robot assignments and the optimal set of
routes for the fleet are treated as independent problems. Several
approaches solve this combined problem in a hierarchical framework,
i.e., assigning tasks first by ignoring the non-colliding
requirement and then planning collision-free paths based on the
assigned tasks. However, these methods are non-optimal as the
consideration of possible collisions can easily affect the optimal
task assignment for the fleet.
[0007] Multi-robot planning (MRP) aims to route a fleet of robots
in a warehouse so as to achieve the maximum reward in a limited
amount of time, while not having the robots collide and obeying the
constraints of individual robots. In MRP, individual robots may
make multiple trips over a given time window and may carry multiple
items on each trip. The efficiency of the warehouse, not the
makespan, can be enhanced since new orders are likely to be
continuously added. Additionally, linear programming (ILP)
formulation and column generation (CG) techniques for (prize
collecting) vehicle routing are also of interest in efficient robot
planning, as is efficient optimization by avoiding consideration of
every time increment.
[0008] Accordingly, what would be desirable are systems and methods
for controlling automated systems, such as robots and other
devices/resources, using integer programming and column generation
techniques, which address the foregoing, and other, needs.
SUMMARY
[0009] The present disclosure relates to systems and methods for
controlling automated systems, such as robots and other
devices/resources, using integer programming and column generation
techniques. The system retrieves location and movement data
corresponding to at least one automated system, and processes the
location and movement data using an integer linear programming
algorithm. The system also optimizes the integer linear programming
algorithm using a column generation algorithm, and solves a pricing
problem associated with generating routes for the at least one
automated system. Then, the system generates a route based on
outputs of the integer linear programming algorithm, the column
generation algorithm, and solving of the pricing problem, and
transmits the route to the at least one automated system, the at
least one automated system executing the route to control a
location or a movement of the at least one automated system.
BRIEF DESCRIPTION OF THE DRAWINGS
[0010] The foregoing features of the invention will be apparent
from the following Detailed Description, taken in connection with
the accompanying drawings, in which:
[0011] FIG. 1 is a diagram illustrating hardware and software
components of the system of the present disclosure;
[0012] FIG. 2 is a flowchart illustrating processing steps carried
out by the system of FIG. 1;
[0013] FIG. 3 is a table illustrating an optimization algorithm
executed by the systems and methods of the present disclosure,
utilizing a column generation technique;
[0014] FIG. 4 is a table illustrating a fast pricing algorithm
executed by the systems and methods of the present disclosure;
[0015] FIG. 5 is a graph illustrating sample routes generated by
the systems and methods of the present disclosure; and
[0016] FIG. 6 is a graph illustrating performance of the systems
and methods of the present disclosure.
DETAILED DESCRIPTION
[0017] The present disclosure relates to systems and methods for
controlling automated systems, such as robots and other
devices/resources, using integer programming and column generation
techniques, as discussed in detail below in connection with FIGS.
1-6.
[0018] FIG. 1 is a diagram illustrating overall hardware and
software components of the system of the present disclosure,
indicated generally at 10. The system 10 includes system code 16
that is executable by a processor of a computer system 12 and
retrieves location and movement data from a data source such as a
database 14. The location and movement data corresponds to
locations and movements of one or more automated systems 20a-20c,
which could include, but are not limited to, robots, automatic
guided vehicles (AGVs), drones, or other system/resource. The
automated systems 20a-20c could be in communication with the
computer system 12 using a suitable communication network 22, such
as a wide area network (WAN), local area network (LAN), controller
area network (CAN), wireless network, optical network, infrared
network, cellular data network, or other suitable network
connections.
[0019] The system code 16 includes a plurality of software modules
18a-18c including a data retrieval and pre-processing module 18a,
an integer linear programming module 18b, and a column generation
module 18c, each of which are described in greater detail below in
connection with FIG. 2 and provide the automated system routing and
control operations described herein. The system code 16 could be
programmed in any suitable high- or low-level language such as C,
C++, C#, Java, Python, or any other suitable programming language.
The computer system 12 could include, but is not limited to, a
personal computer, a tablet computer, a smart phone, a server, or
any other suitable computing device. Moreover, the computer system
12 could be an embedded processor of a robot, robot control system,
automation system, automated guided vehicle (AGV) (such as in one
or more processors of the automated systems 20a-20c), or a
custom-developed hardware device such as an application-specific
integrated circuit (ASIC), field-programmable gate array (FPGA), or
any other suitable hardware device.
[0020] The location and movement data stored in the database 14
could be accumulated location and movement data associated with one
or more automated systems, such as robots, AGVs, or other automated
systems capable of moving from one location to another. Such data
could also be provided in real time to the system code 16, e.g.,
transmitted to the computer system 12 in real time from the one or
more automated systems. The module 18a retrieves the data (e.g.,
from the database 14, or in real time from the automated systems)
and pre-processes the data as needed (e.g., formatting location and
movement data into common units, coordinate systems, formats,
etc.). Then, the data is processed by the modules 18b-18c to
generate optimized routing plans for the one or more automated
systems, as described in greater detail below in connection with
FIG. 2.
[0021] The system 10 could operate with a fleet of mobile warehouse
robots that enter the warehouse floor from a single location,
called the launcher, pick up one or multiple items inside the
warehouse, and deliver them to the launcher before the time limit.
Each item has a reward (i.e., negative cost) and a time window
during which the item can be picked up. Each robot has a capacity
and is allowed to perform multiple trips. At the initial time, the
fleet of robots is located at the launcher, however we also allow
for some robots, called extant robots, to begin at other locations.
The use of extant robots permits re-optimization as the environment
changes, e.g. when items have their rewards changed or when items
are added or removed. The goal is to plan collision-free paths for
the robots to pick up and deliver items and minimize the overall
cost.
[0022] For computational efficiency, the continuous space-time
positions that robots occupy can be approximated by the system 10
by treating the warehouse as a 4-neighbor grid and treating time as
a set of discrete time points. Each position on the grid is
referred to as a cell. Most cells are traversable for the robot but
some cells are labeled as obstacles and cannot be traversed, we
call these obstructed. Through each time period, robots are capable
remaining stationary or moving to an adjacent unobstructed cell in
the four main compass directions, which we connect through edges.
Robots are required to avoid collisions by not occupying the same
cell at any time point and not traversing the same edge in opposite
directions between any successive time points. Every item is
located at a unique cell. Robots incur a cost while deployed on the
grid and for moving on the grid, however, they can obtain a reward
for servicing an item. To service an item, a robot must travel to
the specific cell where the item is located during the item's
associated serviceable time window. Servicing an item consumes a
portion of the robots capacity, which can be refreshed once it
travels back to the launcher.
[0023] FIG. 2 is a flowchart illustrating process steps 50 carried
out by the system 10 of FIG. 1. In step 52, the system retrieves
automated system (e.g., robots, AGVs, etc.) location and movement
data, e.g., from the database 14 of FIG. 1, from the automated
systems themselves, etc. Optionally, in step 54, the location and
movement data is pre-processed as noted above in connection with
FIG. 1. Once pre-processed, the data is then processed by the
modules 18b-18c, as described in detail below in connection with
steps 56-60. Finally, in step 62, the system 10 generates one or
more optimal routes based on outputs of steps 56-60 (e.g, based on
outputs of a integer linear programming algorithm, a column
generation algorithm, and solving of a pricing problem associated
with route planning, as each of these steps are discussed in
greater detail below), and transmits the routes to the automated
systems 20a-20c, for execution by the automated systems 20a-20c,
such that movement of the systems 20a-20c is controlled by the
routes transmitted thereto.
[0024] In step 56, the system processes the location and movement
data using an integer linear programming (ILP) described herein, to
address multi-robot planning (MRP). The ILP problem using the
following notation. We use G to denote the set of feasible robot
routes, which we index by g. We note that G is too large to be
enumerated. We use .GAMMA..sub.g to denote the cost of robot route
g. We use .gamma..sub.g {0, 1} to describe a solution where g is in
the solution IFF .gamma..sub.g=1. We describe the sets of items,
times, and extant robots as D, T, and R, respectively, which we
index by d, t, and r, respectively. We use (P, E) to denote the
time-extended graph. Every p P represents a space-time position,
which is a pair of a location (i.e., an unobstructed cell on the
warehouse grid) and a time t T Two space-time positions p.sub.i,
p.sub.j P are connected by a (directed) space-time edge e=(p.sub.i;
p.sub.j) .epsilon. IFF the locations of p.sub.i and p.sub.j are the
same cell or adjacent cells and the time of p.sub.j is the time of
p.sub.i plus one.
[0025] We describe routes using G.sub.ig {0, 1} for i I={D U T U P
U .epsilon. U R} We set G.sub.dg=1 IFF route g services item d. We
set G.sub.tg=1 IFF route g is active (meaning moving or waiting) at
time t. We set G.sub.pg=1 IFF route g includes space-time position
p. We set G.sub.rg=1 IFF route g is associated with extant robot r.
We set G.sub.eg=1 IFF route g uses space-time edge e. This edge is
associated with adjacent cells e.sub.1 and e.sub.2 in space and
time t. Thus, G.sub.eg=1 indicates that a robot on route g crosses
from e.sub.1 at time t to e.sub.2 at time t+1 OR from e.sub.2 at
time t to e.sub.1 at time t+1. We use N to denote the total number
of robots available in the fleet.
[0026] In step 58, the system optimizes the ILP algorithm using a
column generation (CG) optimization algorithm. We write MRP as an
ILP as illustrated in Algorithm 1 of FIG. 3, followed by an
explanation of the objective and constraints.
min .gamma. g .di-elect cons. { 0 , 1 } .times. .A-inverted. g
.di-elect cons. .times. g .di-elect cons. .times. .GAMMA. g .times.
.gamma. g ( 1 ) g .di-elect cons. .times. G dg .times. .gamma. g
.ltoreq. 1 .times. .times. .A-inverted. d .di-elect cons. ( 2 ) g
.di-elect cons. .times. G tg .times. .gamma. g .ltoreq. N .times.
.times. .A-inverted. t .di-elect cons. ( 3 ) g .di-elect cons.
.times. G rg .times. .gamma. g = 1 .times. .times. .A-inverted. r
.di-elect cons. ( 4 ) g .di-elect cons. .times. G pg .times.
.gamma. g .ltoreq. 1 .times. .times. .A-inverted. p .di-elect cons.
( 5 ) g .di-elect cons. .times. G eg .times. .gamma. g .ltoreq. 1
.times. .times. .A-inverted. g .di-elect cons. .times. .times.
Equations .times. .times. 1 .times. - .times. 6. ( 6 )
##EQU00001##
[0027] In Equation (1), we minimize the cost (that is, maximize the
reward) of the MRP solution. In Equation (2), we enforce that no
item is serviced more than once. In Equation (3), we enforce that
no more than the available number of robots N is used at any given
time. In Equation (4), we enforce that each extant robot is
associated with exactly one route. In Equation (5), we enforce that
no more than one robot can occupy a given space-time position. In
Equation (6), we enforce that no more than one robot can move along
any space-time edge.
[0028] We describe a set of feasibility constraints and cost terms
for robot routes. First, each item d D can only be picked up during
its time window [t.sup.-.sub.d, t.sup.+.sub.d]. Second, each item d
D uses c.sub.d .sub.+ units of capacity of a robot. The capacity of
a robot is c.sub.0 .sub.+. An active robot r E R is associated with
an initial space-time position p.sub.0r (at the initial time, i.e.,
time 1) and a remaining capacity c.sub.r [0, c.sub.0].
[0029] The cost associated with a robot route is defined by the
following terms. First, .theta..sub.d is the cost associated with
servicing item d. Second, .theta..sub.1, .theta..sub.2 .sub.0+ are
the costs of being on the floor and moving respectively, which
depreciate the robot. Using .theta..sub.d, .theta..sub.1, and
.theta..sub.2, we write .GAMMA..sub.g=.SIGMA..sub.d D G.sub.dg
.theta..sub.d+.SIGMA..sub.t T.theta..sub.1 G.sub.tg+.SIGMA..sub.e
.epsilon..theta..sub.2 Ge.sub.g
[0030] In step 58, since in practice G cannot be enumerated, we
address optimization in Equations (1)-(6) using column generation
(CG). Specifically, we relax .gamma. to be non-negative and
construct a sufficient set G.OR right.G to solve optimization over
G using CG. CG iterates between solving the LP relaxation of
Equations (1)-(6) over G, which is referred to as the Restricted
Master Problem (RMP), followed by adding elements to G that have
negative reduced cost, which is referred to as pricing. Below we
formulate pricing as an optimization problem using .lamda..sub.d,
.lamda..sub.t, .lamda..sub.r, .lamda..sub.p, and .lamda..sub.e to
refer to the dual variables over constraints of Equations (2)-(6)
of the RMP respectively.
min g .di-elect cons. .times. .GAMMA. _ g .times. .times. where
.times. .times. .GAMMA. _ g = .GAMMA. g - i .di-elect cons. .times.
.lamda. i .times. G ig ( 7 ) ##EQU00002##
We terminate optimization when the solution to Equation (7) is
non-negative, which means that G is provably sufficient to exactly
solve the LP relaxation of optimization over G. We initialize G
with any feasible solution (perhaps greedily constructed) so as to
ensure that each r R is associated with a route. At termination of
CG, if .gamma..sub.g {0, 1}, .A-inverted.g G, then the solution,
i.e. the tracks defined by {g G|.gamma..sub.g=1}, is provably
optimal. Otherwise, an approximate solution can be produced by
solving the ILP formulation over G or the formulation can be
tightened using valid inequalities, such as subset row
inequalities. We can also use branch-and-price to formulate CG
inside a branch-and-bound formulation. Algorithm 1 of FIG. 3 shows
pseudocode for CG. Below, we describe an enhanced version of CG
motivated by dual optimal inequalities (DOI).
[0031] In step 58 of FIG. 2, the system 10 solves one or pricing
problems associated with route planning. In this step, the system
10 considers the problem of pricing, which we show is a
resource-constrained shortest-path problem (RCSP). First, we
formulate pricing as an RCSP over a graph whose nodes correspond to
space-time positions and whose resources correspond to the items
picked up. Next, we accelerate computation by coarsening the graph,
leaving only locations of significance such as item locations
across time. Then, we further accelerate computation by limiting
the times considered while still achieving exact optimization
during pricing. Finally, we show that CG can be accelerated by
updating the .lamda..sub.i for all i D U R more often than the
remainder of the dual solution, saving computation time by
precluding the need to reconstruct the coarsened graph as often
between rounds of pricing.
[0032] A weighted graph admitting an injunction from the routes in
G to the paths in the graph is established. For a given route g,
the sum of the weights along the corresponding path in the weighted
graph is equal to the route's reduced cost .GAMMA..sub.g. Thus,
finding the lowest-cost feasible path in this graph solves Equation
(7). The graph proposed is a modified form of the time-extended
graph (P, E). Nodes are added to represent start/end locations,
item pickups, and the use of an extant robot. Weights are amended
by the corresponding dual variables associated with a given
node/edge. We solve a RCSP over this graph where the resources are
the items to be pick up.
[0033] Formally, consider a graph (P.sup.+, E.sup.+) with paths
described by x.sub.pipjg {0, 1} for (p.sub.i, p.sub.j) E
.epsilon..sup.+, g G, where x.sub.pipjg=1 indicates that edge
(p.sub.i, p.sub.j) is traversed by the path on the graph
corresponding to route g. Each edge (p.sub.i, p.sub.j) has an
associated weight .kappa.pipj. There is a node in P.sup.+ for each
p P, for each pairing of d D and t [t.sup.-.sub.d, t.sup.+.sub.d]
denoted p.sub.dt, for each r R denoted p.sub.r, the source node
p.sub.+, and the sink node p.sub.-. We ensure that
.GAMMA..sub.g=.SIGMA..sub.(pi,pj)
.epsilon.+.sup.K.sub.pipj.sup.X.sub.pipjg for all g G. For each
pair of space-time positions p.sub.i, p.sub.j occurring at the same
cell at times t.sub.i, t.sub.j=t.sub.i+1 (representing a wait
action), we set
.kappa..sub.pipj=.theta..sub.1-.lamda..sub.tj-.lamda..sub.pj. We
set x.sub.pipig=1 IFF robot route g transfers from p.sub.i to
p.sub.j and no pickup is made at p.sub.i.
[0034] For each pair of space-time positions p.sub.i, p.sub.j
occurring at times t.sub.i and t.sub.j=t.sub.i+1 and associated
with space-time edge e (representing a move action), we set
.kappa..sub.pipj=.theta..sub.1+.theta..sub.2-.lamda..sub.e-.lamda..sub.tj-
-.lamda..sub.pj. We set .lamda..sub.pipjg=1 IFF robot route g
transfers from p.sub.i to p.sub.j and no pickup is made at p.sub.i.
For each d D, t [t.sup.-.sub.d, t.sup.+.sub.d], which occurs at
space-time position p, we set
.kappa..sub.ppdt=.theta..sub.d-.lamda..sub.d. We set x.sub.ppdtg=1
IFF robot route g picks up item d at time t. For each d D, t
[t.sup.-.sub.d, t.sup.+.sub.d] which occurs at an associated p, we
provide identical outgoing .kappa. terms for p.sub.dt as we do p
(except there is no self-connection p.sub.dt to p.sub.dt). We set
x.sub.pdtpjg=1 IFF robot route g transfers from the position of
item d to p.sub.j and item d is picked up at time t.sub.j-1 on
route g. For each t T we connect the p.sub.+ to the launcher at
time t denoted p.sub.0t with weight
.kappa..sub.p+p0t=.theta..sub.1-.lamda..sub.t-.lamda..sub.p0t. We
set x.sub.p+p0tg=1 IFF the robot route g appears first at p.sub.0t.
For each r R we set
.kappa..sub.p+pr=.theta..sub.1-.lamda..sub.r-.lamda..sub.t=1-.lamda..sub.-
pr. We set x.sub.p+prg=1 IFF the robot route g appears first at
p.sub.r. For each r R, p.sub.r has one single outgoing connection
to p.sub.0r with weight .kappa..sub.prp0r=0.
[0035] For each t Twe set .kappa..sub.p0tp-=0. We set
x.sub.p0tp-g=1 IFF the robot route g has its last position at
p.sub.0t. Using .kappa. defined above we express the solution to
Equation (7) as an ILP (followed by description) using decision
variables x.sub.pipj {0, 1} where x.sub.pipj is equal to
x.sub.pipjg for all (p.sub.i, p.sub.j) .epsilon..sup.+.
min x p i .times. p j .di-elect cons. { 0 , 1 } .times. .times.
.A-inverted. ( p i , p j ) .di-elect cons. + .times. ( p i , p j )
.di-elect cons. + .times. .kappa. p i .times. p j .times. x p i
.times. p j ( 8 ) ( p i , p j ) .di-elect cons. + .times. x p i
.times. p j - ( p j , p i ) .di-elect cons. + .times. x p j .times.
p i = [ p i = p + ] - [ p i = p - ] .times. .times. .A-inverted. p
i .di-elect cons. + ( 9 ) d .di-elect cons. .times. c d .times. t d
- .ltoreq. t .ltoreq. t d + .times. ( p , p dt ) .di-elect cons. +
.times. x pp dt .ltoreq. c 0 + r .di-elect cons. .times. ( c r - c
0 ) .times. x p + .times. p r ( 10 ) t d - .ltoreq. t .ltoreq. t d
+ .times. ( p , p dt ) .di-elect cons. + .times. x pp dt .ltoreq. 1
.times. .times. .A-inverted. d .di-elect cons. ( 11 )
##EQU00003##
[0036] In Equation (8) we provide objective s.t.
.GAMMA..sub.g=.SIGMA..sub.(pi,pj)
.epsilon.+.sup.k.sub.pipj.sup.x.sub.pipjg for all g G. In Equation
(9) we ensure that x describes a path from p.sub.+ to p.sub.-
across space time. In Equation (10) we ensure that capacity is
obeyed. In Equation (11) we ensure that each item is picked up at
most once. Optimization in Equations (8)-(11) is strongly NP-hard
as complexity grows exponentially with |D|.
[0037] The optimization for pricing can be re-written in a manner
that vastly decreases graph size allowing optimization to be
efficiently achieved for the RCSP solver. We exploit the fact that
given the space-time positions where item pick-ups occur, we can
solve of the remainder of the problem as independent parts. Each
such independent part is solved as a shortest path problem, which
can be solved via a shortest path algorithm such as Dijkstra's
algorithm.
[0038] We now consider a graph with node set P.sup.2 with edge set
E.sup.2, decision x.sup.2.sub.pipjg {0, 1} and weights
.kappa..sup.2. There is one node in P.sup.2 for each p P.sup.+
excluding those for p P, i.e., P.sup.2=P.sup.+\P. For any p.sub.i,
p.sub.j P.sup.2, (p.sub.i, p.sub.j) .epsilon..sup.2 IFF there
exists a path from p.sub.i to p.sub.j in .epsilon..sup.+ traversing
only intermediate nodes that exist in P. We set
.kappa..sup.2.sub.pipj to be the weight of the shortest path from
p.sub.i to p.sub.j in .epsilon..sup.+ using only intermediate nodes
in P. This is easily computed using a shortest path algorithm. We
set x.sup.2.sub.pipjg=1 IFF p.sub.i is followed by p.sub.j in robot
route g when ignoring nodes in P. Replacing .epsilon..sup.+, x with
.epsilon..sup.2, x.sup.2 respectively in Equations (8)-(11) we have
a smaller but equivalent optimization problem permitting more
efficient optimization.
[0039] The optimization in Equations (8)-(11) over .epsilon..sup.2
requires the enumeration of all d D, t [t.sup.-.sub.d,
t.sup.+.sub.d], which is expensive. As a result, we circumvent the
enumeration of all d D, t [t.sup.-.sub.d, t.sup.+.sub.d] pairs by
aggregating time into sets in such a manner so as to ensure exact
optimization during pricing. For every d D, we construct T.sub.d,
which is an ordered subset of the times [t.sup.-.sub.d,
t.sup.+.sub.d+1] where T.sub.d includes initially t.sup.-.sub.d and
t.sup.+.sub.d+1 and is augmented as needed. We order these in time
where T.sub.jd is the j'th value ordered from earliest to latest.
T.sub.d defines a partition of the window [t.sup.-.sub.d,
t.sup.+.sub.d] into |T.sub.d|-1 sets, where the j'th set is defined
by [T.sub.dj, T.sub.dj+1-1]
[0040] We use P.sup.3, .epsilon..sup.3, .kappa..sup.3, x.sup.3 to
define the graph and solution mapping. Here P.sup.3 consists of
p.sub.+, p.sub.-, p.sub.r .A-inverted..sub.r R and one node
p.sub.dj for each d D, j T.sub.d. We define x.sup.3.sub.p+pdjg=1 if
route g services item d at a time in [T.sub.dj, T.sub.dj+1-1] as
its first pick up. The remaining x terms are defined similarly over
aggregated time sets. We assign each .kappa..sup.3.sub.pipk to be
some minimum k.sup.2 over the possible paths in (P.sup.2,
.epsilon..sup.2) associated with p.sub.i, p.sub.k P.sup.3. We set
.kappa..sup.3.sub.ppdj=min.sub.t [T.sub.dj,
T.sub.dj+1.sup.-1].kappa..sup.2.sub.ppdt for all p {p.sub.+,
p.sub.r.A-inverted..sub.r R}. We set
.kappa..sup.3.sub.p+pr=.kappa..sub.p+pr. We set
.kappa..sup.3.sub.pdjp-=min.sub.t [T.sub.dj,
T.sub.dj+1.sup.-1].kappa..sup.2.sub.pdtp-. For any pair of unique
d.sub.i, d.sub.k and windows j.sub.i, j.sub.k we set
.kappa. p d i .times. j i .times. p d k .times. j k 3 = min t 0
.di-elect cons. [ d i .times. j i , d i .times. .times. j i + 1 - 1
] t 1 .di-elect cons. [ d k .times. j k , d k .times. .times. j k +
1 - 1 ] .times. .kappa. p d i .times. t 0 .times. p d k .times. t 1
2 . ##EQU00004##
[0041] Evaluating each of the .kappa..sup.3 terms amounts to
solving a basic shortest path problem (no resource constraints),
meaning not all .kappa..sup.2 terms mentioned in these
optimizations need be explicitly computed. Replacing .sup.+ with
.sup.3 in Equations (8)-(11) we have a smaller optimization problem
permitting more efficient optimization, which provides a lower
bound on Equations (8)-(11).
[0042] Optimization produces a feasible route when each item in the
route is associated with exactly one unique time. In pursuit of a
feasible route, we add the times associated with items in the route
to their respective T.sub.d sets. We iterate between solving the
RCSP over .epsilon..sup.3 and augmenting the T.sub.d until we
obtain a feasible route. This must ultimately occur since
eventually T.sub.d would include all t T for all d D. Though it
should occur much earlier in practice. We provide pseudocode for
this pricing method in Algorithm 2 illustrated in FIG. 4
[0043] Solving the pricing problem is the key bottleneck in
computation experimentally. One key time consumer in pricing is the
computation of the .kappa. terms, which can easily be avoided by
observing that .kappa..sup.2, .kappa..sup.3 terms are offset by
changes in .lamda..sub.d and .lamda..sub.r but the actual route
does not change so long as .lamda..sub.e, .lamda..sub.p, and
.lamda..sub.t are fixed. We resolve the RMP fully only periodically
so that we can perform several round of pricing using different
.lamda..sub.d, .lamda..sub.r terms leaving the .lamda..sub.e,
.lamda..sub.p, .lamda..sub.t fixed.
[0044] We ran two sets of experiments to empirically study our
model. In the first set, we test our model on two classes of
random, synthetic problem instances, recording relevant performance
and solution statistics. We examine the distribution of these
results, and we compare our algorithm to a modified version
employing MAPF to assess the added value of the algorithm's
consideration of robot collisions in the formulation.
[0045] We study the performance of our algorithm on two distinct
problem classes where each class includes a set of 100 random
instances with specific, shared parameters. Each class shares the
same grid size, number of time steps, number of serviceable items,
number of map obstacles, and number of robots. Given a set of
problem parameters, a single instance additionally includes a
random set of obstacle locations, item locations and their
respective demands and time windows, and extant robot start
locations. We solve each instance over the class, recording the LP
objective solution and solving the corresponding ILP over the
column set G obtained through CG.{grave over ( )}und) and the lower
bound (the LP objective solution) divided by the lower bound. We
normalize so as to efficiently compare the gap obtained (upper
bound--lower bound) across varying problem instances. Experiments
are run in MATLAB and CPLEX is used as our general purpose MIP
solver.
TABLE-US-00001 TABLE 1 10 .times. 10 grid results over 100 random
problem instances LP Integral Time (sec) Iterations Objective
Objective Relative Gap mean 236.3 24.7 -581.0 -574.6 .01 median
160.0 24 -586.2 -581 .01
[0046] We solve the RCSP in pricing using an exponential time
dynamic program. In each round of pricing we return the twenty
lowest reduced cost columns we obtain, if they all have negative
reduced cost. Otherwise, we return as many negative reduced cost
columns as we obtain. We update .lamda..sub.t, .lamda..sub.p,
.lamda..sub.e, and the associated graph components every three CG
iterations, unless we are unable to find a negative reduced cost
column in a given iteration, in which case update all dual
variables and rerun pricing. If at any point pricing fails to find
a negative reduced cost column while all dual variables are up to
date, then we have finished optimization and we conclude CG. To
ensure feasibility for the initial round of CG, we initialize the
RMP with a prohibitively high cost dummy route g.sub.r,init for
each r R, where all G.sub.dgr,init, G.sub.tgr,init, G.sub.pgr,init,
G.sub.egr,init=0 but G.sub.rgr,init=1. These dummy routes represent
and active robot route and thus guarantee that Equation 4 is
satisfied. They ensure feasibility, but are not active at
termination of CG due to their prohibitively high cost.
[0047] In our first class of problems we use a 10.times.10 grid, 4
total robots with 2 initially active, 15 serviceable items, and 30
total time steps. Each robot, including the extant ones, has a
capacity of 6, while each item has a random capacity consumption
uniformly distributed over the set {1, 2, 3}. We set both
.theta..sub.1 and .theta..sub.2 to 1, and the reward for servicing
any item, .theta..sub.d, is -50. Each item's time window is
randomly set uniformly over the available times and can be up to 20
time periods wide. Each map has 15 random locations chosen to serve
as obstacles that are not traversable. We solve 100 unique random
instances and aggregate the results in Table 1 above. A sample
problem with the solution routes is shown in FIG. 5. Each plot in
FIG. 5 shows a snapshot in time of the same instance's solution. A
snapshot shows each robot's route from the initial time up to the
time of the snapshot. We see that over the problem instances in
this class we have an average run time of 160 seconds requiring on
average 24.7 CG iterations. We report an average LP objective of
-581.0 and an average relative gap of 0.01, thus certifying that we
are efficiently producing near optimal solutions. In 93 out of the
100 instances the approximate solution to Equations (1)-(6) reused
robots after they returned to the launcher. In FIG. 5, robot route
results are shown for a single instance over 3 snapshots in time.
Each track is a robot route up through that time step. Traversable
cells, obstacles, the starting/ending launcher, item locations, and
extant robot locations are all noted in the legend--(Left): t=8
snapshot; (Middle): t=16 snapshot; (Right): t=30 (end time)
snapshot.
[0048] In our second class of problems we use a 20.times.20 grid, 5
total robots with 2 initially active, 25 serviceable items, and 100
total time steps. Each robot, including the extant ones, has a
capacity of 6 while each item has a random capacity consumption
uniformly distributed over the set {1, 2, 3}. We set both
.theta..sub.1 and .theta..sub.2 to 1 and the reward for servicing
any item, .theta..sub.d, is -50. Each item's time window is
randomly set uniformly over the available times and can be up to 8
time periods wide. Each map has 40 random locations chosen to serve
as obstacles that are not traversable. We run on 100 unique random
instances and aggregate the results in Table 2, below.
TABLE-US-00002 TABLE 2 20 .times. 20 grid results over 100 random
problem instances LP Integral Relative Time (sec) Iterations
Objective Objective Gap mean 478.8 30.1 -639.4 -6329.5 .02 median
389.0 30.0 -643.5 -632 .01
[0049] We see in this class of instances we get an average run time
of 478.8 seconds and an average of 30.1 iterations of CG. We get an
average LP objective of -639.4 and a relativity gap of 0.01, again
showing that we are efficiently producing near optimal solutions.
In all 100 instances the approximate solution to Equations (1)-(6)
reused robots after they returned to the launcher. We see a slight
increase in the iterations required for the second problem class
with respect to the first problem class. We see a larger growth in
the time required for convergence. We expect this trend can be
alleviated with the application of heuristic pricing. Heuristic
pricing attacks the pricing optimization problem through the use of
heuristic methods. Since we need only produce a negative reduced
cost route through each round of pricing, not necessarily the
minimum one, heuristic pricing can hasten CG by saving
computational time. Such a heuristic would produce approximate
solutions with respect to the ordering of the items but still be
optimal given a particular ordering. We also see a very small
increase in the relative gap on larger problem instances. Though
most problems on the 20.times.20 grid still have a very small gap,
we start to see more problems with a gap close to 5%. The relative
gap can be reduced by tightening the relaxation through the use of
subset row inequalities.
TABLE-US-00003 TABLE 3 Objective value results for both algorithms
over 30 random instances. Our full approach is labeled CG. We
compare against modified CG + MAPF. CG modified CG + MAPF
Difference (CG - MAPF) mean -124.6 -116.8 -7.9 median -122.0 -111.0
-1.0
[0050] We compare our algorithm to a modified version that
incorporates MAPF. This version will initially ignore robot
collision constraints but ultimately consider them after a set of
serviceable items are assigned to specific robots. The modified
algorithm works as follows. We solve a given problem instance using
our CG algorithm, but we neglect the collision constraints, meaning
.lamda..sub.p=0, .lamda..sub.e=0, .A-inverted..sub.p P, e
.epsilon.. This closely resembles a vehicle routing problem and
delivers us a set of robot routes, including the items serviced by
each robot, however this could include collisions. We then take the
disjoint set of items serviced and feed them to a MAPF solver. The
MAPF solver delivers a set of non-colliding robot routes, each
attempting to service the set of items assigned to it. If the MAPF
solver fails to provide a valid route for a particular robot (i.e.,
it cannot make it back to the launcher in time) that route is
neglected in the algorithm's final solution.
[0051] We compare the resulting objective values from our full CG
approach to this modified approach. For the purposes of this
comparison, we neglect time constraints for the items so as to be
generous to the MAPF solver, which is not equipped to handle time
windows for items. We solve 30 random instances with the same
parameters. We use a 20.times.20 grid, 35 serviceable items, 100
random obstacles, 9 total robots, 1 extant robot, and 25 total time
steps. We set .theta..sub.1 to 1, .theta..sub.2 to 0, and the
reward for servicing any item, .theta..sub.d, to -15. The objective
value results for both approaches are show in table 3. A side by
side plot of the objective values are shown in FIG. 6, wherein the
full CG approach is shown and compared against the modified column
CG+MAPF approach.
[0052] We see an average objective difference of -7.9 and a median
difference of -1.0 from the modified algorithm to our full
algorithm. We note from looking at FIG. 6 that many instances
deliver very similar objective results, however some show drastic
improvements for our algorithm. These instances largely include
robot routes that the MAPF algorithm was unable to find a complete
route for within the time constraint given the potential collisions
with other robots. With such problems we see it is critical to
employ our full algorithm that jointly considers routing and
assignment.
[0053] The systems and methods of the present disclosure unify
multi-agent path finding with vehicle routing/column generation to
produce a novel approach applicable to broad classes of multi-robot
planning (MRP) problems. The system treats MRP as a weighted set
packing problem where sets correspond to valid robot routes and
elements correspond to space-time positions. Pricing is treated as
a resource-constrained shortest-path problem (RCSP), which is
NP-hard but solvable in practice. We solve the RCSP by limiting the
time windows that need be explored during pricing. It is noted that
the system can be extended to tighten the LP relaxation using
subset row inequalities and to ensure integrality with
branch-and-price. Subset row inequalities are trivially applied to
sets over the pickup items since they do not alter the solution
paths. Similarly, branch-and-price would be applied to sets over
pickup items. Additionally, the system can incorporate heuristic
pricing to solve the resource-constrained shortest-path problem in
pricing more efficiently, thus increasing the scalability of the
algorithm. The system provides insight into the structure of dual
optimal solutions and the effect of smoothing. Dual values should
change smoothly across space and time, encouraging solutions over
the course of column generation.
[0054] Having thus described the system and method in detail, it is
to be understood that the foregoing description is not intended to
limit the spirit or scope thereof. It will be understood that the
embodiments of the present disclosure described herein are merely
exemplary and that a person skilled in the art may make any
variations and modification without departing from the spirit and
scope of the disclosure. All such variations and modifications,
including those discussed above, are intended to be included within
the scope of the disclosure. What is desired to be protected by
Letters Patent is set forth in the following claims.
* * * * *