Beispiel #1
0
 def test_calculation_divide_by_zeros(self):
     """PCR: P/R/F calculations correctly handle divide-by-zero errors"""
     # Divide by zero handled correctly
     pcr = PerformanceCalculatorResult(0, 0, 0, None)
     self.assertEqual(pcr._calculate_precision(), None)
     self.assertEqual(pcr._calculate_recall(), None)
     self.assertEqual(pcr._calculate_f_measure(), None)
Beispiel #2
0
 def test_calculation_divide_by_zeros(self):
     """PCR: P/R/F calculations correctly handle divide-by-zero errors"""
     # Divide by zero handled correctly
     pcr = PerformanceCalculatorResult(0,0,0,None)
     self.assertEqual(pcr._calculate_precision(),None)
     self.assertEqual(pcr._calculate_recall(),None)
     self.assertEqual(pcr._calculate_f_measure(),None)
Beispiel #3
0
 def test_f_measure(self):
     """PCR: f-measure calculations function as expected """
     # Max and min tests
     pcr = PerformanceCalculatorResult(50,0,0,None)
     self.assertAlmostEqual(pcr._calculate_f_measure(),1.000,3)
     pcr = PerformanceCalculatorResult(0,50,0,None)
     self.assertEqual(pcr._calculate_f_measure(),None)
     pcr = PerformanceCalculatorResult(0,0,50,None)
     self.assertEqual(pcr._calculate_f_measure(),None)
Beispiel #4
0
    def test_init_missing_TN(self):
        """PCR: init functions with missing or non-int TrueNeagtive """
        # TN = n/a 
        pcr = PerformanceCalculatorResult(42,1,0,'n/a')
        self.assertEqual(pcr.TruePositive,42)
        self.assertEqual(pcr.FalsePositive,1)
        self.assertEqual(pcr.FalseNegative,0)
        self.assertEqual(pcr.TrueNegative,None)

        self.assertAlmostEqual(pcr.Precision, 0.9767,3)
        self.assertAlmostEqual(pcr.Recall,1.0,3)
        self.assertAlmostEqual(pcr.FMeasure,0.9882,3)
        # TN = None
        pcr = PerformanceCalculatorResult(42,1,0,None)
        pcr = PerformanceCalculatorResult(42,1,0)
Beispiel #5
0
    def test_init_all_ints(self):
        """PCR: init functions as expected with valid & complete input """
        pcr = PerformanceCalculatorResult(42,1,0,5)
        self.assertEqual(pcr.TruePositive,42)
        self.assertEqual(pcr.FalsePositive,1)
        self.assertEqual(pcr.FalseNegative,0)
        self.assertEqual(pcr.TrueNegative,5)

        self.assertAlmostEqual(pcr.Precision, 0.9767,3)
        self.assertAlmostEqual(pcr.Recall,1.0,3)
        self.assertAlmostEqual(pcr.FMeasure,0.9882,3)
Beispiel #6
0
 def test_f_measure(self):
     """PCR: f-measure calculations function as expected """
     # Max and min tests
     pcr = PerformanceCalculatorResult(50, 0, 0, None)
     self.assertAlmostEqual(pcr._calculate_f_measure(), 1.000, 3)
     pcr = PerformanceCalculatorResult(0, 50, 0, None)
     self.assertEqual(pcr._calculate_f_measure(), None)
     pcr = PerformanceCalculatorResult(0, 0, 50, None)
     self.assertEqual(pcr._calculate_f_measure(), None)
Beispiel #7
0
 def test_calculate_recall(self):
     """PCR: recall calculations function as expected """
     # Max and min tests
     pcr = PerformanceCalculatorResult(50,0,0,None)
     self.assertAlmostEqual(pcr._calculate_recall(),1.000,3)
     pcr = PerformanceCalculatorResult(0,0,50,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.000,3)
     # Intermediate tests
     pcr = PerformanceCalculatorResult(42,0,1,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.9767,3)
     pcr = PerformanceCalculatorResult(1,0,42,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.0232,3)
     pcr = PerformanceCalculatorResult(42,0,42,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.500,3)
     pcr = PerformanceCalculatorResult(42,0,126,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.250,3)
     pcr = PerformanceCalculatorResult(126,0,42,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.750,3)
     # FP/TN have no effect
     pcr = PerformanceCalculatorResult(126,20,42,None)
     self.assertAlmostEqual(pcr._calculate_recall(),0.750,3)
     pcr = PerformanceCalculatorResult(126,20,42,50)
     self.assertAlmostEqual(pcr._calculate_recall(),0.750,3)
