Title: | Statistical Ranking Color Scheme for Multiple Pairwise Comparisons |
---|---|
Description: | Implementation of the SRCS method for a color-based visualization of the results of multiple pairwise tests on a large number of problem configurations, proposed in: I.G. del Amo, D.A. Pelta. SRCS: a technique for comparing multiple algorithms under several factors in dynamic optimization problems. In: E. Alba, A. Nakib, P. Siarry (Eds.), Metaheuristics for Dynamic Optimization. Series: Studies in Computational Intelligence 433, Springer, Berlin/Heidelberg, 2012. |
Authors: | Pablo J. Villacorta <[email protected]> |
Maintainer: | Pablo J. Villacorta <[email protected]> |
License: | LGPL (>= 3) |
Version: | 1.1 |
Built: | 2024-10-31 20:27:50 UTC |
Source: | CRAN |
Dataset with the test accuracy of 6 supervised classification algorithms on eight noisy datasets. The way noise is introduced in originally clear datasets can be adjusted according to some parameters such as the noise type (attribute noise versus class noise) and the noise ratio.
data(ML1)
data(ML1)
A data frame with 52800 observations on the following 6 variables.
Algorithm
A factor with 6 levels: 1-NN, 3-NN, 5-NN, C4.5, RIPPER, SVM
that correspond to 6 different supervised classification algorithms.
Dataset
A factor with 8 levels: autos, balanced, cleveland, ecoli, ionosphere, pima,
vehicle
corresponding to the
names of eight datasets in which noise has been introduced artificially.
Noise type
A factor with 4 levels: ATT_GAUS, ATT_RAND, CLA_PAIR, CLA_RAND
that correspond to
the type of noise introduced: ATT_* to denote noise added to (a percentage of) the attributes of the instance (either in a gaussian or
uniformly random way), and CLA_* to denote noise which modifies the class of (a percentage of) the instances of the dataset
(either by any other class at random, as in CLA_RAND, or by replacing the label of only a percentage of the examples of the majority class by
the label of the second-majority class as in CLA_PAIR).
Noise ratio
A real number with the ratio of attributes affected by noise (for ATT_GAUS
and ATT_RAND
), or
the ratio of examples within the global dataset affected by a class error (for CLA_PAIR
and CLA_RAND
).
Fold
An integer number (between 1 and 25) associated with the repetition of the experiment. Recall that test results were obtained by repeating five independent times a complete 5-fold Cross Validation process.
Performance
Real number between 0 and 1 with the accuracy (in percentage) of the classifier over the test examples.
J.A. Saez, M.Galar, J.Luengo, F.Herrera, Tackling the Problem of Classification with Noisy Data using Multiple Classifier Systems: Analysis of the Performance and Robustness. Information Sciences, 247 (2013) 1-20.
Christopher M. Bishop. Pattern Recognition and Machine Learning. Springer (2006).
data(ML1) str(ML1) head(ML1)
data(ML1) str(ML1) head(ML1)
Dataset with the performance of several dynamic optimization algorithms in the Moving Peaks Benchmark problem (see the source section). The MPB function can be configured according to some parameters such as the dimension, the change frequency and the severity of changes. The performance measure employed is the average offline error.
data(MPB)
data(MPB)
A data frame with 220000 observations on the following 5 variables.
Algorithm
A factor with levels reactive-cs
independent-cs
mqso-both
mqso-rand
mqso-change
mqso
agents
soriga
that correspond to 8 different algorithms for dynamic optimization applied to the Moving Peaks Benchmark function.
Dim
A numeric vector with the dimension (number of input variables) of the MPB function.
CF
A numeric vector with the change frequency along the time, i.e. the number of evaluations of the fitness function after which a change of the location of the function maxima happens.
Severity
A numeric vector with the severity of a change when it occurs.
OffError
A numeric vector with the performance measure, in this case the offline error computed as the average of the offline errors just before every change.
I.G. del Amo, D.A. Pelta. SRCS: a technique for comparing multiple algorithms under several factors in dynamic optimization problems, in: E. Alba, A. Nakib, P. Siarry (Eds.), Metaheuristics for Dynamic Optimization. Series: Studies in Computational Intelligence 433, Springer, Berlin/Heidelberg, 2012.
data(MPB) str(MPB) head(MPB)
data(MPB) str(MPB) head(MPB)
Dataset with the performance of several dynamic optimization algorithms in the Moving Peaks Benchmark problem (see the source section) at five time moments, just before a change.
The MPB function can be configured according to some parameters such as the dimension, the change frequency and the severity of changes.
The performance measure employed is the average offline error, averaged from the beginning up to each time moment.
This dataset serves for illustrating how to compose a video sequence using function animatedplot
.
data(MPBall)
data(MPBall)
A data frame with 82500 observations on the following variables.
Algorithm
A factor with levels reactive-cs
independent-cs
mqso-both
mqso-rand
mqso-change
mqso
agents
soriga
that correspond to 8 different algorithms for dynamic optimization applied to the Moving Peaks Benchmark function.
Dim
A numeric vector with the dimension (number of input variables) of the MPB function.
CF
A numeric vector with the change frequency along the time, i.e. the number of evaluations of the fitness function after which a change of the location of the function maxima happens.
Severity
A numeric vector with the severity of a change when it occurs.
A numeric vector with the performance measure, in this case the offline error computed as the average (over the previous changes) of the offline errors just before every change. Each algorithm was allowed to run for 100 slices, but we have selected only 5 moments of that process, i.e. before the first change, the 25th change, the 49th, 73th and 97th change, in order to keep the resulting dataset reasonably small.
I.G. del Amo, D.A. Pelta. SRCS: a technique for comparing multiple algorithms under several factors in dynamic optimization problems, in: E. Alba, A. Nakib, P. Siarry (Eds.), Metaheuristics for Dynamic Optimization. Series: Studies in Computational Intelligence 433, Springer, Berlin/Heidelberg, 2012.
data(MPBall) str(MPBall) head(MPBall)
data(MPBall) str(MPBall) head(MPBall)
plot.SRCS
: Function to display a grid of heatmaps representing the statistical ranking of one level of the target factor (usually, the algorithm)
vs the rest of levels of the target factor, over several problem configurations characterized by (at most) 3 parameters in addition to the target factor.
animatedplot
: Function to generate an animated video consisting of a temporal sequence of grid plots like those generated by plot.SRCS
.
The function requires software ImageMagick has been installed.
singleplot
: Function to display either a single heatmap representing the statistical ranking of one level of the target factor (usually, the algorithm)
vs the rest of levels of the target factor, over one single problem configurations defined by a combination of values for the problem configuration parameters.
## S3 method for class 'SRCS' plot(x, yOuter, xOuter, yInner, xInner, zInner = "rank", out.Y.par = list(), out.X.par = list(), inner.X.par = list(), inner.Y.par = list(), colorbar.par = list(), color.function = heat.colors, heatmaps.per.row = NULL, heatmaps.titles = NULL, show.colorbar = TRUE, annotation.lab = NULL, heat.cell.par = list(), heat.axes.par = list(), colorbar.cell.par = list(), colorbar.axes.par = list(), annotation.text.par = list(), ...) animatedplot(x, filename, path.to.converter, yOuter, xOuter, yInner, xInner, zInner, width = 800, height = 800, res = 100, pointsize = 16, delay = 30, type = c("png", "jpeg", "bmp", "tiff"), quality = 75, compression = c("none", "rle", "lzw", "jpeg", "zip"), annotations = NULL, ...) singleplot(x, yInner, xInner, zInner = "rank", color.function = heat.colors, labels.par = list(), colorbar.par = list(), heat.axes.par = list(), colorbar.axes.par = list(), haxis = TRUE, vaxis = TRUE, title = "", show.colorbar = TRUE, ...)
## S3 method for class 'SRCS' plot(x, yOuter, xOuter, yInner, xInner, zInner = "rank", out.Y.par = list(), out.X.par = list(), inner.X.par = list(), inner.Y.par = list(), colorbar.par = list(), color.function = heat.colors, heatmaps.per.row = NULL, heatmaps.titles = NULL, show.colorbar = TRUE, annotation.lab = NULL, heat.cell.par = list(), heat.axes.par = list(), colorbar.cell.par = list(), colorbar.axes.par = list(), annotation.text.par = list(), ...) animatedplot(x, filename, path.to.converter, yOuter, xOuter, yInner, xInner, zInner, width = 800, height = 800, res = 100, pointsize = 16, delay = 30, type = c("png", "jpeg", "bmp", "tiff"), quality = 75, compression = c("none", "rle", "lzw", "jpeg", "zip"), annotations = NULL, ...) singleplot(x, yInner, xInner, zInner = "rank", color.function = heat.colors, labels.par = list(), colorbar.par = list(), heat.axes.par = list(), colorbar.axes.par = list(), haxis = TRUE, vaxis = TRUE, title = "", show.colorbar = TRUE, ...)
x |
An SRCS object containing columns for the names of the problem parameters (including the algorithm) and the rank obtained
by that algorithm when compared with the rest over the same problem configuration. Typically this is the object returned by a call to |
yOuter , xOuter
|
Names of the variables in |
yInner , xInner
|
Names of the variables in |
zInner |
Name of the variable in |
out.Y.par , out.X.par
|
A tagged list with parameters to configure how the labels of the outer Y and X variables and their levels are displayed. Valid parameters and their default values are as follows:
|
inner.X.par , inner.Y.par
|
A tagged list with parameters to configure how the labels of the innter Y and X variables and their levels are displayed. Valid parameters and their default values are the following:
|
colorbar.par |
Tagged list to configure the aspect of the colorbar legend displayed on the right part of the figure:
|
color.function |
A custom function that receives one argument (number of colors to be generated, (maxrank - minrank + 1) in our case) and returns a vector of that length
with the hexadecimal codes of the colors to be used in the heatmaps, see |
heatmaps.per.row |
Maximum number of heatmaps displayed in a row of the grid. Useful when variable |
heatmaps.titles |
A vector of the same length as the total number of heatmaps, i.e. unique(x[[yOuter]]) * unique(x[[xOuter]]), containing the titles to be displayed on top of each heatmap. The elements of the vector will be associated to the heatmaps of the grid from left to right and from top to bottom. |
show.colorbar |
Logical: whether a colorbar legend will be shown on the right of the figure (one for each row of heatmaps) or not. Defaults to TRUE |
annotation.lab |
String with the annotation title that will be displayer on the top left corner. Defaults to NULL, indicating no annotation will be shown. |
heat.cell.par |
Tagged list that will be passed to |
heat.axes.par |
Tagged list that will be passed to |
colorbar.cell.par |
Tagged list that will be passed to |
colorbar.axes.par |
Tagged list that will be passed to |
annotation.text.par |
Tagged list that will be passed to |
... |
(In |
filename |
Name of the output video file, including the extension. It is strongly recommended that the name ends in ".gif" to preserve most of image quality. |
path.to.converter |
String with the full path to the converter program delivered with ImageMagick, e.g. "C:/Program Files/ImageMagick-<version>/convert.exe" |
width , height
|
Width and height, in pixels, of the result video. Both default to 800 |
res |
Nominal resolution (in ppi) of the output video. Used to set text size and line widths. Defaults to 100. See |
pointsize |
Point size argument to be passed to the functions that print to image. Defaults to 16. |
delay |
Time delay (in 1/100th of a second) spent in each of the images that compose the video. Defaults to 30, i.e. 0.3 seconds. |
type |
The type of image file generated for each frame. The image files will be then joined together into a video. Should be one of |
quality |
The quality of the images, in a scale from 1 to 100. The less the quality, the more the compression and the smaller the file size. |
compression |
(For TIFF format only) Used to indicate the kind of compression. Must be one of |
annotations |
Vector of strings with the annotation label of every image of the video. Should have the same length as |
labels.par |
Tagged list to configure how the labels will be displayed:
|
haxis , vaxis
|
Whether the X and the Y axes should be displayed or not. Defaults to TRUE for both. |
title |
Title of the plot. |
plot.SRCS
plots a grid with the results over all problem configurations, and should be applied to the object returned by SRCSranks
with
only one performance
column.
singleplot
is used for plotting only one heatmap for a subset of problem configurations
in which the outer X and Y parameters take a fixed value, and should be applied to the object returned by SRCScomparison
.
animatedplot
creates a video from a sequence of plots, intended to show the temporal evolution of the ranking over time.
It should be applied only to the object returned by SRCSranks
when the performance
argument passed to it was a vector of strings,
each of them being the performance column of the data at a given time instant.
The function uses the base graphics system.
text, par, axis, SRCSranks, animatedplot, singleplot
,
brewer.pal, RGB
# Example from a Machine Learning problem with noisy data ranks = SRCSranks(ML1, params = c("Dataset", "Noise type", "Noise ratio"), target = "Algorithm", performance="Performance", maximize = TRUE, ncores = 2, paired = TRUE, pairing.col = "Fold"); singleplot(ranks, yInner = "Noise type", xInner = "Noise ratio", Algorithm = "C4.5", Dataset = "glass") plot(x = ranks, yOuter = "Dataset", xOuter = "Algorithm", yInner = "Noise type", xInner = "Noise ratio", out.X.par = list(levels.lab.textpar = list(col = "white"), levels.bg = "black", levels.border = "white"), out.Y.par = list(levels.bg = "gray"), colorbar.axes.par = list(cex.axis = 0.8), show.colorbar = TRUE) SRCScomparison(ranks, "Algorithm", Dataset = "automobile", `Noise type` = "ATT_GAUS", `Noise ratio`= 10, pvalues = FALSE) # --------------------------------------------------- ## Not run: mat = matrix(NA, nrow = nrow(MPBall), ncol = ncol(MPBall)) # First, take the average of the previous performance columns up to each change point for(j in 6:ncol(MPBall)){ mat[,j] = rowSums(MPBall[,5:j])/(j-5+1) } MPBall[,6:ncol(MPBall)] = mat[,6:ncol(MPBall)] ranksall = SRCSranks(MPBall, params = c("Dim", "CF", "Severity"), target="Algorithm", test = "tukeyHSD", performance=paste("OffError", seq(from=1, to = 100, by = 24), sep = "_"), maximize = FALSE, ncores = 2) # Adjust argument path.to.converter to point to ImageMagick convert utility animatedplot(x = ranksall, filename = "MPBconv_reduced.gif", path.to.converter = "C:/Program Files/ImageMagick-6.8.8-Q8/convert.exe", yOuter = "Algorithm", xOuter = "Dim", yInner = "CF", xInner = "Severity", zInner = paste0("rank",1:5), delay = 30, annotations = paste0("At change ",seq.int(from = 1, to = 100, by = 24)), inner.Y.par = list(levels.at = c("40", "200", "400", "600", "800", "1000"), lab = "Change\nfrequency", levels.loc = "left"), heat.cell.par = list(pty = "s"), inner.X.par = list(levels.at = c("2", "8", "14")), out.Y.par = list(levels.lab.textpar = list(cex = 1, col = "white"), levels.bg = "black", levels.border = "white"), out.X.par = list(lab = "Dimension", levels.bg = "gray"), colorbar.par = list(levels.at = c("-2", "0", "2")), colorbar.axes.par = list(cex.axis = 0.8), show.colorbar = TRUE, height = 500 ) # The full dataset (20 MB) can be downloaded from # http://decsai.ugr.es/~pjvi/SRCSfiles/MPBall.RData # (the average must still be computed before plotting, just as in the example above) # Check the script in http://decsai.ugr.es/~pjvi/SRCSfiles/DOPvideoScript.R ## End(Not run)
# Example from a Machine Learning problem with noisy data ranks = SRCSranks(ML1, params = c("Dataset", "Noise type", "Noise ratio"), target = "Algorithm", performance="Performance", maximize = TRUE, ncores = 2, paired = TRUE, pairing.col = "Fold"); singleplot(ranks, yInner = "Noise type", xInner = "Noise ratio", Algorithm = "C4.5", Dataset = "glass") plot(x = ranks, yOuter = "Dataset", xOuter = "Algorithm", yInner = "Noise type", xInner = "Noise ratio", out.X.par = list(levels.lab.textpar = list(col = "white"), levels.bg = "black", levels.border = "white"), out.Y.par = list(levels.bg = "gray"), colorbar.axes.par = list(cex.axis = 0.8), show.colorbar = TRUE) SRCScomparison(ranks, "Algorithm", Dataset = "automobile", `Noise type` = "ATT_GAUS", `Noise ratio`= 10, pvalues = FALSE) # --------------------------------------------------- ## Not run: mat = matrix(NA, nrow = nrow(MPBall), ncol = ncol(MPBall)) # First, take the average of the previous performance columns up to each change point for(j in 6:ncol(MPBall)){ mat[,j] = rowSums(MPBall[,5:j])/(j-5+1) } MPBall[,6:ncol(MPBall)] = mat[,6:ncol(MPBall)] ranksall = SRCSranks(MPBall, params = c("Dim", "CF", "Severity"), target="Algorithm", test = "tukeyHSD", performance=paste("OffError", seq(from=1, to = 100, by = 24), sep = "_"), maximize = FALSE, ncores = 2) # Adjust argument path.to.converter to point to ImageMagick convert utility animatedplot(x = ranksall, filename = "MPBconv_reduced.gif", path.to.converter = "C:/Program Files/ImageMagick-6.8.8-Q8/convert.exe", yOuter = "Algorithm", xOuter = "Dim", yInner = "CF", xInner = "Severity", zInner = paste0("rank",1:5), delay = 30, annotations = paste0("At change ",seq.int(from = 1, to = 100, by = 24)), inner.Y.par = list(levels.at = c("40", "200", "400", "600", "800", "1000"), lab = "Change\nfrequency", levels.loc = "left"), heat.cell.par = list(pty = "s"), inner.X.par = list(levels.at = c("2", "8", "14")), out.Y.par = list(levels.lab.textpar = list(cex = 1, col = "white"), levels.bg = "black", levels.border = "white"), out.X.par = list(lab = "Dimension", levels.bg = "gray"), colorbar.par = list(levels.at = c("-2", "0", "2")), colorbar.axes.par = list(cex.axis = 0.8), show.colorbar = TRUE, height = 500 ) # The full dataset (20 MB) can be downloaded from # http://decsai.ugr.es/~pjvi/SRCSfiles/MPBall.RData # (the average must still be computed before plotting, just as in the example above) # Check the script in http://decsai.ugr.es/~pjvi/SRCSfiles/DOPvideoScript.R ## End(Not run)
An R implementation of SRCS: Statistical Ranking Color Scheme for visualizing the results of multiple pairwise comparisons in many problem configurations at the same time, each defined by at most 3 additional parameters. For each problem configuration, this technique ranks every level of the target value according to the performance in relation to how other levels perform on the same problem configuration. Ranks are assigned according to statistical performance comparisons. Then, a color is associated to each rank so it can be easily visualized and interpreted.
I.G. del Amo, D.A.Pelta. SRCS: a technique for comparing multiple algorithms under several factors in dynamic optimization problems, in: E. Alba, A. Nakib, P. Siarry (Eds.), Metaheuristics for Dynamic Optimization. Series: Studies in Computational Intelligence 433, Springer, Berlin/Heidelberg, 2012.
Compares the performance of two algorithms for a single problem configuration specified by the user.
SRCScomparison(rankdata, target, alpha = 0.05, pvalues = FALSE, ...)
SRCScomparison(rankdata, target, alpha = 0.05, pvalues = FALSE, ...)
rankdata |
The ranks data frame obtained by a previous call to |
target |
Name of the target column in |
alpha |
Significance threshold to consider two set of measurements coming from two algorithms as statistically significant |
pvalues |
Boolean. TRUE indicates that the pairwise comparison table should contain p-values. FALSE means only ">","<" or "=" (the latter for non-significant difference) will be displayed in the table. Defaults to FALSE. |
... |
The rest of the columns in |
A square matrix of the same dimension as algorithms found in the data. An entry i,j contains either the p-value of the Wilcoxon test between
algorithms i and j (if pvalues
was set to TRUE), or the qualitative result (">", "<" or "=") of the statistical comparison (if pvalues
was set to FALSE).
SRCSranks, plot.SRCS
for a full working example of SRCScomparison.
Computes the ranks of all the algorithms from their (repeated) results measurements after grouping them by several factors combined simultaneosly.
SRCSranks(data, params, target, performance, pairing.col = NULL, test = c("wilcoxon", "t", "tukeyHSD", "custom"), fun = NULL, correction = p.adjust.methods, alpha = 0.05, maximize = TRUE, ncores = 1, paired = FALSE, ...)
SRCSranks(data, params, target, performance, pairing.col = NULL, test = c("wilcoxon", "t", "tukeyHSD", "custom"), fun = NULL, correction = p.adjust.methods, alpha = 0.05, maximize = TRUE, ncores = 1, paired = FALSE, ...)
data |
A dataframe object containing (at least) two columns for the target factor and the performance measure Additional columns are aimed at grouping the problem configuration by (at most) 3 different factors. |
params |
A vector with the column names in |
target |
Name of the target column of |
performance |
Name of the column of |
pairing.col |
Name of the column which links together the paired samples, in case we have set |
test |
The statistical test to be performed to compare the performance of every level of the target variable at each problem configuration. |
fun |
Function performing a custom statistical test, if |
correction |
The p-value adjust method. Must be one of "holm", "hochberg", "hommel", "bonferroni", "BH", "BY", "fdr", "none" (defaults to "holm").
This parameter will be ignored if |
alpha |
Significance threshold for pairwise comparisons. Defaults to 0.05. |
maximize |
Boolean indicating whether the higher the performance measure, the better (default), or vice-versa. |
ncores |
Number of physical CPUs available for computations. If |
paired |
Boolean indicating whether samples in the same problem configuration, which only differ in the target value, and in the same relative position (row) within their respective target values are paired or not. Defaults to FALSE. This should be set to TRUE, for instance, in Machine Learning problems in which, for a fixed problem configuration, the target variable (usually the algorithms being compared) is associated to a number of samples (results) coming from the Cross Validation process. If a K-fold CV is being done, then we would have, for a given problem configuration, K rows for each of the algorithms being compared, all of them identical in all the columns except for the performance column. In that case, the performance of the i-th row (1 <= i <= K) of all of those batches (groups of K rows) for that fixed problem configuration would be related, hence every pairwise comparison should take into account paired samples. |
... |
Further arguments to be passed to the function |
If length(performance)
equals 1, an object of classes c("SRCS", "data.frame")
with the following columns:
- A set of columns with the same names as the params
and target
arguments.
- Two columns called "mean" and "sd" containing the mean of the repeated peformance measurements for each problem configuration and the standard deviation.
- One column named "rank" with the actual rank of each level of the target
variable within that problem configuration. The lower the rank, the better the algorithm.
- |target| additional columns containing the p-values resulting of the comparison between the algorithm and the rest for the same problem configuration,
where |target| is the number of levels of the target variable.
If length(performance)
> 1 (let P = length(performance)
for the explanation that follows), an object of classes c("SRCS","data.frame")
with the following columns:
- A set of columns with the same names as the params
and target
arguments.
- One column per element of the performance
vector, named "rank1", ..., "rankP", containing, for each performance measure,
the rank of each level of the target
variable within that problem configuration for that performance measure.
The higher the rank, the better the algorithm.
Although it has no effect on the results of SRCSranks
, the user should preferably have set the order
of the factor levels explicitly by calling function levels
before calling this function, specially if he intends to subsequently apply plot
to the results,
because the level order does affect the way graphics are arranged in the plot.
plot.SRCS
for a full working example of SRCSranks
and plotting facilities. Also
pairwise.wilcox.test
, t.test
, pairwise.t.test
, TukeyHSD
, p.adjust.methods