class_stats¶

Variables

struct [anonymous] get_TOP¶

Number of positive outcomes.

TOP = TP + FP

Param TP: array of true positives
Param FP: array of false positives
Param Nclass: size of classes array (aka number of classes)
Return: The array of the number of positives outcomes for each class.

struct [anonymous] get_TON¶

Number of negative outcomes.

TON = TN + FN

Param TN: array of true negatives
Param FN: array of false negative
Param Nclass: size of classes array (aka number of classes)
Return: The array of the number of negative outcomes for each class.

struct [anonymous] get_TPR¶

True positive rates.

Sensitivity (also called the true positive rate, the recall, or probability of detection in some fields) measures the proportion of positives that are correctly identified as such (e.g. the percentage of sick people who are correctly identified as having the condition)

TPR = TP / P = TP / (TP + FN)

Param TP: array of true positives
Param FN: array of false negative
Param Nclass: size of classes array (aka number of classes)
Return: The array of the true positive rate outcomes for each class.

struct [anonymous] get_TNR¶

True negative rates.

Specificity (also called the true negative rate) measures the proportion of negatives that are correctly identified as such (e.g. the percentage of healthy people who are correctly identified as not having the condition)

TPN = TN / N = TN / (TN + FP)

Param TN: array of true negatives
Param FP: array of false positives
Param Nclass: size of classes array (aka number of classes)
Return: The array of the true negative rate outcomes for each class.

struct [anonymous] get_PPV¶

Positive predictive value.

Positive predictive value (PPV) is the proportion of positives that correspond to the presence of the condition

PPV = TP / (TP + FP)

Param TP: array of true positives
Param FP: array of false positives
Param Nclass: size of classes array (aka number of classes)
Return: The array of the positive predicted values for each class.

struct [anonymous] get_NPV¶

Negative predictive value.

Negative predictive value (NPV) is the proportion of negatives that correspond to the absence of the condition

NPV = TN / (TN + FN)

Param TP: array of true negatives
Param FP: array of false negatives
Param Nclass: size of classes array (aka number of classes)
Return: The array of the negative predicted values for each class.

struct [anonymous] get_FNR¶

False negative rate.

The false negative rate is the proportion of positives which yield negative test outcomes with the test, i.e., the conditional probability of a negative test result given that the condition being looked for is present.

FNR = FN / P = FN / (FN + TP) = 1 - TPR

Param TPR: array of true positive rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of the false negative rates for each class.

struct [anonymous] get_FPR¶

False positive rate.

The false positive rate is the proportion of all negatives that still yield positive test outcomes, i.e., the conditional probability of a positive test result given an event that was not present. The false positive rate is equal to the significance level. The specificity of the test is equal to 1 minus the false positive rate.

FPR = FP / N = FP / (FP + TN) = 1 - TNR

Param TNR: array of true negative rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of the false positive rates for each class.

struct [anonymous] get_FDR¶

False discovery rate.

The false discovery rate (FDR) is a method of conceptualizing the rate of type I errors in null hypothesis testing when conducting multiple comparisons. FDR-controlling procedures are designed to control the expected proportion of “discoveries” (rejected null hypotheses) that are false (incorrect rejections).

FDR = FP / (FP + TP) = 1 - PPV

Param PPV: array of positive predictive values
Param Nclass: size of classes array (aka number of classes)
Return: The array of the false discovery rates for each class.

struct [anonymous] get_FOR¶

False omission rate.

False omission rate (FOR) is a statistical method used in multiple hypothesis testing to correct for multiple comparisons and it is the complement of the negative predictive value. It measures the proportion of false negatives which are incorrectly rejected.

FOR = FN / (FN + TN) = 1 - NPV

Param NPV: array of negative predictive values
Param Nclass: size of classes array (aka number of classes)
Return: The array of the false omission rates for each class.

struct [anonymous] get_ACC¶

Accuracy.

The accuracy is the number of correct predictions from all predictions made.

ACC = (TP + TN) / (P + N) = (TP + TN) / (TP + TN + FP + FN)

