查找两个数组之间的匹配项，并且第一个数组 == 1？

Question

I have two arrays (y_true and y_pred), both consisting of 0's and 1's of the same length.

I want a more efficient/faster way of counting how many times y_pred == y_true, AND when y_pred == 1. I'm not interested in counting the matching 0's.

Right now, my function looks like this using a for loop:

from sklearn.metrics.scorer import make_scorer
# Make a custom metric function
def my_custom_accuracy(y_true, y_pred):       # Bring in the arrays
    good_matches = 0                          # Set counter to 0
    for num, i in enumerate(y_pred):          # for each y_pred in array...
        if i == y_true[num] & i == 1:         # if y_pred == y_true AND y_pred == 1...
            good_matches += 1                 # count it as a good match
    return float(good_matches / sum(y_true))  # return good matches as a % of all the 1's in y_true

....it works, but the for loop is slow and not very efficient. I was hoping to utilize something like this:

# Make a custom metric function
def my_custom_accuracy(y_true, y_pred):
    return float(sum(y_pred == y_true)) / sum(y_true)

...simple, but I don't know how to add in the "& y_pred == 1" part. Any ideas? Thanks!

Answer 1

You can use a list comprehension to check the lists against each other while filtering out y_pred == 0, then get your accuracy by dividing the matches by the length of the compare list.

compare = [p == t for p, t in zip(y_pred, y_true) if p == 1]
accuracy = compare.count(True) / len(compare)

Or for something utilizing numpy:

mask = np.where(y_true == y_pred)
matches = y_pred[mask]
accuracy = np.sum(matches) / len(matches)

Answer 2

If the arrays aren't already boolean, make them boolean. This can be done cheaply with a view, or more simply with astype :

y_pred = y_pred.astype(bool)
y_true = y_true.astype(bool)

This step can be omitted if the arrays are already boolean, or if they really will never contain anything but zeros and ones.

Now good_matches is just

good_matches = np.sum(y_pred & y_true)

To see why that's so, note that in addition to obviously containing y_pred == y_true , the expression can only be true when y_pred is true, so it automatically implies y_pref == 1 and y_true == 1 , by the definition of the & operator.

Your final result is therefore

np.sum(y_pred & y_true) / np.sum(y_true)

This can be alternatively written as

np.count_nonzero(y_pred & y_true) / np.count_nonzero(y_true)