symforce.opt.optimization_problem module

class OptimizationProblem(subproblems, residual_blocks, shared_inputs=None)

Bases: object

An optimization problem.

Defined by a collection of sub_problem.SubProblem, each of which defines a set of inputs (variables in the Values) and a set of residuals. SubProblems are generally expected to expose inputs that are used by other subproblems; these dependencies should be handled by the user while constructing the residual_blocks argument. Typical workflow is to construct a set of SubProblems (which should also construct each SubProblem Inputs), build the residual_blocks Values by calling sub_problem.SubProblem.build_residuals() on each subproblem with the appropriate arguments, and then pass the subproblems and residual_blocks to the OptimizationProblem constructor.

Parameters:

• subproblems (Mapping[str, SubProblem]) – Mapping from subproblem names to subproblems

• residual_blocks (Values) – Values where each leaf is a residual_block.ResidualBlock, containing all the residuals for the problem. Typically created by calling sub_problem.SubProblem.build_residuals() on each subproblem.

• shared_inputs (Dataclass | None) – If provided, an additional shared_inputs block to be added to the Values

subproblems: Mapping[str, SubProblem]

inputs: Values

residual_blocks: Values

residuals: Values

extra_values: Values

static split_residual_blocks(residual_blocks)

Split residual_blocks into residuals and extra_values

Parameters:

residual_blocks (Values) –

Return type:

Tuple[Values, Values]

keys()

Compute the set of all keys specified by the subproblems

Return type:

List[str]

optimized_keys()

Compute the set of optimized keys, as specified by the subproblems

Return type:

List[str]

generate(output_dir, namespace, name, sparse_linearization=False, config=None)

Generate everything needed to optimize self in C++. This will typically only generate one factor, but can be configured to generate multiple different factors by setting the “factor_name” field of the residual blocks to be split into separate factors.

Parameters:

• output_dir (str | PathLike) – Directory in which to output the generated files.

• namespace (str) – Namespace used in each generated file.

• name (str) – Name of the generated factor.

• sparse_linearization (bool) – Whether the generated factors should use sparse jacobians/hessians

• config (CppConfig | None) – C++ code configuration used with the linearization functions generated for each factor.

Return type:

None

residual_blocks_per_factor(default_name)

Returns a Values with the residual blocks split by factor name.

Parameters:

default_name (str) –

Return type:

Values

static compute_jacobians(keys, inputs, residual_blocks)

Functor that computes the jacobians of the residual with respect to a set of keys

The set of keys is not known when make_symbolic_factors is called, because we may want to create a numeric_factor.NumericFactor which computes derivatives with respect to different sets of optimized variables.

Parameters:

• keys (Sequence[str]) –

• inputs (Values) –

• residual_blocks (Values) –

Return type:

Matrix

make_symbolic_factors(name, config=None)

Return a list of symbolic factors for this problem for analysis purposes. If the factors are to be passed to an symforce.opt.optimizer.Optimizer, use make_numeric_factors() instead.

Parameters:

• name (str) – Name of factors. Note that the generated linearization functions will have "_factor" appended to the function name (see Codegen._pick_name_for_function_with_derivatives for details).

• config (CodegenConfig | None) – Language the factors will be generated in when generate() is called. If not provided, uses the same default as the factor.Factor constructor.

Return type:

List[Factor]

make_numeric_factors(name, optimized_keys=None)

Returns a list of NumericFactor for this problem, for example to pass to Optimizer.

Parameters:

• name (str) – Name of factors. Note that the generated linearization functions will have "_factor" appended to the function name (see Codegen._pick_name_for_function_with_derivatives for details).

• optimized_keys (Sequence[str] | None) – List of keys to optimize with respect to. Defaults to the optimized keys specified by the subproblems of this optimization problem.

Return type:

List[NumericFactor]

build_inputs(subproblems, shared_inputs=None)

Build the inputs Values for a set of subproblems. The resulting values is structured as:

Values(
    subproblem1.name=subproblem1.inputs,
    ...,
    subproblemN.name=subproblemN.inputs,
    shared_inputs=shared_inputs,
)

Parameters:

• subproblems (Iterable[SubProblem]) – Iterable of SubProblems

• shared_inputs (Any | None) – Optional additional shared inputs

Returns:

inputs – the combined Values

Return type:

Values