Beispiel #8
0
 def setUp(self):
     """ Initialize data for tests """
     self._pcr = PerformanceCalculatorResult(42,1,0,5)
Beispiel #9
0
class PerformanceCalculatorResultTests(TestCase):
    """ Tests of the PerformanceCalculatorResult object 

        Note: I like to use abbreviation of the class names to make 
            the makes more clear -- in this case that abbreviation is
            PCR, which is a litle weird since that's a very common 
            acronym. Just to make it clear, this reference is to
            PerformanceCalculatorResult, not Polymerase Chain Reaction.

    """

    def setUp(self):
        """ Initialize data for tests """
        self._pcr = PerformanceCalculatorResult(42,1,0,5)

    def test_init_all_ints(self):
        """PCR: init functions as expected with valid & complete input """
        pcr = PerformanceCalculatorResult(42,1,0,5)
        self.assertEqual(pcr.TruePositive,42)
        self.assertEqual(pcr.FalsePositive,1)
        self.assertEqual(pcr.FalseNegative,0)
        self.assertEqual(pcr.TrueNegative,5)

        self.assertAlmostEqual(pcr.Precision, 0.9767,3)
        self.assertAlmostEqual(pcr.Recall,1.0,3)
        self.assertAlmostEqual(pcr.FMeasure,0.9882,3)
        
    def test_init_missing_TN(self):
        """PCR: init functions with missing or non-int TrueNeagtive """
        # TN = n/a 
        pcr = PerformanceCalculatorResult(42,1,0,'n/a')
        self.assertEqual(pcr.TruePositive,42)
        self.assertEqual(pcr.FalsePositive,1)
        self.assertEqual(pcr.FalseNegative,0)
        self.assertEqual(pcr.TrueNegative,None)

        self.assertAlmostEqual(pcr.Precision, 0.9767,3)
        self.assertAlmostEqual(pcr.Recall,1.0,3)
        self.assertAlmostEqual(pcr.FMeasure,0.9882,3)
        # TN = None
        pcr = PerformanceCalculatorResult(42,1,0,None)
        pcr = PerformanceCalculatorResult(42,1,0)

    def test_calculate_precision(self):
        """PCR: precision calculations function as expected """
        # Max and min tests
        pcr = PerformanceCalculatorResult(50,0,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),1.000,3)
        pcr = PerformanceCalculatorResult(0,50,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.000,3)
        # Intermediate tests
        pcr = PerformanceCalculatorResult(42,1,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.9767,3)
        pcr = PerformanceCalculatorResult(1,42,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.0232,3)
        pcr = PerformanceCalculatorResult(42,42,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.500,3)
        pcr = PerformanceCalculatorResult(42,126,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.250,3)
        pcr = PerformanceCalculatorResult(126,42,0,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.750,3)
        # FN/TN has no effect
        pcr = PerformanceCalculatorResult(126,42,20,None)
        self.assertAlmostEqual(pcr._calculate_precision(),0.750,3)
        pcr = PerformanceCalculatorResult(126,42,20,50)
        self.assertAlmostEqual(pcr._calculate_precision(),0.750,3)

    def test_calculate_recall(self):
        """PCR: recall calculations function as expected """
        # Max and min tests
        pcr = PerformanceCalculatorResult(50,0,0,None)
        self.assertAlmostEqual(pcr._calculate_recall(),1.000,3)
        pcr = PerformanceCalculatorResult(0,0,50,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.000,3)
        # Intermediate tests
        pcr = PerformanceCalculatorResult(42,0,1,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.9767,3)
        pcr = PerformanceCalculatorResult(1,0,42,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.0232,3)
        pcr = PerformanceCalculatorResult(42,0,42,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.500,3)
        pcr = PerformanceCalculatorResult(42,0,126,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.250,3)
        pcr = PerformanceCalculatorResult(126,0,42,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.750,3)
        # FP/TN have no effect
        pcr = PerformanceCalculatorResult(126,20,42,None)
        self.assertAlmostEqual(pcr._calculate_recall(),0.750,3)
        pcr = PerformanceCalculatorResult(126,20,42,50)
        self.assertAlmostEqual(pcr._calculate_recall(),0.750,3)

    def test_f_measure(self):
        """PCR: f-measure calculations function as expected """
        # Max and min tests
        pcr = PerformanceCalculatorResult(50,0,0,None)
        self.assertAlmostEqual(pcr._calculate_f_measure(),1.000,3)
        pcr = PerformanceCalculatorResult(0,50,0,None)
        self.assertEqual(pcr._calculate_f_measure(),None)
        pcr = PerformanceCalculatorResult(0,0,50,None)
        self.assertEqual(pcr._calculate_f_measure(),None)
        

    def test_calculation_divide_by_zeros(self):
        """PCR: P/R/F calculations correctly handle divide-by-zero errors"""
        # Divide by zero handled correctly
        pcr = PerformanceCalculatorResult(0,0,0,None)
        self.assertEqual(pcr._calculate_precision(),None)
        self.assertEqual(pcr._calculate_recall(),None)
        self.assertEqual(pcr._calculate_f_measure(),None)
        
    def test_pretty_precision_recall_fmeasure(self):
        """PCR: PRF formatting functions as expected """
        expected = 'Precision\tRecall\tF-measure\n0.9767\t1.0000\t0.9882'
        self.assertEqual(self._pcr.pretty_precision_recall_fmeasure(),expected)

    def test_pretty_confusion_matrix(self):
        """PCR: Confusion matrix formatting functions as expected """
        expected = 'tp\tfn\nfp\ttn\n--\n42\t0\n1\t5'
        self.assertEqual(self._pcr.pretty_confusion_matrix(),expected) 

    def test_str(self):
        """PCR: str() functions as expected """
        expected = '\n'.join([\
           'tp\tfn\nfp\ttn\n--\n42\t0\n1\t5',\
           'Precision\tRecall\tF-measure\n0.9767\t1.0000\t0.9882'])
        self.assertEqual(str(self._pcr),expected)
