def test_produceResults1(self):
t = L1L2_L1L2(**self.l1l2_l1l2_cfg1)
jobGen = t.createJob(self.ssname1, self.data, self.labels,
self.initial_additionalJobData1)
jps = [jp for jp in jobGen]
jobs = [jp[1] for jp in jps]
jobContainer = SimpleJobExecutor(jobs)
jobContainer.run()
exc = jobContainer.close()
self.assertEqual([], exc)
outputs = jobContainer.getJobResults()
results = t.produceResults(self.ssname1, jobs, self.runtime1)
mvec = [[0 for _ in range(30)], [0 for _ in range(30)],
[0 for _ in range(30)]]
for m in range(3):
for i in range(self.external_k):
vv = outputs[i]['selected_list'][m]
for idx in range(len(vv)):
if vv[idx]:
mvec[m][idx] += 1
for m in range(3):
for idx in range(len(mvec[m])):
mvec[m][idx] = float(mvec[m][idx]) / float(self.external_k)
for m in range(3):
v1 = mvec[m]
v2 = results['MuExt']['freqs'][m]
for val1, val2 in zip(v1, v2):
self.assertEqual(float(val1), float(val2))
def test_produceResults1(self):
t = L1L2_OLS(**self.l1l2_ols_cfg1)
jobGen = t.createJob(self.ssname1, self.data, self.labels,
self.initial_additionalJobData1)
_, job = jobGen.next()
jobContainer = SimpleJobExecutor([job])
jobContainer.run()
exc = jobContainer.close()
self.assertEqual([], exc)
jr = jobContainer.getJobResults()
self.assertEqual(1, len(jr))
beta, error, labels, labels_predicted = jr[0]
self.assertEqual(self.data.shape[0], len(beta))
numpy.testing.assert_almost_equal(error, 0.0)
numpy.testing.assert_equal(self.labels, labels)
self.assertEqual(self.labels.shape[0], len(labels_predicted))
# emulate normal way of resolving degrees of freedom
t.parameters['global_degrees_of_freedom'] = (self.default_null_dof, )
# provide standard runtime data
res1 = t.produceResults(self.ssname1, [job], self.runtime1)
self.assertIsInstance(res1, Results)
self.assertEqual(self.ref_beta_shape, res1['Beta'].shape)
self.assertEqual(self.ref_cls_error, res1['Classification Error'])
self.assertEqual(self.ssname1, res1['SubsetID'])
for rk, rv in self.runtime1.iteritems():
self.assertIn(rk, res1[RESULTS_RUNTIME_KEY])
self.assertEqual(rv, res1[RESULTS_RUNTIME_KEY][rk])
# provide empty runtime data
with self.assertRaises(KeyError):
t.produceResults(self.ssname1, [job], self.runtime2)
# other errors
with self.assertRaises(KeyError):
res1['XXXXX']
with self.assertRaises(Error):
res1['XXXXX'] = 111
def test_run5(self):
jex = SimpleJobExecutor(self.jobs4)
jex.run()
exc = jex.close()
res = jex.getJobResults()
ref_res = [[i * i for i in range(10) if i % 2 == 1] for _ in range(10)]
self.assertEqual(ref_res, res)
self.assertEqual([], exc)
def test_run3(self):
jex = SimpleJobExecutor(self.jobs2)
jex.run()
exc = jex.close()
res = jex.getJobResults()
ref_res = set([10])
self.assertEqual(ref_res, set(res))
self.assertSequenceEqual([], exc)
def test_run4(self):
jex = SimpleJobExecutor(self.jobs3)
jex.run()
exc = jex.close()
res = jex.getJobResults()
for r in res:
self.assertEqual(NOTPRODUCED, r)
for ref_jid, (jid, ex) in zip(self.ref_increment_ids, exc):
self.assertEqual(ref_jid, jid)
self.assertIsInstance(ex, Error)
def test_produceResults1(self):
t = L1L2_RLS(**self.l1l2_rls_cfg1)
jobGen = t.createJob(self.ssname1, self.data, self.labels,
self.initial_additionalJobData1)
jps = [jp for jp in jobGen]
jobs = [jp[1] for jp in jps]
# emulate normal way of resolving degrees of freedom
t.parameters['global_degrees_of_freedom'] = (self.default_null_dof, )
jobContainer = SimpleJobExecutor(jobs)
jobContainer.run()
exc = jobContainer.close()
self.assertEqual([], exc)
outputs = jobContainer.getJobResults()
results = t.produceResults(self.ssname1, jobs, self.runtime1)
self.assertIsNotNone(outputs)
self.assertIsNotNone(results)
def test_L1L2_VarCount_Reporter_1(self):
t = L1L2_OLS(**self.l1l2_ols_cfg1)
jobs = list()
for ds in self.data:
jobGen = t.createJob(self.ssname1, ds, self.labels,
self.initial_additionalJobData1)
_, job = jobGen.next()
jobs.append(job)
jobContainer = SimpleJobExecutor(jobs)
jobContainer.run()
exc = jobContainer.close()
self.assertEqual([], exc)
results = list()
ssIndResults = dict()
subsets = dict()
for ss, j in zip(self.ssname1, jobs):
r = t.produceResults(ss, [j], self.runtime1)
results.append(r)
ssIndResults[ss] = r
subsets[ss] = dict()
subsets[ss]['vars'] = self.vars1
subsets[ss]['mat'] = ss
outerSel = OuterSelector_ClassificationErrorThreshold(
**{'error_threshold': 0.0})
innerSel = InnerSelector_ClassificationErrorThreshold_AllVars()
outerSel.perform(results)
outerSelRes = dict([(ss, sor['Selection']['outer'])
for (ss, sor) in zip(self.pkcid1, results)])
innerSel.perform(outerSelRes, ssIndResults, subsets)
reporter = L1L2_VarCount_Reporter()
reporter.initialize(self.storageManager1, self.ssloc1,
self.additionalReportData1)
reporter.produce(results)
reporter.finalize()
self.assertTrue(os.path.exists(self.reports_loc1))
self.assertEqual(set(self.reports_names1),
set(os.listdir(self.reports_loc1)))
for rp in self.reports_paths1:
self.assertTrue(os.path.exists(rp))
def test_init2(self):
with self.assertRaises(TypeError):
SimpleJobExecutor()
def test_init1(self):
jex = SimpleJobExecutor(self.jobs0)
self.assertEqual(self.jobs0, jex.jobs_to_execute)