Param TP: array of true positives
Param FP: array of false positives
Param FN: array of false negative
Param TN: array of true negatives
Param Nclass: size of classes array (aka number of classes)
Return: The array of accuracies for each class.

struct [anonymous] get_F1_SCORE¶

Fbeta-score.

In statistical analysis of classification, the F1 score (also F-score or F-measure) is a measure of a test’s accuracy. It considers both the precision p and the recall r of the test to compute the score. The F1 score is the harmonic average of the precision and recall, where F1 score reaches its best value at 1 (perfect precision and recall) and worst at 0. In this case the score is evaluated with beta=1.

Fbeta = (1 + beta**2) * (PPV * TPR) / (beta**2 * PPV) + TPR = (1 + beta**2) * TP / ((1 + beta**2) * TP + FP + beta**2 * FN)

Param TP: array of true positives
Param FP: array of false positives
Param FN: array of false negative
Param Nclass: size of classes array (aka number of classes)
Return: The array of F1 scores for each class.

struct [anonymous] get_F05_SCORE¶

Fbeta-score.

In statistical analysis of classification, the F1 score (also F-score or F-measure) is a measure of a test’s accuracy. It considers both the precision p and the recall r of the test to compute the score. The F1 score is the harmonic average of the precision and recall, where F1 score reaches its best value at 1 (perfect precision and recall) and worst at 0. In this case the score is evaluated with beta=0.5.

Fbeta = (1 + beta**2) * (PPV * TPR) / (beta**2 * PPV) + TPR = (1 + beta**2) * TP / ((1 + beta**2) * TP + FP + beta**2 * FN)

Param TP: array of true positives
Param FP: array of false positives
Param FN: array of false negative
Param Nclass: size of classes array (aka number of classes)
Return: The array of F1 scores for each class.

struct [anonymous] get_F2_SCORE¶

Fbeta-score.

In statistical analysis of classification, the F1 score (also F-score or F-measure) is a measure of a test’s accuracy. It considers both the precision p and the recall r of the test to compute the score. The F1 score is the harmonic average of the precision and recall, where F1 score reaches its best value at 1 (perfect precision and recall) and worst at 0. In this case the score is evaluated with beta=2.

Fbeta = (1 + beta**2) * (PPV * TPR) / (beta**2 * PPV) + TPR = (1 + beta**2) * TP / ((1 + beta**2) * TP + FP + beta**2 * FN)

Param TP: array of true positives
Param FP: array of false positives
Param FN: array of false negative
Param Nclass: size of classes array (aka number of classes)
Return: The array of F1 scores for each class.

struct [anonymous] get_MCC¶

Matthews correlation coefficient.

The Matthews correlation coefficient is used in machine learning as a measure of the quality of binary (two-class) classifications, introduced by biochemist Brian W. Matthews in 1975. It takes into account true and false positives and negatives and is generally regarded as a balanced measure that can be used even if the classes are of very different sizes. The MCC is, in essence, a correlation coefficient between the observed and predicted binary classifications; it returns a value between −1 and +1. A coefficient of +1 represents a perfect prediction, 0 no better than random prediction and −1 indicates total disagreement between prediction and observation.

MCC = (TP * TN - FP * FN) / sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN))

Param TP: array of true positives
Param TN: array of true negatives
Param FP: array of false positives
Param FN: array of false negative
Param Nclass: size of classes array (aka number of classes)
Return: The array of MCC scores for each class.

struct [anonymous] get_BM¶

Bookmaker informedness.

The informedness of a prediction method as captured by a contingency matrix is defined as the probability that the prediction method will make a correct decision as opposed to guessing and is calculated using the bookmaker algorithm. It is equal to Youden Index.

BM = TPR + TNR - 1

Param TPR: array of true positive rates
Param TNR: array of true negative rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of BM scores for each class.

struct [anonymous] get_MK¶

Markedness.

