def test_report_timing(self):
# Create a set to ensure that the global sets have already been
# constructed (this is an issue until the new set system is
# merged in and the GlobalSet objects are not automatically
# created by pyomo.core
m = ConcreteModel()
m.x = Var([1,2])
ref = """
0 seconds to construct Block ConcreteModel; 1 index total
0 seconds to construct RangeSet r; 1 index total
0 seconds to construct Var x; 2 indicies total
""".strip()
os = StringIO()
try:
report_timing(os)
m = ConcreteModel()
m.r = RangeSet(2)
m.x = Var(m.r)
self.assertEqual(os.getvalue().strip(), ref)
finally:
report_timing(False)
buf = StringIO()
with LoggingIntercept(buf, 'pyomo'):
m = ConcreteModel()
m.r = RangeSet(2)
m.x = Var(m.r)
self.assertEqual(os.getvalue().strip(), ref)
self.assertEqual(buf.getvalue().strip(), "")
def test_report_timing(self):
# Create a set to ensure that the global sets have already been
# constructed (this is an issue until the new set system is
# merged in and the GlobalSet objects are not automatically
# created by pyomo.core
m = ConcreteModel()
m.x = Var([1,2])
ref = r"""
(0(\.\d+)?) seconds to construct Block ConcreteModel; 1 index total
(0(\.\d+)?) seconds to construct RangeSet FiniteSimpleRangeSet; 1 index total
(0(\.\d+)?) seconds to construct Var x; 2 indices total
(0(\.\d+)?) seconds to construct Suffix Suffix; 1 index total
(0(\.\d+)?) seconds to apply Transformation RelaxIntegerVars \(in-place\)
""".strip()
xfrm = TransformationFactory('core.relax_integer_vars')
try:
with capture_output() as out:
report_timing()
m = ConcreteModel()
m.r = RangeSet(2)
m.x = Var(m.r)
xfrm.apply_to(m)
result = out.getvalue().strip()
self.maxDiff = None
for l, r in zip(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
finally:
report_timing(False)
os = StringIO()
try:
report_timing(os)
m = ConcreteModel()
m.r = RangeSet(2)
m.x = Var(m.r)
xfrm.apply_to(m)
result = os.getvalue().strip()
self.maxDiff = None
for l, r in zip(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
finally:
report_timing(False)
buf = StringIO()
with LoggingIntercept(buf, 'pyomo'):
m = ConcreteModel()
m.r = RangeSet(2)
m.x = Var(m.r)
xfrm.apply_to(m)
result = os.getvalue().strip()
self.maxDiff = None
for l, r in zip(result.splitlines(), ref.splitlines()):
self.assertRegex(str(l.strip()), str(r.strip()))
self.assertEqual(buf.getvalue().strip(), "")
def create_instance(self,
filename=None,
data=None,
name=None,
namespace=None,
namespaces=None,
profile_memory=0,
report_timing=False,
**kwds):
"""
Create a concrete instance of an abstract model, possibly using data
read in from a file.
Parameters
----------
filename: `str`, optional
The name of a Pyomo Data File that will be used to load data into
the model.
data: `dict`, optional
A dictionary containing initialization data for the model to be
used if there is no filename
name: `str`, optional
The name given to the model.
namespace: `str`, optional
A namespace used to select data.
namespaces: `list`, optional
A list of namespaces used to select data.
profile_memory: `int`, optional
A number that indicates the profiling level.
report_timing: `bool`, optional
Report timing statistics during construction.
"""
#
# Generate a warning if this is a concrete model but the
# filename is specified. A concrete model is already
# constructed, so passing in a data file is a waste of time.
#
if self.is_constructed() and isinstance(filename, str):
msg = "The filename=%s will not be loaded - supplied as an " \
"argument to the create_instance() method of a "\
"concrete instance with name=%s." % (filename, name)
logger.warning(msg)
if 'clone' in kwds:
kwds.pop('clone')
deprecation_warning(
"Model.create_instance() no longer accepts the 'clone' "
"argument: the base abstract model is always cloned.",
version='5.4')
if 'preprocess' in kwds:
kwds.pop('preprocess')
deprecation_warning(
"Model.create_instance() no longer accepts the preprocess' "
"argument: preprocessing is always deferred to when the "
"model is sent to the solver",
version='5.4')
if kwds:
msg = \
"""Model.create_instance() passed the following unrecognized keyword
arguments (which have been ignored):"""
for k in kwds:
msg = msg + "\n '%s'" % (k, )
logger.error(msg)
if self.is_constructed():
deprecation_warning(
"Cannot call Model.create_instance() on a constructed "
"model; returning a clone of the current model instance.",
version='5.4')
return self.clone()
if report_timing:
timing.report_timing()
if name is None:
# Preserve only the local name (not the FQ name, as that may
# have been quoted or otherwise escaped)
name = self.local_name
if filename is not None:
if data is not None:
logger.warning(
"Model.create_instance() passed both 'filename' "
"and 'data' keyword arguments. Ignoring the "
"'data' argument")
data = filename
if data is None:
data = {}
#
# Clone the model and load the data
#
instance = self.clone()
if name is not None:
instance._name = name
# If someone passed a rule for creating the instance, fire the
# rule before constructing the components.
if instance._rule is not None:
instance._rule(instance, next(iter(self.index_set())))
if namespaces:
_namespaces = list(namespaces)
else:
_namespaces = []
if namespace is not None:
_namespaces.append(namespace)
if None not in _namespaces:
_namespaces.append(None)
instance.load(data,
namespaces=_namespaces,
profile_memory=profile_memory)
#
# Indicate that the model is concrete/constructed
#
instance._constructed = True
#
# Change this class from "Abstract" to "Concrete". It is
# absolutely crazy that this is allowed in Python, but since the
# AbstractModel and ConcreteModel are basically identical, we
# can "reassign" the new concrete instance to be an instance of
# ConcreteModel
#
instance.__class__ = ConcreteModel
return instance
opt.set_instance(m)
p_values = list(range(1, 31))
obj_values = list()
for p in p_values:
m.P.value = p
opt.remove_constraint(m.num_warehouses)
opt.add_constraint(m.num_warehouses)
res = opt.solve(save_results=False)
assert_optimal_termination(res)
obj_values.append(res.problem.lower_bound)
# @:parametric_persistent
# @report_timing:
report_timing()
print('Building model')
print('--------------')
m = create_warehouse_model(num_locations=200, num_customers=200)
# @:report_timing
# @report_timing_with_lin_expr:
print('Building model with LinearExpression')
print('------------------------------------')
m = create_warehouse_linear_expr(num_locations=200, num_customers=200)
# @:report_timing_with_lin_expr
report_timing(False)
# @tic_toc_timer:
timer = TicTocTimer()
