Thanks!

[davidechicco]

Hola Arthur,
Thanks for having implemented our curve software in Python, that's extremely useful! I hope you'll be able to add the metric feature too.

Best,

-- Davide Chicco

[arthurcgusmao]

Hi @davidechicco , thanks a lot for your presence here :)

Coincidentally, I have recently talked to a friend about implementing the metric and we will try to submit a PR soon. I'll link the PR to this issue once it is created.

Best,
Arthur Colombini Gusmão

[SamusRam]

Hi @arthurcgusmao , @davidechicco ,

Thank you for your great work!

FYI, for now I'm going to use the following re-implementation of the Davide's R code:

from mcc_f1 import mcc_f1_curve
import numpy as np

def summary_mccf1(y_true, y_pred, digits=None, bins=100):
    mcc_nor_truncated, f_truncated, thresholds = mcc_f1_curve(y_true, y_pred)
    # Get the index of the point with the largest normalized MCC
    index_of_max_mcc = np.argmax(mcc_nor_truncated)

    # Define points on the MCC-F1 curve located on the left of the point with the highest normalized MCC as "left curve"
    mcc_left = mcc_nor_truncated[:index_of_max_mcc + 1]
    f_left = f_truncated[:index_of_max_mcc + 1]

    # Define points on the MCC-F1 curve located on the right of the point with the highest normalized MCC as "right curve"
    mcc_right = mcc_nor_truncated[index_of_max_mcc + 1:]
    f_right = f_truncated[index_of_max_mcc + 1:]

    # Divide the range of normalized MCC into subranges
    unit_len = (np.max(mcc_nor_truncated) - np.min(mcc_nor_truncated)) / bins

    # Calculate the sum of mean distances from the left curve to the point (1, 1)
    mean_distances_left = np.zeros(bins)
    for i in range(bins):
        pos = np.where((mcc_left >= np.min(mcc_nor_truncated) + (i - 1) * unit_len) &
                       (mcc_left <= np.min(mcc_nor_truncated) + i * unit_len))[0]
        sum_of_distance_within_subrange = np.sum(np.sqrt((mcc_left[pos] - 1) ** 2 + (f_left[pos] - 1) ** 2))
        mean_distances_left[i] = sum_of_distance_within_subrange / len(pos) if len(pos) > 0 else np.nan

    # Get rid of NAs in mean_distances_left and sum the mean distances
    num_of_na_left = np.sum(np.isnan(mean_distances_left))
    sum_of_mean_distances_left_no_na = np.nansum(mean_distances_left)

    # Calculate the sum of mean distances from the right curve to the point (1, 1)
    mean_distances_right = np.zeros(bins)
    for i in range(bins):
        pos = np.where((mcc_right >= np.min(mcc_nor_truncated) + (i - 1) * unit_len) &
                       (mcc_right <= np.min(mcc_nor_truncated) + i * unit_len))[0]
        sum_of_distance_within_subrange = np.sum(np.sqrt((mcc_right[pos] - 1) ** 2 + (f_right[pos] - 1) ** 2))
        mean_distances_right[i] = sum_of_distance_within_subrange / len(pos) if len(pos) > 0 else np.nan

    # Get rid of NAs in mean_distances_right and sum the mean distances
    num_of_na_right = np.sum(np.isnan(mean_distances_right))
    sum_of_mean_distances_right_no_na = np.nansum(mean_distances_right)

    # Calculate the MCC-F1 metric
    mccf1_metric = 1 - ((sum_of_mean_distances_left_no_na + sum_of_mean_distances_right_no_na) /
                       (bins * 2 - num_of_na_right - num_of_na_left)) / np.sqrt(2)

    # Find the best threshold
    eu_distance = np.sqrt((1 - mcc_nor_truncated) ** 2 + (1 - f_truncated) ** 2)
    best_threshold = thresholds[np.nanargmin(eu_distance)]

    # Output of the function is the MCC-F1 metric and the top threshold
    if digits is not None:
        mccf1_result = {'mccf1_metric': round(mccf1_metric, digits),
                        'best_threshold': round(best_threshold, digits)}
    else:
        mccf1_result = {'mccf1_metric': mccf1_metric,
                        'best_threshold': best_threshold}

    return mccf1_result