In statistics and psychology, the social science concept of markedness is quantified as a measure of how much one variable is marked as a predictor or possible cause of another and is also known as △P in simple two-choice cases.

MK = PPV + NPV - 1

Param PPV: array of positive predictive values
Param NPV: array of negative predictive values
Param Nclass: size of classes array (aka number of classes)
Return: The array of MK scores for each class.

struct [anonymous] get_ICSI¶

Individual classification success index.

The Individual Classification Success Index (ICSI), is a class-specific symmetric measure defined for classification assessment purpose. ICSI is hence 1 minus the sum of type I and type II errors. It ranges from −1 (both errors are maximal, i.e. 1) to 1 (both errors are minimal, i.e. 0), but the value 0 does not have any clear meaning. The measure is symmetric, and linearly related to the arithmetic mean of TPR and PPV

ICSI = PPV + TPR - 1

Param PPV: array of positive predictive values
Param TPR: array of true positive rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of ICSI for each class.

struct [anonymous] get_PLR¶

Positive likelihood ratio.

Likelihood ratios are used for assessing the value of performing a diagnostic test. They use the sensitivity and specificity of the test to determine whether a test result usefully changes the probability that a condition (such as a disease state) exists. The first description of the use of likelihood ratios for decision rules was made at a symposium on information theory in 1954.

PLR = TPR / FPR

Param TPR: array of true positive rates
Param FPR: array of false positive rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of TPR for each class.

struct [anonymous] get_NLR¶

Negative likelihood ratio.

Likelihood ratios are used for assessing the value of performing a diagnostic test. They use the sensitivity and specificity of the test to determine whether a test result usefully changes the probability that a condition (such as a disease state) exists. The first description of the use of likelihood ratios for decision rules was made at a symposium on information theory in 1954.

NLR = FNR / TNR

Param FNR: array of false negative rates
Param TNR: array of true negative rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of NLR for each class.

struct [anonymous] get_DOR¶

Diagnostic odds ratio.

The diagnostic odds ratio is a measure of the effectiveness of a diagnostic test. It is defined as the ratio of the odds of the test being positive if the subject has a disease relative to the odds of the test being positive if the subject does not have the disease.

DOR = PLR / NLR

Param PLR: array of positive likelihood ratio values.
Param NLR: array of negative likelihood ratio values.
Param Nclass: size of classes array (aka number of classes)
Return: The array of DOR scores for each class.

struct [anonymous] get_PRE¶

Prevalence.

Prevalence is a statistical concept referring to the number of cases of a disease that are present in a particular population at a given time (Reference Likelihood).

PRE = P / POP

Param P: array of the number of positive samples for each class.
Param POP: array of total samples for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of PRE scores for each class.

struct [anonymous] get_G¶

G-measure.

The geometric mean of precision and sensitivity, also known as Fowlkes–Mallows index.

G = sqrt(PPV * TPR)

Param PPV: array of positive predicted values.
Param TPR: array of true positive rates.
Param Nclass: size of classes array (aka number of classes)
Return: The array of G scores for each class.

struct [anonymous] get_RACC¶

Random accuracy.

The expected accuracy from a strategy of randomly guessing categories according to reference and response distributions.

RACC = (TOP * P) / POP**2

Param TOP: array of positive predicted values for each class.
Param P: array of true positive rates for each class.
Param POP: array of true positive rates for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of RACC scores for each class.

struct [anonymous] get_ERR_ACC¶

Error rate.

The error rate is the number of incorrect predictions from all predictions made.

ERR = (FP + FN) / (P + N) = (FP + FN) / (TP + TN + FP + FN) = 1 - ACC

Param ACC: array of accuracy scores for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of error rates for each class.

struct [anonymous] get_RACCU¶

Random accuracy unbiased.

The expected accuracy from a strategy of randomly guessing categories according to the average of the reference and response distributions.

RACCU = ((TOP + P) / (2 * POP))**2

Param TOP: array of positive predicted values.
Param P: array of true positive rates.
Param POP: array of true positive rates.
Param Nclass: size of classes array (aka number of classes)
Return: The array of RACCU scores for each class.

