Ejemplo n.º 1
0
def weighted_c_index_error(target, result):
    '''Used in genetic training.
    multiplied by length of target array because it is divided by the length of the target array in the genetic algorithm.'''
    #len(target) first to compensate for internals in genetic training
    #abs( - 0.5) to make both "positive" and "negative" C_index work, since they do
    C = get_weighted_C_index(target, result)

    return __inversed__(C, len(target))
Ejemplo n.º 2
0
    def testGeneticWeightedCindexError(self):
        print("\nWeighted C Error")
        T = self.generateRandomTestData(1000)
        outputs = self.generateRandomTestData(1000)
        c_index = get_weighted_C_index(T, outputs)
        rand_error = weighted_c_index_error(T, outputs) / len(T)
        test_error = 1 / c_index
        print("rand_error = ", rand_error, "test value = ", test_error, "weighted_index = ", c_index)
        assert((rand_error - test_error) < 0.0001)

        T[:, 0] = np.arange(len(T))
        outputs = T
        rev_outputs = outputs[::-1]

        c_index = get_weighted_C_index(T, outputs)
        ord_error = weighted_c_index_error(T, outputs) / len(T)
        test_error = 1 / c_index
        print("ordered_error = ", ord_error, "test value = ", test_error, "weighted_index = ", c_index)
        assert(ord_error == test_error)

        c_index = get_weighted_C_index(T, rev_outputs)
        rev_error = weighted_c_index_error(T, rev_outputs) / len(T)
        #test_error = 1 / c_index #Will give zero-division, set to 9000
        test_error = 9000.0
        print("reversed_error = ", rev_error, "test value = ", test_error, "weighted_index = ", c_index)
        assert(rev_error == test_error)

        assert(ord_error < rev_error)

        T[:, 0] = np.arange(len(T))
        T[0, 1], T[-1, 1] = 1, 1 #Make sure they are non-censored
        outputs = T.copy()
        outputs[0], outputs[-1] = outputs[-1], outputs[0]
        rev_outputs = outputs[::-1]

        c_index = get_weighted_C_index(T, outputs)
        ord_error = weighted_c_index_error(T, outputs) / len(T)
        test_error = 1 / c_index
        print("1_off_ends_error = ", ord_error, "test value = ", test_error, "weighted_index = ", c_index)
        assert(ord_error == test_error)

        assert(ord_error > 1)
        ord_error_ends = ord_error

        c_index = get_weighted_C_index(T, rev_outputs)
        rev_error = weighted_c_index_error(T, rev_outputs) / len(T)
        test_error = 1 / c_index
        print("1_off_ends_reversed_error = ", rev_error, "test value = ", test_error, "weighted_index = ", c_index)
        assert(rev_error == test_error)

        assert(rev_error > 1)

        rev_error_ends = rev_error

        T[:, 0] = np.arange(len(T))
        T[len(T) / 2, 1], T[len(T) / 2 + 1, 1] = 1, 1 #Make sure they are non-censored
        outputs = T.copy()
        outputs[len(T) / 2], outputs[len(T) / 2 + 1] = outputs[len(T) / 2 + 1], outputs[len(T) / 2]
        rev_outputs = outputs[::-1]

        c_index = get_weighted_C_index(T, outputs)
        ord_error = weighted_c_index_error(T, outputs) / len(T)
        test_error = 1 / c_index
        print("1_off_middle_error = ", ord_error, "test value = ", test_error, "weighted_index = ", c_index)
        assert(ord_error == test_error)

        assert(ord_error > 1)
        assert(ord_error < ord_error_ends)

        c_index = get_weighted_C_index(T, rev_outputs)
        rev_error = weighted_c_index_error(T, rev_outputs) / len(T)
        print("1_off_middle_reversed_error = ", rev_error, "weighted_index = ", c_index)

        assert(rev_error > rev_error_ends)