def test_saveload_modelresult_roundtrip(method):
"""Test for modelresult.loads()/dumps() and repeating that"""
def mfunc(x, a, b):
return a * (x - b)
model = Model(mfunc)
params = model.make_params(a=0.1, b=3.0)
params['a'].set(min=.01, max=1, brute_step=0.01)
params['b'].set(min=.01, max=3.1, brute_step=0.01)
np.random.seed(2020)
xx = np.linspace(-5, 5, 201)
yy = 0.5 * (xx - 0.22) + np.random.normal(scale=0.01, size=len(xx))
result1 = model.fit(yy, params=params, x=xx, method=method)
result2 = ModelResult(model, Parameters())
result2.loads(result1.dumps(), funcdefs={'mfunc': mfunc})
result3 = ModelResult(model, Parameters())
result3.loads(result2.dumps(), funcdefs={'mfunc': mfunc})
assert result3 is not None
assert_allclose(result2.params['a'], 0.5, rtol=1.0e-2)
assert_allclose(result2.params['b'], 0.22, rtol=1.0e-2)
assert_allclose(result3.params['a'], 0.50, rtol=1.0e-2)
assert_allclose(result3.params['b'], 0.22, rtol=1.0e-2)
def test_saveload_modelresult_roundtrip():
"""Test for modelresult.loads()/dumps() and repeating that"""
def mfunc(x, a, b):
return a * (x - b)
model = Model(mfunc)
params = model.make_params(a=0.0, b=3.0)
xx = np.linspace(-5, 5, 201)
yy = 0.5 * (xx - 0.22) + np.random.normal(scale=0.01, size=len(xx))
result1 = model.fit(yy, params, x=xx)
result2 = ModelResult(model, Parameters())
result2.loads(result1.dumps(), funcdefs={'mfunc': mfunc})
result3 = ModelResult(model, Parameters())
result3.loads(result2.dumps(), funcdefs={'mfunc': mfunc})
assert result3 is not None
assert_param_between(result2.params['a'], 0.48, 0.52)
assert_param_between(result2.params['b'], 0.20, 0.25)
assert_param_between(result3.params['a'], 0.48, 0.52)
assert_param_between(result3.params['b'], 0.20, 0.25)
def run_preview(data: Table, m_def, pool, state: TaskState):
def progress_interrupt(_: float):
if state.is_interruption_requested():
raise InterruptException
# Protects against running the task in succession many times, as would
# happen when adding a preprocessor (there, commit() is called twice).
# Wait 100 ms before processing - if a new task is started in meanwhile,
# allow that is easily` cancelled.
for _ in range(10):
time.sleep(0.010)
progress_interrupt(0)
orig_data = data
model, parameters = create_composite_model(m_def)
model_result = {}
x = getx(data)
if data is not None and model is not None:
for row in data:
progress_interrupt(0)
res = pool.schedule(pool_fit2,
(row.x, model.dumps(), parameters, x))
while not res.done():
try:
progress_interrupt(0)
except InterruptException:
# CANCEL
if multiprocessing.get_start_method(
) != "fork" and res.running():
# If slower start methods are used, give the current computation
# some time to exit gracefully; this avoids reloading processes
concurrent.futures.wait([res], 1.0)
if not res.done():
res.cancel()
raise
concurrent.futures.wait([res], 0.05)
fits = res.result()
model_result[row.id] = ModelResult(model, parameters).loads(
fits, **LMFIT_LOADS_KWARGS)
progress_interrupt(0)
return orig_data, data, model_result
def run_task(data: Table, m_def, state: TaskState):
def progress_interrupt(i: float):
state.set_progress_value(i)
if state.is_interruption_requested():
raise InterruptException
# Protects against running the task in succession many times, as would
# happen when adding a preprocessor (there, commit() is called twice).
# Wait 100 ms before processing - if a new task is started in meanwhile,
# allow that is easily` cancelled.
for _ in range(10):
time.sleep(0.010)
progress_interrupt(0)
model, parameters = create_composite_model(m_def)
data_fits = data_anno = data_resid = None
if data is not None and model is not None:
orig_data = data
output = []
x = getx(data)
n = len(data)
fits = []
residuals = []
with multiprocessing.Pool(processes=N_PROCESSES,
initializer=pool_initializer,
initargs=(model.dumps(), parameters,
x)) as p:
res = p.map_async(pool_fit, data.X, chunksize=1)
def done():
try:
return n - res._number_left * res._chunksize
except AttributeError:
return 0
while not res.ready():
progress_interrupt(done() / n * 99)
res.wait(0.05)
fitsr = res.get()
progress_interrupt(99)
for fit, bpar, fitted, resid in fitsr:
out = ModelResult(model,
parameters).loads(fit, **LMFIT_LOADS_KWARGS)
output.append(bpar)
fits.append(fitted)
residuals.append(resid)
progress_interrupt(99)
data = fit_results_table(np.vstack(output), out, orig_data)
data_fits = orig_data.from_table_rows(orig_data,
...) # a shallow copy
with data_fits.unlocked_reference(data_fits.X):
data_fits.X = np.vstack(fits)
data_resid = orig_data.from_table_rows(orig_data,
...) # a shallow copy
with data_resid.unlocked_reference(data_resid.X):
data_resid.X = np.vstack(residuals)
dom_anno = Domain(
orig_data.domain.attributes,
orig_data.domain.class_vars,
orig_data.domain.metas + data.domain.attributes,
)
data_anno = orig_data.transform(dom_anno)
with data_anno.unlocked(data_anno.metas):
data_anno.metas[:, len(orig_data.domain.metas):] = data.X
progress_interrupt(100)
return data, data_fits, data_resid, data_anno