struct [anonymous] get_jaccard_index¶

Jaccard index.

The Jaccard index, also known as Intersection over Union and the Jaccard similarity coefficient (originally coined coefficient de communauté by Paul Jaccard), is a statistic used for comparing the similarity and diversity of sample sets.

J = TP / (TOP + P - TP)

Param TP: array of true positive values.
Param TOP: array of positive predicted values.
Param P: array of true positive rates.
Param Nclass: size of classes array (aka number of classes)
Return: The array of J scores for each class.

struct [anonymous] get_IS¶

Information score.

The amount of information needed to correctly classify an example into class C, whose prior probability is p(C), is defined as −log2⁡(p(C)).

IS = -log2( (TP + FN)/POP ) + log2( TP / (TP + FP))

Param TP: array of true positive values.
Param FP: array of false positive values.
Param FN: array of false negative values.
Param POP: array of true positive rates.
Param Nclass: size of classes array (aka number of classes)
Return: The array of IS scores for each class.

struct [anonymous] get_CEN¶

Confusion entropy.

CEN based upon the concept of entropy for evaluating classifier performances. By exploiting the misclassification information of confusion matrices, the measure evaluates the confusion level of the class distribution of misclassified samples. Both theoretical analysis and statistical results show that the proposed measure is more discriminating than accuracy and RCI while it remains relatively consistent with the two measures. Moreover, it is more capable of measuring how the samples of different classes have been separated from each other. Hence the proposed measure is more precise than the two measures and can substitute for them to evaluate classifiers in classification applications.

Param confusion_matrix: confusion matrix.
Param Nclass: size of classes array (aka number of classes)
Return: The array of CEN for each class.

struct [anonymous] get_MCEN¶

Modified confusion entropy.

Modified version of CEN

Param confusion_matrix: confusion matrix.
Param Nclass: size of classes array (aka number of classes)
Return: The array of MCEN for each class.

struct [anonymous] get_AUC¶

Area under the ROC curve.

The area under the curve (often referred to as simply the AUC) is equal to the probability that a classifier will rank a randomly chosen positive instance higher than a randomly chosen negative one (assuming ‘positive’ ranks higher than ‘negative’). Thus, AUC corresponds to the arithmetic mean of sensitivity and specificity values of each class.

AUC = (TNR + TPR) / 2

Param TNR: array of true negative rates
Param TPR: array of true positive rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of AUC for each class.

struct [anonymous] get_dIND¶

Distance index.

Euclidean distance of a ROC point from the top left corner of the ROC space, which can take values between 0 (perfect classification) and sqrt(2).

dInd = sqrt((1 - TNR)**2 + (1 - TPR)**2)

Param TNR: array of true negative rates
Param TPR: array of true positive rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of dInd for each class.

struct [anonymous] get_sIND¶

Similarity index.

sInd is comprised between 0 (no correct classifications) and 1 (perfect classification).

sInd = 1 - dInd

Param dInd: array of distance indexes for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of sInd for each class.

struct [anonymous] get_DP¶

Discriminant power.

Discriminant power (DP) is a measure that summarizes sensitivity and specificity. The DP has been used mainly in feature selection over imbalanced data.

DP = (sqrt(3) / π ) * (log10(TPR / (1 - TPR)) + log10(TNR / (1 - TNR)))

Param TPR: array of true positive rates
Param TNR: array of true negative rates
Param Nclass: size of classes array (aka number of classes)
Return: The array of DP for each class.

struct [anonymous] get_Y¶

Youden index.

Youden’s index evaluates the algorithm’s ability to avoid failure; it’s derived from sensitivity and specificity and denotes a linear correspondence balanced accuracy. As Youden’s index is a linear transformation of the mean sensitivity and specificity, its values are difficult to interpret, we retain that a higher value of Y indicates better ability to avoid failure. Youden’s index has been conventionally used to evaluate tests diagnostic, improve the efficiency of Telemedical prevention.

Y = BM = TPR + TNR - 1

