def test_minmax_norm(self):
data = Table.from_numpy(None, [[2, 1, 2, 2, 3]])
p = Normalize(method=Normalize.MinMax)(data)
q = (data.X) / (3 - 1)
np.testing.assert_equal(p.X, q)
p = Normalize(method=Normalize.MinMax, lower=0, upper=4)(data)
np.testing.assert_equal(p.X, q)
p = Normalize(method=Normalize.MinMax, lower=0, upper=2)(data)
np.testing.assert_equal(p.X, q)
def test_SNV_norm(self):
data = Table.from_numpy(None, [[2, 1, 2, 2, 3]])
p = Normalize(method=Normalize.SNV)(data)
q = (data.X - 2) / 0.6324555320336759
np.testing.assert_equal(p.X, q)
p = Normalize(method=Normalize.SNV, lower=0, upper=4)(data)
np.testing.assert_equal(p.X, q)
p = Normalize(method=Normalize.SNV, lower=0, upper=2)(data)
np.testing.assert_equal(p.X, q)
def test_area_norm(self):
data = Orange.data.Table([[2, 1, 2, 2, 3]])
p = Normalize(method=Normalize.Area, int_method=Integrate.PeakMax, lower=0, upper=4)(data)
np.testing.assert_equal(p.X, data.X / 3)
p = Normalize(method=Normalize.Area, int_method=Integrate.Simple, lower=0, upper=4)(data)
np.testing.assert_equal(p.X, data.X / 7.5)
p = Normalize(method=Normalize.Area, int_method=Integrate.Simple, lower=0, upper=2)(data)
q = Integrate(methods=Integrate.Simple, limits=[[0, 2]])(p)
np.testing.assert_equal(q.X, np.ones_like(q.X))
def test_vector_norm(self):
data = Table.from_numpy(None, [[2, 1, 2, 2, 3]])
p = Normalize(method=Normalize.Vector)(data)
q = data.X / np.sqrt((data.X * data.X).sum(axis=1))
np.testing.assert_equal(p.X, q)
p = Normalize(method=Normalize.Vector, lower=0, upper=4)(data)
np.testing.assert_equal(p.X, q)
p = Normalize(method=Normalize.Vector, lower=0, upper=2)(data)
np.testing.assert_equal(p.X, q)
def test_attribute_norm(self):
data = Orange.data.Table([[2, 1, 2, 2, 3]])
ndom = Orange.data.Domain(data.domain.attributes, data.domain.class_vars,
metas=[Orange.data.ContinuousVariable("f")])
data = data.transform(ndom)
data[0]["f"] = 2
p = Normalize(method=Normalize.Attribute, attr=data.domain.metas[0])(data)
np.testing.assert_equal(p.X, data.X / 2)
p = Normalize(method=Normalize.Attribute, attr=data.domain.metas[0],
lower=0, upper=4)(data)
np.testing.assert_equal(p.X, data.X / 2)
p = Normalize(method=Normalize.Attribute, attr=data.domain.metas[0],
lower=2, upper=4)(data)
np.testing.assert_equal(p.X, data.X / 2)
def test_vector_norm_nan_correction(self):
# even though some values are unknown the other values
# should be normalized to the same results
data = Table.from_numpy(None, [[2, 2, 2, 2]])
p = Normalize(method=Normalize.Vector)(data)
self.assertAlmostEqual(p.X[0, 0], 0.5)
# unknown in between that can be interpolated does not change results
data.X[0, 2] = float("nan")
p = Normalize(method=Normalize.Vector)(data)
self.assertAlmostEqual(p.X[0, 0], 0.5)
self.assertTrue(np.isnan(p.X[0, 2]))
# unknowns at the edges do not get interpolated
data.X[0, 3] = float("nan")
p = Normalize(method=Normalize.Vector)(data)
self.assertAlmostEqual(p.X[0, 0], 2**0.5 / 2)
self.assertTrue(np.all(np.isnan(p.X[0, 2:])))
def test_normalization_vector():
fns = ["collagen", dust(), spectra20nea(), "peach_juice.dpt"]
for fn in fns:
print(fn)
data = Table(fn)
p = Normalize(method=Normalize.Vector)
print(data.X.shape)
t = time.time()
r = p(data)
print("no interpolate", time.time() - t)
data[0, 2] = np.nan
t = time.time()
r = p(data)
print("with interpolate", time.time() - t)
assert (np.all(np.argwhere(np.isnan(r.X)) == [[0, 2]]))
def createinstance(params):
method = params.get("method", Normalize.Vector)
lower = params.get("lower", 0)
upper = params.get("upper", 4000)
int_method_index = params.get("int_method", 0)
int_method = IntegrateEditor.Integrators_classes[int_method_index]
attr = params.get("attr", None)
if method != NORMALIZE_BY_REFERENCE:
return Normalize(method=method, lower=lower, upper=upper,
int_method=int_method, attr=attr)
else:
# avoids circular imports
from orangecontrib.spectroscopy.widgets.owpreprocess import REFERENCE_DATA_PARAM
reference = params.get(REFERENCE_DATA_PARAM, None)
return NormalizeReference(reference=reference)
def createinstance(params):
method = params.get("method", Normalize.Vector)
lower = params.get("lower", 0)
upper = params.get("upper", 4000)
int_method_index = params.get("int_method", 0)
int_method = IntegrateEditor.Integrators_classes[int_method_index]
attr = params.get("attr", None)
if method not in (NORMALIZE_BY_REFERENCE, PHASE_REFERENCE):
return Normalize(method=method, lower=lower, upper=upper,
int_method=int_method, attr=attr)
else:
# avoids circular imports
reference = params.get(REFERENCE_DATA_PARAM, None)
if method == PHASE_REFERENCE:
return NormalizePhaseReference(reference=reference)
return NormalizeReference(reference=reference)
def test_attribute_norm_unknown(self):
data = Table.from_numpy(None, X=[[2, 1, 2, 2, 3]], metas=[[2]])
p = Normalize(method=Normalize.Attribute, attr="unknown")(data)
self.assertTrue(np.all(np.isnan(p.X)))
SavitzkyGolayFiltering(window=9, polyorder=2, deriv=2),
Cut(lowlim=1000, highlim=1800),
GaussianSmoothing(sd=3.),
Absorbance(),
Transmittance(),
Integrate(limits=[[900, 100], [1100, 1200], [1200, 1300]]),
Integrate(methods=Integrate.Simple, limits=[[1100, 1200]]),
Integrate(methods=Integrate.Baseline, limits=[[1100, 1200]]),
Integrate(methods=Integrate.PeakMax, limits=[[1100, 1200]]),
Integrate(methods=Integrate.PeakBaseline, limits=[[1100, 1200]]),
Integrate(methods=Integrate.PeakAt, limits=[[1100]]),
Integrate(methods=Integrate.PeakX, limits=[[1100, 1200]]),
Integrate(methods=Integrate.PeakXBaseline, limits=[[1100, 1200]]),
RubberbandBaseline(),
LinearBaseline(),
Normalize(method=Normalize.Vector),
Normalize(method=Normalize.Area,
int_method=Integrate.PeakMax,
lower=0,
upper=10000),
Normalize(method=Normalize.MinMax),
CurveShift(1),
Despike(threshold=5, cutoff=60, dis=5),
]
xas_norm_collagen = XASnormalization(edge=1630,
preedge_dict={
'from': 1000,
'to': 1300,
'deg': 1
},
def test_attribute_norm_unknown(self):
data = Orange.data.Table([[2, 1, 2, 2, 3]], metas=[[2]])
p = Normalize(method=Normalize.Attribute, attr="unknown")(data)
self.assertTrue(np.all(np.isnan(p.X)))
def __init__(self, original_model, preprocessors=None, fit_params={}):
super().__init__(preprocessors=preprocessors)
self.preprocessors.append(CorrectWavenumberRange(original_model.wavenumbers))
self.preprocessors.append(Normalize(Normalize.Vector))
self.original_model = original_model
self.fit_params = fit_params