Beispiel #10
0
 def test_calculate_recall(self):
     """PCR: recall calculations function as expected """
     # Max and min tests
     pcr = PerformanceCalculatorResult(50, 0, 0, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 1.000, 3)
     pcr = PerformanceCalculatorResult(0, 0, 50, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.000, 3)
     # Intermediate tests
     pcr = PerformanceCalculatorResult(42, 0, 1, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.9767, 3)
     pcr = PerformanceCalculatorResult(1, 0, 42, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.0232, 3)
     pcr = PerformanceCalculatorResult(42, 0, 42, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.500, 3)
     pcr = PerformanceCalculatorResult(42, 0, 126, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.250, 3)
     pcr = PerformanceCalculatorResult(126, 0, 42, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.750, 3)
     # FP/TN have no effect
     pcr = PerformanceCalculatorResult(126, 20, 42, None)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.750, 3)
     pcr = PerformanceCalculatorResult(126, 20, 42, 50)
     self.assertAlmostEqual(pcr._calculate_recall(), 0.750, 3)
Beispiel #11
0
 def setUp(self):
     """ Initialize data for tests """
     self._pcr = PerformanceCalculatorResult(42, 1, 0, 5)
Beispiel #12
0
class PerformanceCalculatorResultTests(TestCase):
    """ Tests of the PerformanceCalculatorResult object 

        Note: I like to use abbreviation of the class names to make 
            the makes more clear -- in this case that abbreviation is
            PCR, which is a litle weird since that's a very common 
            acronym. Just to make it clear, this reference is to
            PerformanceCalculatorResult, not Polymerase Chain Reaction.

    """

    def setUp(self):
        """ Initialize data for tests """
        self._pcr = PerformanceCalculatorResult(42, 1, 0, 5)

    def test_init_all_ints(self):
        """PCR: init functions as expected with valid & complete input """
        pcr = PerformanceCalculatorResult(42, 1, 0, 5)
        self.assertEqual(pcr.TruePositive, 42)
        self.assertEqual(pcr.FalsePositive, 1)
        self.assertEqual(pcr.FalseNegative, 0)
        self.assertEqual(pcr.TrueNegative, 5)

        self.assertAlmostEqual(pcr.Precision, 0.9767, 3)
        self.assertAlmostEqual(pcr.Recall, 1.0, 3)
        self.assertAlmostEqual(pcr.FMeasure, 0.9882, 3)

    def test_init_missing_TN(self):
        """PCR: init functions with missing or non-int TrueNeagtive """
        # TN = n/a
        pcr = PerformanceCalculatorResult(42, 1, 0, "n/a")
        self.assertEqual(pcr.TruePositive, 42)
        self.assertEqual(pcr.FalsePositive, 1)
        self.assertEqual(pcr.FalseNegative, 0)
        self.assertEqual(pcr.TrueNegative, None)

        self.assertAlmostEqual(pcr.Precision, 0.9767, 3)
        self.assertAlmostEqual(pcr.Recall, 1.0, 3)
        self.assertAlmostEqual(pcr.FMeasure, 0.9882, 3)
        # TN = None
        pcr = PerformanceCalculatorResult(42, 1, 0, None)
        pcr = PerformanceCalculatorResult(42, 1, 0)

    def test_calculate_precision(self):
        """PCR: precision calculations function as expected """
        # Max and min tests
        pcr = PerformanceCalculatorResult(50, 0, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 1.000, 3)
        pcr = PerformanceCalculatorResult(0, 50, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.000, 3)
        # Intermediate tests
        pcr = PerformanceCalculatorResult(42, 1, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.9767, 3)
        pcr = PerformanceCalculatorResult(1, 42, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.0232, 3)
        pcr = PerformanceCalculatorResult(42, 42, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.500, 3)
        pcr = PerformanceCalculatorResult(42, 126, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.250, 3)
        pcr = PerformanceCalculatorResult(126, 42, 0, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.750, 3)
        # FN/TN has no effect
        pcr = PerformanceCalculatorResult(126, 42, 20, None)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.750, 3)
        pcr = PerformanceCalculatorResult(126, 42, 20, 50)
        self.assertAlmostEqual(pcr._calculate_precision(), 0.750, 3)

    def test_calculate_recall(self):
        """PCR: recall calculations function as expected """
        # Max and min tests
        pcr = PerformanceCalculatorResult(50, 0, 0, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 1.000, 3)
        pcr = PerformanceCalculatorResult(0, 0, 50, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.000, 3)
        # Intermediate tests
        pcr = PerformanceCalculatorResult(42, 0, 1, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.9767, 3)
        pcr = PerformanceCalculatorResult(1, 0, 42, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.0232, 3)
        pcr = PerformanceCalculatorResult(42, 0, 42, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.500, 3)
        pcr = PerformanceCalculatorResult(42, 0, 126, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.250, 3)
        pcr = PerformanceCalculatorResult(126, 0, 42, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.750, 3)
        # FP/TN have no effect
        pcr = PerformanceCalculatorResult(126, 20, 42, None)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.750, 3)
        pcr = PerformanceCalculatorResult(126, 20, 42, 50)
        self.assertAlmostEqual(pcr._calculate_recall(), 0.750, 3)

    def test_f_measure(self):
        """PCR: f-measure calculations function as expected """
        # Max and min tests
        pcr = PerformanceCalculatorResult(50, 0, 0, None)
        self.assertAlmostEqual(pcr._calculate_f_measure(), 1.000, 3)
        pcr = PerformanceCalculatorResult(0, 50, 0, None)
        self.assertEqual(pcr._calculate_f_measure(), None)
        pcr = PerformanceCalculatorResult(0, 0, 50, None)
        self.assertEqual(pcr._calculate_f_measure(), None)

    def test_calculation_divide_by_zeros(self):
        """PCR: P/R/F calculations correctly handle divide-by-zero errors"""
        # Divide by zero handled correctly
        pcr = PerformanceCalculatorResult(0, 0, 0, None)
        self.assertEqual(pcr._calculate_precision(), None)
        self.assertEqual(pcr._calculate_recall(), None)
        self.assertEqual(pcr._calculate_f_measure(), None)

    def test_pretty_precision_recall_fmeasure(self):
        """PCR: PRF formatting functions as expected """
        expected = "Precision\tRecall\tF-measure\n0.9767\t1.0000\t0.9882"
        self.assertEqual(self._pcr.pretty_precision_recall_fmeasure(), expected)

    def test_pretty_confusion_matrix(self):
        """PCR: Confusion matrix formatting functions as expected """
        expected = "tp\tfn\nfp\ttn\n--\n42\t0\n1\t5"
        self.assertEqual(self._pcr.pretty_confusion_matrix(), expected)

    def test_str(self):
        """PCR: str() functions as expected """
        expected = "\n".join(
            ["tp\tfn\nfp\ttn\n--\n42\t0\n1\t5", "Precision\tRecall\tF-measure\n0.9767\t1.0000\t0.9882"]
        )
        self.assertEqual(str(self._pcr), expected)