Param BM: array of bookmaker indexes for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of Y for each class.

struct [anonymous] get_PLRI¶

Positive likelihood ratio interpretation.

The score follows the ranges

PLR < 1 Negligible
1 < PLR < 5 Poor
5 < PLR < 10 Fair
PLR > 10 Good

Param PLR: array of positive likelihood ratio values.
Param Nclass: size of classes array (aka number of classes)
Return: The array of PLRI for each class.

struct [anonymous] get_NLRI¶

Negative likelihood ratio interpretation.

The score follows the ranges

0.5 < NLR < 1 Negligible
0.2 < NLR < 0.5 Poor
0.1 < NLR < 0.2 Fair
NLR > 0.1 Good

Param NLR: array of negative likelihood ratio values for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of NLRI for each class.

struct [anonymous] get_DPI¶

Discriminant power interpretation.

The score follows the ranges

DPI < 1 Poor
1 < DPI < 2 Limited
2 < DPI < 3 Fair
DPI > 3 Good

Param DP: array of discriminant power values for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of DPI for each class.

struct [anonymous] get_AUCI¶

AUC value interpretation.

The score follows the ranges

0.5 < AUCI > 0.6 Poor
0.6 < AUCI < 0.7 Fair
0.7 < AUCI < 0.8 Good
0.8 < AUCI < 0.9 Very good
0.9 < AUCI < 1.0 Excellent

Param AUC: array of area under the curve values for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of AUCI for each class.

struct [anonymous] get_GI¶

Gini index.

A chance-standardized variant of the AUC is given by Gini coefficient, taking values between 0 (no difference between the score distributions of the two classes) and 1 (complete separation between the two distributions). Gini coefficient is widespread use metric in imbalanced data learning.

GI = 2 * AUC - 1

Param AUC: array of area under the curve values for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of Gini-index scores for each class

struct [anonymous] get_LS¶

Lift score.

In the context of classification, lift compares model predictions to randomly generated predictions. Lift is often used in marketing research combined with gain and lift charts as a visual aid.

LS = PPV / PRE

Param PPV: array of positive predicted values for each class.
Param PRE: array of prevalence scores for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of LS scores for each class

struct [anonymous] get_AM¶

Automatic/Manual.

Difference between automatic and manual classification i.e., the difference between positive outcomes and of positive samples.

AM = TOP - P = (TP + FP) - (TP + FN)

Param TOP: array of positive predicted values for each class.
Param P: array of the number of positive samples for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of AM scores for each class

struct [anonymous] get_OP¶

Optimized precision.

Optimized precision is a type of hybrid threshold metric and has been proposed as a discriminator for building an optimized heuristic classifier. This metric is a combination of accuracy, sensitivity and specificity metrics. The sensitivity and specificity metrics were used for stabilizing and optimizing the accuracy performance when dealing with an imbalanced class of two-class problems.

OP = ACC - abs(TNR - TPR) / abs(TNR + TPR)

Param ACC: array of accuracy scores for each class.
Param TPR: array of true positive rates for each class.
Param TNR: array of true negative rates for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of OP scores for each class

struct [anonymous] get_IBA¶

Index of balanced accuracy.

The method combines an unbiased index of its overall accuracy and a measure about how dominant is the class with the highest individual accuracy rate.

IBAα = (1 + α * (TPR - TNR)) * TNR * TPR

Param TPR: array of true positive rates for each class.
Param TNR: array of true negative rates for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of IBA scores for each class

struct [anonymous] get_GM¶

G-mean.

Geometric mean of specificity and sensitivity.

GM = sqrt(TPR * TNR)

Param TNR: array of true negative rates for each class.
Param TPR: array of true positive rates for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of GM scores for each class

struct [anonymous] get_Q¶

Yule’s Q.

In statistics, Yule’s Q, also known as the coefficient of colligation, is a measure of association between two binary variables.

OR = (TP * TN) / (FP * FN)
Q = (OR - 1) / (OR + 1)

