def compute_score(self, observation, prediction):
"""Implementation of sciunit.Test.score_prediction."""
print("%s: Observation = %s, Prediction = %s" % (self.name,str(observation),str(prediction)))
score = zscore(observation,prediction)
score = ZScore(score)
score.related_data['mean_spikewidth'] = prediction['mean']
return score
def compute_score(self, observation, prediction): """Implementation of sciunit.Test.score_prediction.""" score = zscore(observation,prediction) score = ZScore(score) score.related_data['mean_vm'] = prediction['mean'] return score
def test_regular_score_types_1(self):
score = PercentScore(42)
self.assertEqual(score.sort_key,0.42)
ZScore(0.7)
score = ZScore.compute({'mean':3.,'std':1.},{'value':2.})
self.assertEqual(score.score,-1.)
CohenDScore(-0.3)
score = CohenDScore.compute({'mean':3.,'std':1.},{'mean':2.,'std':1.})
self.assertTrue(-0.708 < score.score < -0.707)
def test_regular_score_types_1(self):
self.assertEqual(PercentScore(0).norm_score, 0)
self.assertEqual(PercentScore(100).norm_score, 1)
score = PercentScore(42)
self.assertRaises(InvalidScoreError, PercentScore, 101)
self.assertRaises(InvalidScoreError, PercentScore, -1)
self.assertEqual(str(score), "42.0%")
self.assertEqual(score.norm_score, 0.42)
self.assertEqual(1, ZScore(0.0).norm_score)
self.assertEqual(0, ZScore(1e12).norm_score)
self.assertEqual(0, ZScore(-1e12).norm_score)
ZScore(0.7)
score = ZScore.compute({"mean": 3.0, "std": 1.0}, {"value": 2.0})
self.assertIsInstance(ZScore.compute({"mean": 3.0}, {"value": 2.0}),
InsufficientDataScore)
self.assertIsInstance(
ZScore.compute({
"mean": 3.0,
"std": -1.0
}, {"value": 2.0}),
InsufficientDataScore,
)
self.assertIsInstance(
ZScore.compute({
"mean": np.nan,
"std": np.nan
}, {"value": np.nan}),
InsufficientDataScore,
)
self.assertEqual(score.score, -1.0)
self.assertEqual(1, CohenDScore(0.0).norm_score)
self.assertEqual(0, CohenDScore(1e12).norm_score)
self.assertEqual(0, CohenDScore(-1e12).norm_score)
CohenDScore(-0.3)
score = CohenDScore.compute({
"mean": 3.0,
"std": 1.0
}, {
"mean": 2.0,
"std": 1.0
})
self.assertAlmostEqual(-0.707, score.score, 3)
self.assertEqual("D = -0.71", str(score))
score = CohenDScore.compute({
"mean": 3.0,
"std": 10.0,
"n": 10
}, {
"mean": 2.5,
"std": 10.0,
"n": 10
})
self.assertAlmostEqual(-0.05, score.score, 2)
def test_converters(self):
from sciunit.converters import (
AtLeastToBoolean,
AtMostToBoolean,
LambdaConversion,
NoConversion,
RangeToBoolean,
)
from sciunit.scores import BooleanScore, ZScore
old_score = ZScore(1.3)
new_score = NoConversion().convert(old_score)
self.assertEqual(old_score, new_score)
new_score = LambdaConversion(lambda x: x.score**2).convert(old_score)
self.assertEqual(old_score.score**2, new_score.score)
new_score = AtMostToBoolean(3).convert(old_score)
self.assertEqual(new_score, BooleanScore(True))
new_score = AtMostToBoolean(1).convert(old_score)
self.assertEqual(new_score, BooleanScore(False))
new_score = AtLeastToBoolean(1).convert(old_score)
self.assertEqual(new_score, BooleanScore(True))
new_score = AtLeastToBoolean(3).convert(old_score)
self.assertEqual(new_score, BooleanScore(False))
new_score = RangeToBoolean(1, 3).convert(old_score)
self.assertEqual(new_score, BooleanScore(True))
new_score = RangeToBoolean(3, 5).convert(old_score)
self.assertEqual(new_score, BooleanScore(False))
self.assertEqual(new_score.raw, str(old_score.score))
def test_score_matrix_constructor(self):
tests = [Test([1, 2, 3])]
models = [Model()]
scores = np.array([ZScore(1.0)])
scoreArray = ScoreArray(tests)
scoreMatrix = ScoreMatrix(tests, models, scores)
scoreMatrix = ScoreMatrix(tests, models, scores, transpose=True)
tests = Test([1, 2, 3])
models = Model()
scoreMatrix = ScoreMatrix(tests, models, scores)
def compute(cls, observation, prediction):
"""
Computes a z-score from an observation and a prediction.
"""
scores = []
table = [] # store intermediate results
for obs, pred in zip(observation, prediction):
assert obs.keys() == pred.keys()
assert len(obs) == 1
scores.append(
ZScore.compute(list(obs.values())[0],
list(pred.values())[0]).score)
key = list(obs.keys())[0]
table.append((key, obs[key]["mean"], obs[key]["std"],
pred[key]["value"], scores[-1]))
sc = np.sqrt(np.mean(np.square(scores)))
print("RMS(Z) " + str(sc))
score = cls(sc, related_data={'score_table': table})
return score
