import numpy as np import numpy.matlib LEFT, ROPE, RIGHT = range(3) def correlated_ttest_MC(x, rope, runs=1, nsamples=50000): """ See correlated_ttest module for explanations """ if x.ndim == 2: x = x[:, 1] - x[:, 0] diff=x n = len(diff) nfolds = n / runs x = np.mean(diff) # Nadeau's and Bengio's corrected variance var = np.var(diff, ddof=1) * (1 / n + 1 / (nfolds - 1)) if var == 0: return int(x < rope), int(-rope <= x <= rope), int(rope < x) return x+np.sqrt(var)*np.random.standard_t( n - 1, nsamples) ## Correlated t-test def correlated_ttest(x, rope, runs=1, verbose=False, names=('C1', 'C2')): import scipy.stats as stats """ Compute correlated t-test The function uses the Bayesian interpretation of the p-value and returns the probabilities the difference are below `-rope`, within `[-rope, rope]` and above the `rope`. For details, see `A Bayesian approach for comparing cross-validated algorithms on multiple data sets `_, G. Corani and A. Benavoli, Mach Learning 2015. | The test assumes that the classifiers were evaluated using cross validation. The number of folds is determined from the length of the vector of differences, as `len(diff) / runs`. The variance includes a correction for underestimation of variance due to overlapping training sets, as described in `Inference for the Generalization Error `_, C. Nadeau and Y. Bengio, Mach Learning 2003.) | Args: x (array): a vector of differences or a 2d array with pairs of scores. rope (float): the width of the rope runs (int): number of repetitions of cross validation (default: 1) return: probablities (tuple) that differences are below -rope, within rope or above rope """ if x.ndim == 2: x = x[:, 1] - x[:, 0] diff=x n = len(diff) nfolds = n / runs x = np.mean(diff) # Nadeau's and Bengio's corrected variance var = np.var(diff, ddof=1) * (1 / n + 1 / (nfolds - 1)) if var == 0: return int(x < rope), int(-rope <= x <= rope), int(rope < x) pr = 1-stats.t.cdf(rope, n - 1, x, np.sqrt(var)) pl = stats.t.cdf(-rope, n - 1, x, np.sqrt(var)) pe=1-pl-pr if verbose: print('P({c1} > {c2}) = {pl}, P(rope) = {pe}, P({c2} > {c1}) = {pr}'. format(c1=names[0], c2=names[1], pl=pl, pe=pe, pr=pr)) return pl, pe, pr ## SIGN TEST def signtest_MC(x, rope, prior_strength=1, prior_place=ROPE, nsamples=50000): """ Args: x (array): a vector of differences or a 2d array with pairs of scores. rope (float): the width of the rope prior_strength (float): prior strength (default: 1) prior_place (LEFT, ROPE or RIGHT): the region to which the prior is assigned (default: ROPE) nsamples (int): the number of Monte Carlo samples Returns: 2-d array with rows corresponding to samples and columns to probabilities `[p_left, p_rope, p_right]` """ if prior_strength < 0: raise ValueError('Prior strength must be nonegative') if nsamples < 0: raise ValueError('Number of samples must be a positive integer') if rope < 0: raise ValueError('Rope must be a positive number') if x.ndim == 2: x = x[:, 1] - x[:, 0] nleft = sum(x < -rope) nright = sum(x > rope) nrope = len(x) - nleft - nright alpha = np.array([nleft, nrope, nright], dtype=float) alpha += 0.0001 # for numerical stability alpha[prior_place] += prior_strength return np.random.dirichlet(alpha, nsamples) def signtest(x, rope, prior_strength=1, prior_place=ROPE, nsamples=50000, verbose=False, names=('C1', 'C2')): """ Args: x (array): a vector of differences or a 2d array with pairs of scores. rope (float): the width of the rope prior_strength (float): prior strength (default: 1) prior_place (LEFT, ROPE or RIGHT): the region to which the prior is assigned (default: ROPE) nsamples (int): the number of Monte Carlo samples verbose (bool): report the computed probabilities names (pair of str): the names of the two classifiers Returns: p_left, p_rope, p_right """ samples = signtest_MC(x, rope, prior_strength, prior_place, nsamples) winners = np.argmax(samples, axis=1) pl, pe, pr = np.bincount(winners, minlength=3) / len(winners) if verbose: print('P({c1} > {c2}) = {pl}, P(rope) = {pe}, P({c2} > {c1}) = {pr}'. format(c1=names[0], c2=names[1], pl=pl, pe=pe, pr=pr)) return pl, pe, pr ## SIGNEDRANK def heaviside(X): Y = np.zeros(X.shape); Y[np.where(X > 0)] = 1; Y[np.where(X == 0)] = 0.5; return Y #1 * (x > 0) def signrank_MC(x, rope, prior_strength=0.6, prior_place=ROPE, nsamples=50000): """ Args: x (array): a vector of differences or a 2d array with pairs of scores. rope (float): the width of the rope prior_strength (float): prior strength (default: 0.6) prior_place (LEFT, ROPE or RIGHT): the region to which the prior is assigned (default: ROPE) nsamples (int): the number of Monte Carlo samples Returns: 2-d array with rows corresponding to samples and columns to probabilities `[p_left, p_rope, p_right]` """ if x.ndim == 2: zm = x[:, 1] - x[:, 0] else: zm = x nm=len(zm) if prior_place==ROPE: z0=[0] if prior_place==LEFT: z0=[-float('inf')] if prior_place==RIGHT: z0=[float('inf')] z=np.concatenate((zm,z0)) n=len(z) z=np.transpose(np.asmatrix(z)) X=np.matlib.repmat(z,1,n) Y=np.matlib.repmat(-np.transpose(z)+2*rope,n,1) Aright = heaviside(X-Y) X=np.matlib.repmat(-z,1,n) Y=np.matlib.repmat(np.transpose(z)+2*rope,n,1) Aleft = heaviside(X-Y) alpha=np.concatenate((np.ones(nm),[prior_strength]),axis=0) samples=np.zeros((nsamples,3), dtype=float) for i in range(0,nsamples): data = np.random.dirichlet(alpha, 1) samples[i,2]=numpy.inner(np.dot(data,Aright),data) samples[i,0]=numpy.inner(np.dot(data,Aleft),data) samples[i,1]=1-samples[i,0]-samples[i,2] return samples def signrank(x, rope, prior_strength=0.6, prior_place=ROPE, nsamples=50000, verbose=False, names=('C1', 'C2')): """ Args: x (array): a vector of differences or a 2d array with pairs of scores. rope (float): the width of the rope prior_strength (float): prior strength (default: 0.6) prior_place (LEFT, ROPE or RIGHT): the region to which the prior is assigned (default: ROPE) nsamples (int): the number of Monte Carlo samples verbose (bool): report the computed probabilities names (pair of str): the names of the two classifiers Returns: p_left, p_rope, p_right """ samples = signrank_MC(x, rope, prior_strength, prior_place, nsamples) winners = np.argmax(samples, axis=1) pl, pe, pr = np.bincount(winners, minlength=3) / len(winners) if verbose: print('P({c1} > {c2}) = {pl}, P(rope) = {pe}, P({c2} > {c1}) = {pr}'. format(c1=names[0], c2=names[1], pl=pl, pe=pe, pr=pr)) return pl, pe, pr def hierarchical(diff, rope, rho, upperAlpha=2, lowerAlpha =1, lowerBeta = 0.01, upperBeta = 0.1,std_upper_bound=1000, verbose=False, names=('C1', 'C2') ): # upperAlpha, lowerAlpha, upperBeta, lowerBeta, are the upper and lower bound for alpha and beta, which are the parameters of #the Gamma distribution used as a prior for the degress of freedom. #std_upper_bound is a constant which multiplies the sample standard deviation, to set the upper limit of the prior on the #standard deviation. Posterior inferences are insensitive to this value as this is large enough, such as 100 or 1000. samples=hierarchical_MC(diff, rope, rho, upperAlpha, lowerAlpha, lowerBeta, upperBeta, std_upper_bound,names ) winners = np.argmax(samples, axis=1) pl, pe, pr = np.bincount(winners, minlength=3) / len(winners) if verbose: print('P({c1} > {c2}) = {pl}, P(rope) = {pe}, P({c2} > {c1}) = {pr}'. format(c1=names[0], c2=names[1], pl=pl, pe=pe, pr=pr)) return pl, pe, pr def hierarchical_MC(diff, rope, rho, upperAlpha=2, lowerAlpha =1, lowerBeta = 0.01, upperBeta = 0.1, std_upper_bound=1000, names=('C1', 'C2') ): # upperAlpha, lowerAlpha, upperBeta, lowerBeta, are the upper and lower bound for alpha and beta, which are the parameters of #the Gamma distribution used as a prior for the degress of freedom. #std_upper_bound is a constant which multiplies the sample standard deviation, to set the upper limit of the prior on the #standard deviation. Posterior inferences are insensitive to this value as this is large enough, such as 100 or 1000. import scipy.stats as stats import pystan #data rescaling, to have homogenous scale among all dsets stdX = np.mean(np.std(diff,1)) #we scale all the data by the mean of the standard deviation of data sets x = diff/stdX rope=rope/stdX #to avoid numerical problems with zero variance for i in range(0,len(x)): if np.std(x[i,:])==0: x[i,:]=x[i,:]+np.random.normal(0,np.min(1/1000000000,np.abs(np.mean(x[i,:])/100000000))) #This is the Hierarchical model written in Stan hierarchical_code = """ /*Hierarchical Bayesian model for the analysis of competing cross-validated classifiers on multiple data sets. */ data { real deltaLow; real deltaHi; //bounds of the sigma of the higher-level distribution real std0Low; real std0Hi; //bounds on the domain of the sigma of each data set real stdLow; real stdHi; //number of results for each data set. Typically 100 (10 runs of 10-folds cv) int Nsamples; //number of data sets. int q; //difference of accuracy between the two classifier, on each fold of each data set. matrix[q,Nsamples] x; //correlation (1/(number of folds)) real rho; real upperAlpha; real lowerAlpha; real upperBeta; real lowerBeta; } transformed data { //vector of 1s appearing in the likelihood vector[Nsamples] H; //vector of 0s: the mean of the mvn noise vector[Nsamples] zeroMeanVec; /* M is the correlation matrix of the mvn noise. invM is its inverse, detM its determinant */ matrix[Nsamples,Nsamples] invM; real detM; //The determinant of M is analytically known detM <- (1+(Nsamples-1)*rho)*(1-rho)^(Nsamples-1); //build H and invM. They do not depend on the data. for (j in 1:Nsamples){ zeroMeanVec[j]<-0; H[j]<-1; for (i in 1:Nsamples){ if (j==i) invM[j,i]<- (1 + (Nsamples-2)*rho)*pow((1-rho),Nsamples-2); else invM[j,i]<- -rho * pow((1-rho),Nsamples-2); } } /*at this point invM contains the adjugate of M. we divide it by det(M) to obtain the inverse of M.*/ invM <-invM/detM; } parameters { //mean of the hyperprior from which we sample the delta_i real delta0; //std of the hyperprior from which we sample the delta_i real std0; //delta_i of each data set: vector of lenght q. vector[q] delta; //sigma of each data set: : vector of lenght q. vector[q] sigma; /* the domain of (nu - 1) starts from 0 and can be given a gamma prior*/ real nuMinusOne; //parameters of the Gamma prior on nuMinusOne real gammaAlpha; real gammaBeta; } transformed parameters { //degrees of freedom real nu ; /*difference between the data (x matrix) and the vector of the q means.*/ matrix[q,Nsamples] diff; vector[q] diagQuad; /*vector of length q: 1 over the variance of each data set*/ vector[q] oneOverSigma2; vector[q] logDetSigma; vector[q] logLik; //degrees of freedom nu <- nuMinusOne + 1 ; //1 over the variance of each data set oneOverSigma2 <- rep_vector(1, q) ./ sigma; oneOverSigma2 <- oneOverSigma2 ./ sigma; /*the data (x) minus a matrix done as follows: the delta vector (of lenght q) pasted side by side Nsamples times*/ diff <- x - rep_matrix(delta,Nsamples); //efficient matrix computation of the likelihood. diagQuad <- diagonal (quad_form (invM,diff')); logDetSigma <- 2*Nsamples*log(sigma) + log(detM) ; logLik <- -0.5 * logDetSigma - 0.5*Nsamples*log(6.283); logLik <- logLik - 0.5 * oneOverSigma2 .* diagQuad; } model { /*mu0 and std0 are not explicitly sampled here. Stan automatically samples them: mu0 as uniform and std0 as uniform over its domain (std0Low,std0Hi).*/ //sampling the degrees of freedom nuMinusOne ~ gamma ( gammaAlpha, gammaBeta); //vectorial sampling of the delta_i of each data set delta ~ student_t(nu, delta0, std0); //logLik is computed in the previous block increment_log_prob(sum(logLik)); } """ datatable=x std_within=np.mean(np.std(datatable,1)) Nsamples = len(datatable[0]) q= len(datatable) if q>1: std_among=np.std(np.mean(datatable,1)) else: std_among=np.mean(np.std(datatable,1)) #Hierarchical data in Stan hierachical_dat = {'x': datatable, 'deltaLow' : -np.max(np.abs(datatable)), 'deltaHi' : np.max(np.abs(datatable)), 'stdLow' : 0, 'stdHi' : std_within*std_upper_bound, 'std0Low' : 0, 'std0Hi' : std_among*std_upper_bound, 'Nsamples' : Nsamples, 'q' : q, 'rho' : rho, 'upperAlpha' : upperAlpha, 'lowerAlpha' : lowerAlpha, 'upperBeta' : upperBeta, 'lowerBeta' : lowerBeta} #Call to Stan code fit = pystan.stan(model_code=hierarchical_code, data=hierachical_dat, iter=1000, chains=4) la = fit.extract(permuted=True) # return a dictionary of arrays mu = la['delta0'] stdh = la['std0'] nu = la['nu'] samples=np.zeros((len(mu),3), dtype=float) for i in range(0,len(mu)): samples[i,2]=1-stats.t.cdf(rope, nu[i], mu[i], stdh[i]) samples[i,0]=stats.t.cdf(-rope, nu[i], mu[i], stdh[i]) samples[i,1]=1-samples[i,0]-samples[i,2] return samples def plot_posterior(samples, names=('C1', 'C2')): """ Args: x (array): a vector of differences or a 2d array with pairs of scores. names (pair of str): the names of the two classifiers Returns: matplotlib.pyplot.figure """ return plot_simplex(samples, names) def plot_simplex(points, names=('C1', 'C2')): import matplotlib.pyplot as plt from matplotlib.lines import Line2D from matplotlib.pylab import rcParams def _project(points): from math import sqrt, sin, cos, pi p1, p2, p3 = points.T / sqrt(3) x = (p2 - p1) * cos(pi / 6) + 0.5 y = p3 - (p1 + p2) * sin(pi / 6) + 1 / (2 * sqrt(3)) return np.vstack((x, y)).T vert0 = _project(np.array( [[0.3333, 0.3333, 0.3333], [0.5, 0.5, 0], [0.5, 0, 0.5], [0, 0.5, 0.5]])) fig = plt.figure() fig.set_size_inches(8, 7) nl, ne, nr = np.max(points, axis=0) for i, n in enumerate((nl, ne, nr)): if n < 0.001: print("p{} is too small, switching to 2d plot".format(names[::-1] + ["rope"])) coords = sorted(set(range(3)) - i) return plot2d(points[:, coords], labels[coords]) # triangle fig.gca().add_line( Line2D([0, 0.5, 1.0, 0], [0, np.sqrt(3) / 2, 0, 0], color='orange')) # decision lines for i in (1, 2, 3): fig.gca().add_line( Line2D([vert0[0, 0], vert0[i, 0]], [vert0[0, 1], vert0[i, 1]], color='orange')) # vertex labels rcParams.update({'font.size': 16}) fig.gca().text(-0.08, -0.08, 'p({})'.format(names[0]), color='orange') fig.gca().text(0.44, np.sqrt(3) / 2 + 0.05, 'p(rope)', color='orange') fig.gca().text(1.00, -0.08, 'p({})'.format(names[1]), color='orange') # project and draw points tripts = _project(points[:, [0, 2, 1]]) plt.hexbin(tripts[:, 0], tripts[:, 1], mincnt=1, cmap=plt.cm.Blues_r) # Leave some padding around the triangle for vertex labels fig.gca().set_xlim(-0.2, 1.2) fig.gca().set_ylim(-0.2, 1.2) fig.gca().axis('off') return fig