Param TP: array of true positives for each class.
Param TN: array of true negatives for each class.
Param FP: array of false positives for each class.
Param FN: array of false negative for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of Q scores for each class

struct [anonymous] get_AGM¶

Adjusted G-mean.

An adjusted version of the geometric mean of specificity and sensitivity.

Nn = N / POP
AGM = (GM + TNR * Nn) / (1 + Nn) if TPR > 0 else 0

Param TPR: array of true positive rates for each class.
Param TNR: array of true negative rates for each class.
Param GM: array of geometric means for each class.
Param N: array of number of negative samples for each class.
Param POP: array of total samples for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of AGM score values for each class.

struct [anonymous] get_MCCI¶

Matthews correlation coefficient interpretation.

MCC is a confusion matrix method of calculating the Pearson product-moment correlation coefficient (not to be confused with Pearson’s C). Therefore, it has the same interpretation. The score follows the ranges

MCCI < 0.3 Negligible
0.3 < MCCI < 0.5 Weak
0.5 < MCCI < 0.7 Moderate
0.7 < MCCI < 0.9 Strong
0.9 < MCCI < 1.0 Very Strong

Param MCC: array of Matthews correlation coefficients for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of MCCI scores for each class.

struct [anonymous] get_AGF¶

Adjusted F-score.

The F-measures used only three of the four elements of the confusion matrix and hence two classifiers with different TNR values may have the same F-score. Therefore, the AGF metric is introduced to use all elements of the confusion matrix and provide more weights to samples which are correctly classified in the minority class.

F2 = 5 * (PPV * TPR) / ((4 * PPV) + TPR)
InvF0.5 = (1 + 0.5**2) * (NPV * TNR) / ((0.5**2 * NPV) + TNR)
AGF = sqrt(F2 * invF0.5)

Param TP: array of true positives
Param FP: array of false positives
Param FN: array of false negative
Param TN: array of true negatives
Param Nclass: size of classes array (aka number of classes)
Return: The array of AGF scores for each class.

struct [anonymous] get_OC¶

Overlap coefficient.

The overlap coefficient, or Szymkiewicz–Simpson coefficient, is a similarity measure that measures the overlap between two finite sets. It is defined as the size of the intersection divided by the smaller of the size of the two sets.

OC = TP / min(TOP, P) = max(PPV, TPR)

Param TP: array of true positive values for each class.
Param TOP: array of positive predicted values for each class.
Param P: array of the number of positive samples for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of OC values for each class.

struct [anonymous] get_OOC¶

Otsuka-Ochiai coefficient.

In biology, there is a similarity index, known as the Otsuka-Ochiai coefficient named after Yanosuke Otsuka and Akira Ochiai, also known as the Ochiai-Barkman or Ochiai coefficient. If sets are represented as bit vectors, the Otsuka-Ochiai coefficient can be seen to be the same as the cosine similarity.

OOC = TP / sqrt(TOP * P)

Param TP: array of true positive values for each class.
Param TOP: array of positive predicted values for each class.
Param P: array of the number of positive samples for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of OOC values for each class.

struct [anonymous] get_AUPR¶

Area under the PR curve.

A PR curve is plotting precision against recall. The precision recall area under curve (AUPR) is just the area under the PR curve. The higher it is, the better the model is.

AUPR = (TPR + PPV) / 2

Param PPV: array of positive predicted values for each class.
Param TPR: array of true positive rates for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of AUPR values for each class.

struct [anonymous] get_BCD¶

Bray-Curtis dissimilarity.

In ecology and biology, the Bray–Curtis dissimilarity, named after J. Roger Bray and John T. Curtis, is a statistic used to quantify the compositional dissimilarity between two different sites, based on counts at each site.

BCD = abs(AM) / sum(TOP + P)

Param TOP: array of positive predicted values for each class.
Param P: array of the number of positive samples for each class.
Param AM: array of Automatic/Manual differences for each class.
Param Nclass: size of classes array (aka number of classes)
Return: The array of BCD scores for each class.