Nonlinear Models#

This page describes the dwave-optimization package’s nonlinear model: classes, attributes, and methods.

For examples, see Ocean’s Getting Started examples.

Nonlinear models are especially suited for use with decision variables that represent a common logic, such as subsets of choices or permutations of ordering. For example, in a traveling salesperson problem permutations of the variables representing cities can signify the order of the route being optimized and in a knapsack problem the variables representing items can be divided into subsets of packed and not packed.

Model Class#

class Model#

Nonlinear model.

The nonlinear model represents a general optimization problem with an objective function and/or constraints over variables of various types.

The Model class can contain this model and its methods provide convenient utilities for working with representations of a problem.

Examples

This example creates a model for a flow-shop-scheduling problem with two jobs on three machines.

>>> from dwave.optimization.generators import flow_shop_scheduling
...
>>> processing_times = [[10, 5, 7], [20, 10, 15]]
>>> model = flow_shop_scheduling(processing_times=processing_times)

Model Primitives#

Instantiation of the model’s decision (and constant) symbols. For the full list of supported symbols, see the Symbols page.

binary([shape])

Create a binary symbol as a decision variable.

constant(array_like)

Create a constant symbol.

disjoint_bit_sets(primary_set_size, ...)

Create a disjoint-sets symbol as a decision variable.

disjoint_lists(primary_set_size, ...)

Create a disjoint-lists symbol as a decision variable.

integer([shape, lower_bound, upper_bound])

Create an integer symbol as a decision variable.

list(n)

Create a list symbol as a decision variable.

set(n[, min_size, max_size])

Create a set symbol as a decision variable.

Model Methods#

add_constraint(value)

Add a constraint to the model.

decision_state_size()

An estimated size, in bytes, of the model's decision states.

from_file(file, *[, check_header])

Construct a model from the given file.

into_file(file, *[, max_num_states, ...])

Serialize the model into an existing file.

is_locked()

Lock status of the model.

iter_constraints()

Iterate over all constraints in the model.

iter_decisions()

Iterate over all decision variables in the model.

iter_symbols()

Iterate over all symbols in the model.

lock()

Lock the model.

minimize(value)

Set the objective value to minimize.

num_constraints()

Number of constraints in the model.

num_decisions()

Number of independent decision nodes in the model.

num_nodes()

Number of nodes in the directed acyclic graph for the model.

num_symbols()

Number of symbols tracked by the model.

quadratic_model(x, quadratic[, linear])

Create a quadratic model from an array and a quadratic model.

state_size()

An estimate of the size, in bytes, of all states in the model.

to_file(**kwargs)

Serialize the model to a new file-like object.

to_networkx()

Convert the model to a NetworkX graph.

unlock()

Release a lock, decrementing the lock count.

States Class#

class States#

States of a symbol in a model.

States represent assignments of values to a symbol’s elements. For example, an integer() symbol of size \(1 \times 5\) might have state [3, 8, 0, 12, 8], representing one assignment of values to the symbol.

Examples

This example creates a knapsack model and manipulates its states to test that it behaves as expected.

First, create a model.

>>> from dwave.optimization import Model
...
>>> model = Model()
>>> # Add constants
>>> weights = model.constant([10, 20, 5, 15])
>>> values = model.constant([-5, -7, -2, -9])
>>> capacity = model.constant(30)
>>> # Add the decision variable
>>> items = model.set(4)
>>> # add the capacity constraint
>>> model.add_constraint(weights[items].sum() <= capacity)
>>> # Set the objective
>>> model.minimize(values[items].sum())

Lock the model to prevent changes to directed acyclic graph. At any time, you can verify the locked state, which is demonstrated here.

>>> with model.lock():
...     model.is_locked()
True

Set a couple of states on the decision variable and verify that the model generates the expected values for the objective.

>>> model.states.resize(2)
>>> items.set_state(0, [0, 1])
>>> items.set_state(1, [0, 2, 3])
>>> with model.lock():
...     print(model.objective.state(0) > model.objective.state(1))
True

You can clear the states you set.

>>> model.states.clear()
>>> model.states.size()
0

States Methods#

clear()

Clear any saved states.

from_file(file, *[, replace, check_header])

Construct states from the given file.

from_future(future, result_hook)

Populate the states from the result of a future computation.

into_file(file)

Serialize the states into an existing file.

resize(n)

Resize the number of states.

resolve()

Block until states are retrieved from any pending future computations.

size()

Number of model states.

to_file()

Serialize the states to a new file-like object.