scores.py

from main import *

def apk(actual, predicted, k):
    """
    Computes the average precision at k.
    This function computes the average prescision at k between two lists of
    items.
    Parameters
    ----------
    actual : list
             A list of elements that are to be predicted (order doesn't matter)
    predicted : list
                A list of predicted elements (order does matter)
    k : int, optional
        The maximum number of predicted elements
    Returns
    -------
    score : double
            The average precision at k over the input lists
    """
    if len(predicted)>k:
        predicted = predicted[:k]

    score = 0.0
    num_hits = 0.0

    for i,p in enumerate(predicted):
        if p in actual and p not in predicted[:i]:
            num_hits += 1.0
            score += num_hits / (i+1.0)

    if not actual:
        return 0.0

    score = score / min(len(actual), k)

    return score / min(len(actual), k)

    


def mapk(actual, predicted, k, ):
    """
    Computes the mean average precision at k.
    This function computes the mean average prescision at k between two lists
    of lists of items.
    Parameters
    ----------
    actual : list
             A list of lists of elements that are to be predicted 
             (order doesn't matter in the lists)
    predicted : list
                A list of lists of predicted elements
                (order matters in the lists)
    k : int, optional
        The maximum number of predicted elements
    Returns
    -------
    score : double
            The mean average precision at k over the input lists
    """
    return np.mean([apk(a,p,k) for a,p in zip(actual, predicted)])


def apk2(actual, predicted, k):
    """
    Computes the average precision at k.
    This function computes the average prescision at k between two lists of
    items.
    Parameters
    ----------
    actual : list
             A list of elements that are to be predicted (order doesn't matter)
    predicted : list
                A list of predicted elements (order does matter)
    k : int, optional
        The maximum number of predicted elements
    Returns
    -------
    score : double
            The average precision at k over the input lists
    """
    scores=[]
    for i in range(len(predicted)):
        predicted_part = predicted[i]
        actual_part = [actual[i]]
        if len(predicted_part)>k:
            predicted_part = predicted_part[:k]

        score = 0.0
        num_hits = 0.0

        for i,p in enumerate(predicted_part):
            if p in actual_part and p not in predicted_part[:i]:
                num_hits += 1.0
                score += num_hits / (i+1.0)

        if not actual_part:
            return 0.0

        score = score / min(len(actual_part), k)
        scores.append(score / min(len(actual_part), k))
    
    if len(predicted) == 2:
        score = np.mean(scores)
    else:
        score = scores[0]
    

    return score



def mapk2(actual, predicted, k, ):
    """
    Computes the mean average precision at k.
    This function computes the mean average prescision at k between two lists
    of lists of items.
    Parameters
    ----------
    actual : list
             A list of lists of elements that are to be predicted 
             (order doesn't matter in the lists)
    predicted : list
                A list of lists of predicted elements
                (order matters in the lists)
    k : int, optional
        The maximum number of predicted elements
    Returns
    -------
    score : double
            The mean average precision at k over the input lists
    """

    # predicted2=[]
    # for i in range(len(predicted)):
    #     predicted2.append([])
    #     for j in range(len(predicted[i])):
    #         predicted2[i].append([predicted[i][j]])

    count = 0
    result = 0
    for i in range(len(predicted)):
        image = predicted[i]
        for j in range(len(image)):
            count+=1
            painting = predicted[i][j]
            solution = [actual[i][j]]
            apk_res = apk(solution,painting,k)
            result +=apk_res
    
    average = result / count

    return average