An optimization algorithm may be used to determine a solution for a problem in which the solution considers all variables and constraints related to the problem and provides a lowest cost configuration of the values for all the variables. For example, in a televised event, a plurality of cameras may be used to capture the event. The cameras may move along planned trajectories to fully capture the event. Accordingly, the problem associated with such a scenario may be to determine the planned trajectories for the cameras that incorporate the variables and constraints associated therewith. Such variables and constraints may include no overlap of space as the cameras cannot physically be co-located at a common time, a trajectory path that provides a sufficient video capture of the event, a tracking algorithm for the occurrences during the event, etc. Through incorporation of all these considerations, the optimization algorithm may determine the trajectories of the cameras to provide the lowest cost solution (e.g., least distance to be covered by the cameras, best coverage of the event, least energy requirements, etc.). However, most optimization algorithms require significantly high processing requirements for all these considerations to be assessed as well as provide the lowest cost solution to the problem.
A conventional algorithm used for convex optimization is the Alternating Direction Method of Multipliers (ADMM). Conventionally, the ADMM algorithm is a variant of an augmented Lagrangian scheme that uses partial updates for dual variables. This algorithm has also been utilized and shown to be well-suited for distributed implementations. Further developments in using the ADMM algorithm have included being used in applications such as Linear Programming (LP) decoding of error-correcting codes and compressed sensing. However, the ADMM algorithm has in practice been used exclusively for convex optimization problems whereas determining optimal trajectories is not convex. Another conventional approach for optimization uses graphical models in which a graph denotes conditional dependencies between random variables. The graphical models often are combined with a Belief Propagation (BP) message-passing algorithm in which inferences are performed on the graphical models. The BP message-passing algorithm calculates the marginal distribution for each unobserved node, conditional on any observed nodes within the graphical model.
Even with altering the above conventional approaches to fit the optimization problem of determining trajectories, a further consideration in determining optimal trajectories involves the number of dimensions in which the objects may move. For example, the cameras may be limited to a surface upon which the camera is placed upon such as mounted on a land vehicle, placed on rails or tracks, etc. That is, this may represent a two-dimensional path restriction as they are limited to move along this plane. In another example, the cameras may be free to move in any direction which may represent a three-dimensional path availability such as aerial movements (e.g., mounted on an unmanned aerial vehicle) or underwater movements (e.g., mounted on an autonomous underwater vehicle). Therefore, even if the ADMM and/or BP algorithms are altered for use in the less complex two-dimensional analysis of determining optimal trajectories, the applicability of these altered algorithms will have limited applicability to the three-dimensional analysis.
The exemplary embodiments relate to a device and method for planning trajectories for multiple agents. The exemplary embodiments may be further understood with reference to the following description and the appended drawings, wherein like elements are referred to with the same reference numerals. The exemplary embodiments describe a method and device for generating an optimization solution. Specifically, the method and device utilize a message-passing version of the ADMM algorithm that is applicable to determining trajectories that may travel within a three-dimensional space. The message-passing algorithm includes a weighting system in which a message passed between nodes of a graphical model may include weights associated with confidence values of the messages. The optimization solution, the generation thereof, the message-passing algorithm, the ADMM algorithm, the confidence weighting system, and a related method will be described in further detail below.
The exemplary embodiments provide a mechanism for planning collision-free paths for multiple agents using optimization methods. Specifically, the exemplary embodiments utilize proximal algorithms in the mechanism. As will become evident below, the proximal algorithms used with the exemplary embodiments provide parallelization and decentralization such that the speed with which the algorithms may generate good quality solutions is improved and its ability to incorporate different proximal operators is more efficient. The proximal operators may ensure that paths satisfy a desired property that may be initial constraints that are applied to the problem. Through updates and modifications to the proximal operators through the exemplary embodiments, they may be applied to paths beyond two-dimensions and allow for intermediate waypoints to be independent of agents instead of being preassigned to specific agents. The new proximal operators according to the exemplary embodiments may deal with agents moving in arbitrary dimensions that more efficiently compute and further features such as landmarks may be introduced which are space-time positions that are automatically assigned to the set of agents under different optimality criteria.
Initially, the formulation of path planning may be described as an optimization problem. As an optimization problem, the incorporation of the proximal algorithms according to the exemplary embodiments is hereby introduced. For example, a system may have p spherical agents in Rd of radius {ri}i=1p. Accordingly, the objective is to find collision free paths {xi(t)}i∈[p],i∈[0,T] for all agents between a respective specified initial position (xiinit)i=1p at time 0 and specified final position {xifinal}i=1p at time T. In a simplest case, the total time from 0 to T may be divided into intervals of equal length and the path {xi(t)}t=0T of agent i∈[p] is parametrized by a set of break points {xi(s)}s=0η such that xi(t)=xi(s) for t=sT/η and all s. It is noted that between break points, agents may be assumed to have zero-acceleration.
In this manner, a global path planning may be expressed as an optimization problem with an objective function that is a large sum of simple cost functions. Each function may account for a different aspect of the problem. Using the above notion, the following may be solved for the problem:
The function ƒcoil prevents agent-agent collisions. That is, the function ƒcoil is zero if ∥αxi(s)+(1−α)xi(s+1)−(αxj(s)+(1−α)xj(s+1)∥ri+rj for all α∈[0,1] and infinity otherwise. The function ƒwall prevents agents from colliding with obstacles (i.e., non-agent objects). That is, the function ƒwall is zero if ∥αxi(s)+(1−α)xi(s+1)−y∥≥ri for all α∈[0,1],y∈W and is infinity otherwise. W is a set of points defining an obstacle. W may be a line between two points xL and xR in a plane and a summation ΣW is across a set of obstacles. The functions ƒvel and ƒdir may impose restrictions on the velocities and direction changes of the paths, respectively. The function ƒpos may impose boundary conditions. That is, the function ƒpos is zero if xi(0=xiinit) (or if xi(η)=xifinal) and infinity otherwise.
As discussed above, the multi-agent path planning uses proximal algorithms for solving. Furthermore, the multi-agent path planning is formulated as a large non-convex optimization problem. The exemplary embodiments further utilize the Alternating Direction Method of Multipliers (ADMM) and a variant that introduces a Three Weight Algorithm (TWA). Specifically, the exemplary embodiments provide how an ADMM algorithm for a constrained optimization problem may be derived as a specific case of a message-passing version of the ADMM algorithm for convex optimization, particularly when the agents are allowed to move along paths in a three-dimensional space. The message-passing algorithm is improved upon through introduction of the TWA for the messages between nodes of a graphical model with “certain” and “no opinion” weights as well as the standard weight used in the ADMM. The “certain” messages allow the optimization algorithm to implement constraint propagation while the “no opinion” messages speed convergence for some problems by making the optimization algorithm focus only on active constraints. The three-weight version of message-passing in the ADMM further provides greatly improved performance in non-convex problems while retaining the exact performance of ADMM for convex problems. It is noted that the nodes of the graphical model may be equivalent to the proximal operators described above. Thus, the term “node” as related to the graphical model and the term “proximal operator” may be used interchangeably.
The exemplary embodiments overcome the conventional limits of the ADMM algorithm and are used as a well-defined algorithm for general optimization functions and provide a powerful heuristic algorithm even for NP-hard non-convex problems. When the objective function being optimized by the ADMM algorithm consists entirely of “hard” constraints, the ADMM algorithm reduces to a message-passing version of the “Divide and Concur” (DC) constraint satisfaction algorithm which is effective for a very wide variety of non-convex constraint satisfaction problems. Again, the exemplary embodiments are further adapted for application to agents moving in a three-dimensional space.
As will be described in further detail below, the use of the message-passing algorithm between variables and cost functions in the graphical model enables messages to be sent between these nodes until a consensus is reached; that is, until an optimization solution has been generated. Specifically, messages are transmitted from right side nodes representing a first set of consensus functions to left side nodes representing a second set of functions. That is, the left side functions may be the proximal operators. The left side nodes process those messages and compute new messages that are transmitted back from left side nodes to the right side nodes. The right side nodes then use the messages that have come from the left side nodes to compute new messages that are sent to the left side nodes, and the cycle continues. The weights associated with the messages are determined such that the messages have an appropriate impact in the processing of the messages to compute new messages. The weights for the messages have one of three different weights. A “certain” weight indicates that a cost function or variable (i.e., one of the nodes) is certain (e.g., 100% confidence) about a value of a variable and all other opinions should defer thereto; a “no opinion” weight indicates that the node has no opinion about the value (e.g., may be omitted in the considerations for the consensus); and a “standard” weight indicates that the message is weighted equally with all other standard weight messages.
In view of the above discussion of the manner in which the message passing operates, the ADMM and the TWA are iterative algorithms that do not access the objective function directly but indirectly through multiple algorithmic blocks. As used above, these algorithmic blocks may be the nodes of the graphical model or the proximal operators. The blocks may be used one per function-term in the objective. At each iteration, these proximal operators may be applied independently and so both the TWA and the ADMM are easily parallelized. In general, the ADMM and the TWA are not guaranteed to converge for non-convex problems.
In using the TWA version of the message-passing ADMM, the ADMM iteratively updates five kinds of variables living on the edges of a factor graph as used in a graphical model that is composed of function nodes and variable nodes. The factor graph represents the decomposition of the objective function into separate terms. The ADMM is guaranteed to solve convex problems but empirically, the ADMM and the TWA can also find good feasible solutions for large non-convex problems via the modifications described above.
As discussed above with proximal algorithms, the ADMM does not access a function ƒ in the objective directly but rather indirectly through its proximal operator. For example, the proximal operator may be:
In this proximal operator, ∈ is used instead of = to indicate that, for a non-convex function ƒ, the operator may be one-to-many, in which case extra tie-breaking rule needs to be implemented. The proximal operators appear in the steps that update the left side nodes. Thus, the implementation of these proximal operators is emphasized as an inner-loop step in this framework that provides significant information in the determination of the solution to this optimization problem. For example, when ƒ=ƒvel takes a quadratic (e.g., kinetic energy) form, the operator such as used in Equation 2 has a simple closed-form expression. However, for E(r) or E(r), the operator involves solving a semi-infinite programming (SIP) problem. Those skilled in the art will understand that the SIP problem involves solving a non-trivial problem with an infinite number of constraints and a finite number of variables.
The ADMM according to the exemplary embodiments rely upon two constant parameters of ρ and γ>0. Their performance may be improved by using different values of ρ. The TWA improves performance further by assigning to each edge two values {right arrow over (ρ)} and and dynamically assigning to them values in {0,const.,∞}, where {right arrow over (ρ)} represents a direction from a node on the left side (e.g., of the graphical model on a factor graph representation) to another node on the right side and represents an opposite direction. That is, implementing the TWA requires computing proximal operators and specifying outgoing weights {right arrow over (ρ)} of each proximal operator. In the TWA, there are also incoming weights which correspond to the ρ that appear in the definition of the proximal operators but having a fixed update scheme. For the collision operator and landmark operator as described in further detail below, a computation of outgoing weights may be used in which if an operator maps a set of input variables (n1, n2, . . . , nk) to a set of output variables (x1, x2 . . . , xk), then, if ni≠xi, a first setting of {right arrow over (ρ)}i=1 may be used, otherwise {right arrow over (ρ)}i=0 may be used when ni=xi. That is, if a variable is unchanged by the operators, the outgoing weight associated to it should be zero, otherwise it is 1.
With the above basis of using the variant of the ADMM and utilizing the TWA, the exemplary embodiments further modify this mechanism to provide a set of algorithmic building blocks in the proximal operators to plan paths for a system of multiple independent agents (e.g., robots) that need to move optimally across a set of locations and avoid collisions with obstacles and each other. Such an optimization problem may be crucial in applications involving automated storage, exploration, and surveillance. The paths of the agents also incorporates the volume of the agent itself, thereby the agents may further incorporate a clearance along its path. Even if each agent has a few degrees of freedom since the paths may be within a three-dimensional space, the joint system is complex and this problem has a relatively high degree of difficulty.
There have been limitations in previous attempts of using the variant of the ADMM with the TWA in the optimization problem being addressed by the exemplary embodiments. One limitation is that solving the SIP problem for robots is limited to two-dimensional movements since the problem is interpreted as a mechanics problem which excludes the applications for which the exemplary embodiments specifically relate. Another limitation is that the prior mechanism does not allow robots to automatically select waypoint positions from a set of reference positions. Such a feature may be required when, for example, problems involve robots in formations such as with the unmanned aerial vehicles and autonomous underwater vehicles. Rather, any reference position must be pre-assigned to a specific robot.
The exemplary embodiments address at least these limitations. Thus, in a first feature, the exemplary embodiments may be applied to a SIP problem involved in collision proximal operators that are reduced to solving a single-constraint non-convex problem with a solution that is determined explicitly in arbitrary dimensions, and that also more efficiently determines the solution, even in two dimensions. In a second feature, the exemplary embodiments provide further modified proximal operators that automatically assign agents to a subset of reference positions and penalize non-optimal assignments. These features may allow solutions to be determined for instances of path planning problems involving many agents that may need to move tightly together. Furthermore, these feature may be used for proximal algorithms to solve other SIP problems. That is, it is noted that the application to path planning is only exemplary and the exemplary embodiments may be applied to other optimization problems.
The processor 105 may further execute a plurality of engines that are configured to perform a functionality associated with generating the optimization solution. As illustrated, the processor 105 may execute a variable engine 125, a cost engine 130, a landmark engine 132, a factor graph engine 135, a constraint engine 140, an optimization engine 145, and a signal generating engine 150. The engines will be described in further detail below.
The optimization functionality executed by the processor 105 utilizes a graphical model in order to generate the optimization solution. When relating to optimization, the graphical model includes a first plurality of cost functions and a second plurality of variables, as well as edges connecting cost functions to variables. The cost functions may represent either “soft” costs or “hard” constraints. An edge exists between a cost function and a variable if the variable is involved in the cost function. In a “soft” cost function, the cost function encodes a preference for the connected variables to have particular values, but that preference may be violated, while in a “hard” constraint version of a cost function, the preferences must not be violated. Each cost function may be connected to one or more of the variables and vice versa.
In view of the manner in which the optimization functionality is utilized, the variable engine 125 may receive the set of variables while the cost engine 130 may receive the set of cost functions. As will be described in further detail below, the landmark engine 132 may receive a set of landmarks which represent a point or group of points in the space that the agent should attempt to visit via its path planning. The factor graph engine 135 may generate the graphical model for the variables and the cost functions. Through the connections between the cost functions and the variables, the constraint engine 140 may provide the lines of the graphical model to the factor graph engine 135. It is again noted that the nodes of the graphical model may be the proximal operators of the exemplary embodiments. All this data may be received by the optimization engine 145 that generates the optimization solution. The signal generating engine 150 may generate a signal based upon the generated optimization solution such that a particular application that requires this solution may receive it. For example, a particular application may be trajectories for a plurality of cameras. The signal generating engine 150 may generate signals for each camera that indicate the trajectory at which the camera is to move.
As illustrated in
Due to the bipartite structure of a Forney factor graph such as the graphical model 200, the cost functions may be split into two groups: the nodes on the left may represent the original soft cost functions and hard constraints and the nodes on the right may represent equality constraints. Each edge variable xij sits on a left side of the edge and a copy may be made denoted as zij that sits on the right side of the edge. The xij and zij variables are referred to as “belief” variables because the xij variables may intuitively be thought of as “beliefs” that the left-hand side of the factor graph has about the values of the original variables rj, while the zij variables may be thought of as “beliefs” that the right-hand side of the factor graph has about the values of the original variables rj. The objective function E(x) may then be split into a sum of the left cost functions denoted as ƒ(x) and the right cost functions denoted as g(z), where z is a vector made from all the zij belief variables.
With the graphical models described above and the blocks representing proximal operators, the exemplary embodiments provide no-collision proximal operators to determine solutions for the optimization problem. Specifically, the proximal operator associated with the function ƒcoll may ensure there is no collision between two agents of radius r and r′ that move between two consecutive break-points. The variables associated to the two agents and the variables associated to the two break-points may be distinguished. Specifically, a prime (′) may be used to distinguish the variables of the agents while an underscore (_) and an opposite underscore (
The exemplary embodiments provide an efficient procedure to solve the above Equation 3 SIP problem for agents in arbitrary dimensions by reducing it to a max-min problem. As will be described and explained in further detail below, Equation 3 is essentially equivalent to a “most costly” of the problems of single-constraint problems parameterized by a such as in the following family:
It is noted that since Equation 4 has a simple closed-form solution, Question 3 may be solved in an efficient manner for two-dimensional objects, as will be described below. It is also noted that the proximal operator according to the exemplary embodiments may further be utilized for planning in three-dimensions as well as four-dimensions.
With regard to Equation 3 being an equivalent to the “most costly” of the problems, a theorem as described below may be used. Specifically, a theorem may be used where if ∥α(n−n′)+(1−α)(
and the unique minimizer of Equation 4 is:
It is noted that under a few conditions, a Remark may be provided that shows the above theorem may be used to determine a solution to the Equation 3 by solving a simpler Equation 4 for a special value of α. However, in numerical implementations, the conditions of the above theorem are easy to satisfy and the x*(α*) obtained is the unique minimizer of Equation 3. This principle is described in further detail below.
In other words, to find one solution to Equation 3, α* may be found by maximizing Equation 5 and then minimizing Equation 4 using Equations 6-9 with α=α*. Both steps may be performed efficiently as will be described below. The intuition behind the above theorem is that if the optimization problem as expressed in Equation 3 is solved for the “worst” constraint (the α* that produces the largest minimum value), then the solution also satisfies all other constraints. That is, it also holds for all other α∈[0,1]. This may be made precise using the following Lemma that is used to prove the above theorem. It is noted that ∂i is used to denote the derivative of a function with respect to the ith variable. The proof of the Lemma is described below.
The following provides various reasons that illustrate why the above Remark holds true. In a first point, if the various ρ are all positive, the objective function of Equation 3 is strictly convex and the constraint ∥x,x′,
In a second point, the problem expressed in Equation 3 may be interpreted as resolving the following conflict. Specifically, the conflict may be that a first agent wants to move from n at a time 0 to
In a third point, it may be shown from the continuity of the objective function of Equation 3, from the continuous differentiability of g(x,α)=∥α(x−x′)+(1−α)(
The above referenced Lemma utilizes A as a convex set in , the function g:d×A→,(x,α)g(x,α) which is convex in α and continuously differentiable in (x, α) and the function ƒ:d→,xƒ(x) which is continuously differentiable and has a unique minimizer. For every α∈A, h(α) may be denoted the minimum value of minx:g(x,α)≥0ƒ(x) and if the minimum is attained by a feasible point, this may be denoted by x*(α). Under these conditions, if α*∈arg maxα∈Ah(α), and if x*(α) exists around a neighborhood of α* in A and is differentiable at α* and if ∂1g(x*(α*),α*)≠0, then x*(α*) minimizes to minx:g(x,α)≥0∀α∈A ƒ(x).
In showing the proof for the above Lemma, two separate cases may be considered. In a first case, it may be assumed that x*(α*) is such that the expression g(x*(α*),α*)>0 is true. This implies that x*(α*) is a minimizer of minx ƒ(x) which implies that minx:g(x,α*)≥0 ƒ(x)=minx ƒ which implies that minx:g(x,α)≥0ƒ(x)≥minx ƒ(x)=minx:g(x,α*)≥0ƒ(x)=maxα′∈Aminx:g(x,α*)≥0ƒ(x)≥minx:g(x,α)≥0ƒ(x). That is, the expression minx:g(x,α)≥0 ƒ(x)=ƒ(x*(α*)) is true for all α∈A. Since ƒ(x) has a unique minimizer, x*(α*) must be feasible for the problem minx:g(x,α)≥0 ƒ(x) which implies that g(x*(α*),α)≥0 for all α∈A. That is, x*(α*) is a feasible point of minx:g(x,α)≥0∀α∈A ƒ(x) and attains the smallest possible objective value, thereby minimizing it.
In a second case, it may be assumed that g(x*(α*),α*)=0. To finish the proof, it suffices to show that ν∂2g(x*(α*)α*)≥0 for all ν∈ such that α*+ν∈A. To illustrate this, it is first noted that, if this is the case, then, for all α∈A, convexity implies that g(x*(α*),α)≥g(x*(α*),α*)+(α−α*)∂2g(x*(α*),α*)=(α−α*)∂2g(x*(α*),α*)≥0 which implies that x*(α*) is a feasible point for the problem minx:g(x,α)≥0,∀α∈A ƒ(x). Secondly, it is noted that the following expression holds ƒ(x*(α*))≥minx:g(x,α)≥0,∀α∈A ƒ(x)≥maxα∈A minx:g(x,α)≥0 ƒ(x)=ƒ(x*(α*)). This implies that x*(α*) minimizes minx:g(x,α)≥0,∀α∈A ƒ(x).
Given the above, ν∂2g(x*(α*),α*)≥0 may be shown for all ν∈ such that α*+ν∈A. First, it is noted that since ƒ is differentiable and x*(α) exists and is differentiable at x*(α*), then, by the chain rule, h(α) is differentiable at α*. In addition, it is noted that if α* maximizes h, then if ν∈ is such that α*+ν∈A, the directional derivative of h in the direction of ν evaluated at α* must be non-positive. That is, the expression ν∂1h(α*)=ν∂1ƒ(x*(α*))†∂1x*(α*)≤0 holds true. Second, it is noted that in a small neighborhood around α*, the term x*(α) exists and is continuous (because x*(α*) is differentiable) which, by the continuous-differentiability of g and the fact that ∂1g(x*(α*),α*≠0), implies that ∂1g(x*(α),α)≠0 in this neighborhood. Therefore, in a small neighborhood around α*, the problem expressed as minx:g(x,α)≥0 ƒ(x) has a single inequality constraint and ∂1g(x*(α),α)≠0 which implies that x*(α), which is assumed exists in this neighborhood, is a feasible regular point and satisfies the first-order necessary optimality conditions below:
∂1ƒ(x*(α))+λ∂1g(x*(α),α)=0 (Equation 10)
λg(x*(α),α)=0 (Equation 11)
g(x*(α),α)≥0 (Equation 12)
λ≤0 (Equation 13)
Subsequently, the directional derivative of Equation 12 may be taken with respect to α in the direction ν evaluated at (x*(α*),α*) to obtain:
ν∂1g(x*(α*),α*)†∂1x*(α*)+ν∂2g(x*(α*),α*)≥0 (Equation 14)
At the same time, by computing the inner product between Equation 10 and ∂1x* evaluated at α* and multiplying by ν, the expression ν∂1ƒ(x*(α*))†∂1x*(α*)+λν∂1g(x*(α*),α*)†∂1x*(α*)=0 may be obtained. However, since the expression ν∂1ƒ(x*(α*))†∂1x*(α*)≤0 has already been proven, the expression λν∂1g(x*(α*),α*)†∂1x*(α*)≥0 holds true. As noted above, it is again noted that it is being assumed that the expression g(x*(α*),α*)=0 is true. Therefore, the expression λ<0 is true. It thereby follows that the expression ν∂1g(x*(α*),α*)†∂1x*(α*)≤0 and Equation 14 provides the conclusion that the expression ν∂2g(x*(α*),α*)≥0 is true.
The theorem following Equations 3 and 4 may be proved as follows. The solutions to Equations 3 and 4 remain the same if the portion ∥α(x−x′)+(1−α)(
The proof for the above theorem may be shown by considering two separate cases. In a first case, the term r+r′≤minα∈[0,1]∥α(n−n′)+(1−α)(
Next, it may be assumed that r+r′>minα∈[0,1]∥α(n−n′)+(1−α)(
It may further be shown that in this case, the expression ∂1g(x*(α*),α*)≠0 is true. First, it is noted that the expression ∂1g=(∂xg,∂
As discussed above, Equations 5-9 are shown to hold when ∥α(n−n′)+(1−α)(
Initially, it is noted that if the expression ∥α(n−n′)+(1−α)(
To simplify the expressions, several block variables are introduced and expressed in the above problem of Equation 15 to provide a shorter form. Specifically, a first block variable is defined as x=(x,x′,
It is noted that it is necessary that the solutions to the above problem expressed in Equation 16 are among the points that satisfy Karush-Kuhn-Tucker (KKT) conditions. Specifically, these points satisfy:
D(x−n)+2αν=0 (Equation 17)
ν=λ(α†x) (Equation 18)
∥ν∥/|λ=r+r′ (Equation 19)
where λ≠0 is the Lagrange multiplier associated to the problem's constraint and is non-zero because it is assumed the constraint is active. As will be described in further detail below, the rest of the proof shows that there are only two points that satisfy the KKT conditions and show that, between them, the one that corresponds to the global optimum satisfies Equations 5-9.
The Equations may be written even more compactly with the following:
It may be claimed that, if 1+2λα†D−1α≠0, the inverse of the block matrix
Although the formula for the inverse of a block matrix may also be used, a simpler manner of the proof is computing the product of Equations 22 and 21 and show it equals the identity. It is evident that the block diagonal entries of the resulting product are indeed identity matrices. Since both matrices are symmetric, the remaining calculation is to verify that one of the non-diagonal block entries is zero. Indeed, such a determination may be illustrated with the following:
The linear system of Equation 20 may be solved by multiplying both sides by the inverse matrix Equation 22 to conclude the following:
Using Equation 24, the objective value of Equation 16 may be expressed with the following:
where in the last equality, Equation 23 is made of use. Referring back to the third equation in the KKT conditions, the expression ∥ν∥/λ=r+r′ is used and the following may be concluded:
Therefore, the following may further be concluded:
Because the global minimum is sought and since there is an assumption that ∥α†n∥=∥α(n−{right arrow over (n)}′)+(1−α)(
This calculation uses the fact that the expressions α†n=αΔn+(1−αΔ
To finish the proof, the validity of Equations 6-9 are proven when the expression ∥α†n∥=∥α(n−n′)+(1−α)(
If a variable
is defined in this manner, the following expression for x*(α) may be written as follows:
x*(α)=n−γD−1αα†n (Equation 32)
which holds if the expression ∥α†n∥=∥α(n−n′)+(1−α)(
With the above expressions and the proofs therefore being illustrated, the mechanism used to solve the trajectory optimization problem with the variation of the ADMM and the TWA may be further defined with other collision operators, speeding up computations, and local path planning. Furthermore, as will be described in further detail below, a landmark proximal operator may also be introduced for the mechanism such that the trajectory optimization problem applied to a three-dimensional path of the agents may be determined by the device 100.
With regard to the other collision operators (i.e., non-agent collisions), the wall-agent collision operator may be efficiently extended to path planning of trajectories of agents with obstacles in three-dimensions. To avoid a collision between a first agent having radius r and a line between points y1,y2∈d, the following constraint may be added in the overall optimization problem: ∥αx1(s)+(1−α)x1(s+1)−(βy1+(1−β)γ2)∥≥r for all α,β∈[0,1] and all s+1∈[η+1]. This constraint is associated with the proximal operator that receives (n,n′) and finds (x,
It is noted that a proximal operator may not be implemented to avoid collisions between an agent and a convex envelop of an arbitrary set of points y1,y2, . . . , yq by maximizing over α,β1, . . . , β1-q∈[0,1] the minimum of the single-constraint problem obtained from Equation 4 after replacing n′ and
With regard to the speeding up of the computations, the computational bottleneck for the collision operators is maximizing Equation 5. There may be two scenarios when avoiding this expensive step to improve performance. A first scenario may be denoted as trivial whereas a second scenario may be denoted as easy.
First, it may be noted that one skilled in the art may readily check whether x=n is a trivial feasible solution. If it is a trivial feasible solution, it must be optimal because it has 0 cost and the operator may return it as the optimal solution. This is the case if the segment from Δn=n−n′ to Δ
Second, the easy scenario may be a shortcut to directly determine if the maximizer of maxα∈[0,1]h(α) is either 0 or 1. Initially, h may be noted to have at most one extreme point in [0,1] (e.g., this may be illustrated by plotting h(α) for different values of Δn and Δ
It is further noted that if these cases do not hold, the maximizing of Equation 5 may not be avoided which may entail a scenario denoted as expensive.
With regard to local path planning, the optimization problem expressed in Equation 1 finds beginning-to-end collision free paths for all agents simultaneously, known as global path planning. It is also possible to solve path planning greedily by solving a sequence of small optimization problems, known as local path planning. Each of these problems plans the path of all agents for the next τ seconds such that, as a group, they get as close as possible to their final desired positions. These small optimization problems may be solved using a special case of the no-collision operator. Accordingly, the exemplary embodiments extend the local path planning to arbitrary dimensions (particularly to three dimensions) and improve its speed further. As will be described in further detail below, the improvements in speed will be illustrated.
As discussed above, the concept of landmarks may be introduced that, automatically and jointly, (i) produce reference points in space-time that, as a group, agents should try to visit, (ii) produce a good assignment between these reference points and the agents, and (iii) produce collision-free paths for the agents that are trying to visit points assigned to them. Therefore, the exemplary embodiments introduce the landmark proximal operator. The three points are essential, for example, to formation control in multi-robot systems and autonomous surveillance or search and are also related to the problem of assigning tasks to robots if the tasks are seen as groups of points to visit. Prior works focus on only one of these points or treat them in isolation. One application where these points are considered although separately is the problem of using color-changing robots as pixels in a display. The pixel-robots arrangement is planned frame by frame and does not automatically guarantee that the same image part is represented by the same set of robots across frames, crating visual artifacts. In contrast, the exemplary embodiments utilize a landmark formalism that enables a penalty for these situations.
The exemplary embodiments introduce landmarks as extra terms in the objective function expressed in Equation 1. With the above basis, the proximal operators associated with Equation 1 may be determined. For example, a set of landmark trajectories {yj(s)}j∈[m],s
where the variable σj indicates which agent should follow trajectory j. If σj=*, that means trajectory j is unassigned. It may be assumed that each trajectory may be assigned to at most one agent which it must follow throughout its duration. Therefore, the agent is σj∈[p]∪{*} and there exists a condition that if σj=σj′, then either j=j′ or σj=*. The overall objective function may be optimized over x and σ. It is noted that it is not equally important to follow every point in the trajectory. For example, by setting some costs equal to zero, it may effectively deal with trajectories of different lengths, different beginnings and ends, and even trajectories with holes. By setting some costs equal to infinity, it may be imposed that if the trajectory is followed, it must be followed exactly. In Equation 33, the Euclidean metric may be used but other distances may be considered (even non-convex ones) as long as the resulting proximal operators are easy to compute. It is also noted that, a priori, the term {yj(s)} is not needed to describe collision free trajectories. The other terms in the overall objective function attempts to enforce no-collision constraints and additional dynamic constraints. It is further noted that if an unreasonable set of path specifications are attempted to be satisfied, the proximal algorithm used may not converge.
The proximal operator associated to the term expressed in Equation 33 receives as an input {ni(s)} and outputs xi*(s) where i∈[p], sinit≤s≤send, and {xi*(s)} minimizes the following:
The variables σ are used only internally in the computation of the proximal operator because they are not shared with other terms in the overall objective function. The above proximal operator may be efficiently computed with the following process. First, Equation 11 may be optimized over the various x as a function of σ and then the resulting expression may be optimized over the various σ. If optimized over the various x, the term Σjwj,σ
holds true. The last equality follows from a solving of a simple quadratic problem. An optimization may be performed over the various σ by solving a linear assignment problem with cost matrix w which may be done, for example, using a simple Hungarian method, or more advanced methods thereof. Once an optimal σ* is determined, the output of the operator may be computed with the following. If i is such that {j:σj*=i}=ϕ, then xi*(s)=ni(s) for all sinit≤s≤send and if i is such that i=σj for some j∈[m], then xi*(s)=(ρini(s)+2ci(s)yj(s))/(2ci(s)+ρi) for all sinit≤s≤send.
The term expressed in Equation 33 corresponds to a set of trajectories between break-points s=sinit and s=send for which the different agents must complete. That is, each agent may follow at most one trajectory. However, an agent may be allowed to be assigned to and cover multiple landmark trajectories. One immediate manner of performing this is by adding more terms of the form expressed in Equation 33 to the overall objective function such that the kth term has all its m(k) in trajectories within the interval └sinit(k),send(k)┘ and different intervals for different k are disjoint. It is noted that doing this alone does not enable an imposition of a constraint such as the following: “the jth trajectory in the set corresponding to the interval └sinit(k),send(k)┘ must be covered by the same agent as the (j′)th trajectory in the set corresponding to the interval └sinit(k+1),send(k+1)┘.” If such a constraint were to be imposed, an additional constraint is required to be imposed that some of the σ(k) variables across different terms of the form expressed in Equation 33 are the same such as (in the previous example) σj(s)=σj′(s+1). Since the variables may now be shared across different terms, the proximal operator expressed in Equation 34 needs to be changed. Subsequently, this term receives as input a set of values {ni(s)}s,i and {nj′}j and outputs a set of values {xi*(s)}i,s and {σj*}j that minimize the following:
In the above expression, {σj}j and {n′j}j are both vectors of length p+1 where the last component encodes for no assignment and σj must be binary with only one entry. For example, if p=5 and σ2=[,0,1,0,0,0], the second trajectory in the set of trajectories is assigned to the third agent of the p agents. In another example, if σ1=[0,0,0,0,0,1], the first trajectory in the set of trajectories is not assigned to any agent. The term W may have real values and several non-zero components.
The above problem may also be solved by first optimizing over x and then over σ. By optimizing over x, the term Σjŵj,σ
Furthermore, to include constraints of the kind σj(k)=σj′(k′), a term may be added to the objective that takes the value infinity whenever the constraint is violated and zero otherwise. This term is associated with a proximal operator that receives as input n′j=(n′j(1), . . . , n′j(n)) and n′j′=(n′j(1), . . . , n′j′(n)) and outputs
Again σj and σj′ are binary vectors of length p+1 with exactly one non-zero entry. The solution has the form σj*=σj′*=[0,0, . . . ,0,1,0 . . . 0] where the 1 is in position i*=arg maxi∈[p]ρjn′j(i)+ρ′j′n′j′(i).
It should be noted that the device 100 may utilize a factor graph such as the graphical models 200, 300. Thus, the method 400 may include steps that generate these factor graphs. For example, the factor graph engine 135 may generate the graphical models via the constraint engine 140 providing data as to the relationships between the cost functions and the variables. Specifically, the relationships may be those shown in the graphical models 200, 300 for the nodes on the left and the nodes on the right.
In step 417, the device 100 (via the landmark engine 132) determines the landmarks that are introduced to the optimization problem. As discussed above, the landmark may provide a point or set of points that the agent should attempt to visit along its path from an initial position to a final position. Thus, when a path is determined for the agent that deviates from visiting the landmark, the associated cost may be affected for this path.
In step 420, the device 100 generates messages to be passed from the cost functions to the variables (e.g., the messages to be passed from the left nodes to the right nodes on the factor graph). In step 425, the device 100 also determine a respective weight to be applied to each message. As discussed above, the exemplary optimization algorithm utilizes a TWA. Accordingly, each message that is generated also includes a corresponding weight (e.g., zero, infinite, and standard). In step 430, the message and corresponding weight are transmitted from the cost functions to the variables. These steps may further incorporate the landmarks described above. Specifically, the cost functions may be affected directly by whether the agent visits the landmark or not.
In step 435, based upon the messages and weights that were received from the cost functions to the variables, the device 100 generates further messages to be passed from the variables to the cost functions. In step 440, the device 100 determines a respective weight to be applied to each of these further messages. In step 445, the further message and corresponding weight are transmitted from the variables to the cost functions.
In step 450, the device 100 determines whether there is a consensus between the messages being transmitted between the cost functions and the variables. If a consensus has not been reached, the method 400 returns to step 420 where steps 420-445 are repeated. This may repeat as many times as required for the consensus to be reached. Once the consensus is reached, the method 400 continues to step 455. In step 455, the optimization solution is generated as a function of the messages transmitted that were determined to form the consensus. That is, the optimization solution relates to a minimum being reached for each of the cost functions while still satisfying all the requirements of the variables.
It should be noted that the method 400 may include further steps. For example, the method 400 may include a criterion in which the consensus is only formed when a predetermined number of consecutive messages that are passed between the cost functions and the variables holds true. Thus, after step 450, the method 400 may include a further determination such that the satisfaction of the predetermined number is determined. In another example, the method 400 may include steps after step 425 and step 440 in which a determination is made whether nodes or input/outputs to the nodes may be ignored or removed from further computation. For example, when a zero weight or infinite weight is determined for a particular message, the graphical model may be modified to incorporate this knowledge to further improve efficiency in determining the optimization solution.
The above method 400 of
The numerical experiments have been such that the first run using the Old iteration is performed on a configuration where 8 agents each having a radius r=0.918 equally spaced around a circle of radius R=3 where each agent is required to exchange position with the corresponding antipodal agent. While running the TWA using the Old iteration, the trace of all n variables input into the Old operators. The execution speed of the Old iteration versus the New iteration have been compared on this trace of inputs, after segmenting the n variables into trivial, easy, or expensive. For global planning, the distribution of trivial, easy, and expensive inputs resulted in {0.814, 0.001, 0.185}. Although the expensive inputs are infrequent, the total wall-clock time that the New iteration takes to process them is 76 msec compared to 54 msec to process all trivial and easy inputs. By comparison, the Old iteration takes a total time of 551 msec on the expensive inputs, thereby the New iteration yielding an average speedup of 7.25× on the inputs that are most expensive to process. Similarly, the trace of the n variables input into the collision operator are collected when using the local planning method on this same scenario. It is observed a distribution of the trivial, easy, and expensive inputs equal to {0.597, 0.121, 0.282} where a total time spent in the easy and trivial cases of 340 msec for the New iteration and a total time spent in the expensive cases of 2,802 msec for the New iteration and 24,157 msec for the Old iteration. This results in an average speedup of 8.62× on the expensive inputs. For other scenarios, a similar speedup is observed on the expensive inputs, although scenarios easier than the currently used configuration have fewer expensive inputs. For example, if the initial and final target points are chosen at random instead of with antipodal targets, the distribution results in {0.968, 0, 0.032}.
The exemplary embodiments provide a method and device for generating an optimization solution for an optimization problem. Specifically, the optimization solution is a modified version of the ADMM algorithm in which the messages in the message-passing algorithm includes various weights. The weights may indicate a “certainty,” a “no opinion,” or otherwise a “standard.” Through incorporating the weights, the optimization solution may be determined in a more efficient manner. The optimization solution may also be modified through incorporation of knowledge that is determined during the course of the message-passing. Whether a reasoner hierarchy or graph dynamics are used, the knowledge may further improve the efficiency at which the optimization solution is determined. The exemplary embodiments further utilize specialized proximal operators for agent-agent collisions, non-agent collisions, and landmarks. Accordingly, the optimization solution determines straightest possible paths for the agents that move from a first configuration to a second configuration in a tight formation.
Those skilled in the art will understand that the above-described exemplary embodiments may be implemented in any suitable software or hardware configuration or combination thereof. An exemplary hardware platform for implementing the exemplary embodiments may include, for example, an Intel x86 based platform with compatible operating system, a Mac platform and MAC OS, etc. In a further example, the exemplary embodiments of the above described method may be embodied as a program containing lines of code stored on a non-transitory computer readable storage medium that, when compiled, may be executed on a processor or microprocessor.
It will be apparent to those skilled in the art that various modifications may be made in the present invention, without departing from the spirit or scope of the invention. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents.
Number | Name | Date | Kind |
---|---|---|---|
8879811 | Liu et al. | Nov 2014 | B2 |
9639813 | Yedidia | May 2017 | B2 |
20100256852 | Mudalige | Oct 2010 | A1 |
20150330209 | Panchal et al. | Nov 2015 | A1 |
20160217380 | Yedidia | Jul 2016 | A1 |
Entry |
---|
Mosabbeb et al., Multi-View Human Activity Recognition in Distributed Camera Sensor Networks, Sensors, 13, pp. 8750-8770 (Year : 2013). |
Wang et al., Solving Multiple-Block Separable Convex Minimization Problems Using Two-Block Alternating Direction Method of Multipliers, Mathematics of Computation, pp. 1-29 (Year: 2013). |
Zhou et al., 3D Shape Estimation from 2D Landmarks: A Convex Relaxation Approach, The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2015, pp. 4447-4455 (Year: 2015). |
Boyd et al., (“Distributed Optimization and Statistical Learning via the Alternating Direction Method of Multipliers”, FTML, vol. 3. No. 1(2010), pp. 1-122. |
Martins et al., “An Augmented Lagrangian Approach to Constrained Map Inference”, ICML, 2011, pp. 8. |
Alonso-Mora et al., “Reciprocal Collision Avoidance for Multiple Car-like Robots”, IEE ICRA, 2012, pp. 360-366. |
Derbinsky et al., “An Improved Three-Weight Message-Passing Algorithm”, ArXiv:1305.1961(2013). |
Bento et al., “A message-passing algorithm for multi-agent trajectory planning”, Advances in Neural Information Processing Systems (NIPS) (2013). |
Mathy et al., “Sparta: Fast global planning of collision-avoiding robot trajectories”, NIPS Workshop on Learning, Inference, and Control of Multi-Agent Systems, (2015). |
Number | Date | Country | |
---|---|---|---|
20170176994 A1 | Jun 2017 | US |