Weighting

Many aggregation methods involve some kind of weighting, i.e. coefficients that define the relative weight of the indicators/aggregates in the aggregation. In order to aggregate, weights need to first be specified, but to effectively adjust weights it is necessary to aggregate.

This chicken and egg conundrum is best solved by aggregating initially with a trial set of weights, perhaps equal weights, then seeing the effects of the weighting, and making any weight adjustments necessary.

Approaches

COINr aggregation functions

Let’s now explore some of the options of the Aggregate() function. Like other coin-building functions in COINr, Aggregate() comes with a number of inbuilt options, but can also accept any function that is passed to it, as long as it satisfies some requirements. COINr’s inbuilt aggregation functions begin with a_, and are:

• a_amean(): the weighted arithmetic mean
• a_gmean(): the weighted geometric mean
• a_hmean(): the weighted harmonic mean
• a_copeland(): the Copeland method (note: requires by_df = TRUE)

For details of these methods, see Approaches above and the function documentation of each of the functions listed.

By default, the arithmetic mean is called but we can easily change this to the geometric mean, for example. However here we run into a problem: the geometric mean will fail if any values to aggregate are less than or equal to zero. So to use the geometric mean we have to re-do the normalisation step to avoid this. Luckily this is straightforward in COINr:

coin <- Normalise(coin, dset = "Treated",
                   global_specs = list(f_n = "n_minmax",
                                        f_n_para = list(l_u = c(1,100))))
#> Written data set to .$Data$Normalised
#> (overwritten existing data set)

Now, since the indicators are scaled between 1 and 100 (instead of 0 and 100 as previously), they can be aggregated with the geometric mean.

coin <- Aggregate(coin, dset = "Normalised",
                   f_ag = "a_gmean")
#> Written data set to .$Data$Aggregated
#> (overwritten existing data set)

External functions

All of the four aggregation functions mentioned above have the same format (try e.g. ?a_gmean), and are built into the COINr package. But what if we want to use another type of aggregation function? The process is exactly the same.

NOTE: the compind package has been disabled here from running the commands in this vignette because of changes to a dependent package which are causing problems with the R CMD check. The commands should still work if you run them, but the results will not be shown here.

In this section we use some functions from other packages: the matrixStats package and the Compind package. These are not imported by COINr, so the code here will only work if you have these installed. If this vignette was built on your computer, we have to check whether these packages are installed:

# ms_installed <- requireNamespace("matrixStats", quietly = TRUE)
# ms_installed

# ci_installed <- requireNamespace("Compind", quietly = TRUE)
# ci_installed

If either of these have returned FALSE, in the following code chunks you will see some blanks. See the online version of this vignette to see the results, or install the above packages and rebuild the vignettes.

Now for an example, we can use the weightedMedian() function from the matrixStats package. This has a number of arguments, but the ones we will use are x and w (with the same meanings as COINr functions), and na.rm which we need to set to TRUE.

# RESTORE above eval=ms_installed
# load matrixStats package
# library(matrixStats)
# 
# # aggregate using weightedMedian()
# coin <- Aggregate(coin, dset = "Normalised",
#                    f_ag = "weightedMedian",
#                    f_ag_para = list(na.rm = TRUE))

The weights w do not need to be specified in f_ag_para because they are automatically passed to f_ag unless specified otherwise.

The general requirements for f_ag functions passed to Aggregate() are that:

1. The input to the function is a numeric vector x, possibly with missing values
2. The function returns a single (scalar) aggregated value
3. If the function accepts a vector of weights, this vector (of the same length of x) is passed as function argument w. If the function doesn’t accept a vector of weights, we can set w = "none" in the arguments to Aggregate(), and it will not try to pass w.
4. Any other arguments to f_ag, apart from x and w, should be included in the named list f_ag_para.

Sometimes this may mean that we have to create a wrapper function to satisfy these requirements. For example, the ‘Compind’ package has a number of sophisticated aggregation approaches. The “benefit of the doubt” uses data envelopment analysis to aggregate indicators, however the function Compind::ci_bod() outputs a list. We can make a wrapper function to use this inside COINr:

# RESTORE ABOVE eval= ci_installed

# NOTE: this chunk disabled - see comments above.

# load Compind
# suppressPackageStartupMessages(library(Compind))
# 
# # wrapper to get output of interest from ci_bod
# # also suppress messages about missing values
# ci_bod2 <- function(x){
#   suppressMessages(Compind::ci_bod(x)$ci_bod_est)
# }
# 
# # aggregate
# coin <- Aggregate(coin, dset = "Normalised",
#                    f_ag = "ci_bod2", by_df = TRUE, w = "none")

The benefit of the doubt approach automatically assigns individual weights to each unit, so we need to specify w = "none" to stop Aggregate() from attempting to pass weights to the function. Importantly, we also need to specify by_df = TRUE which tells Aggregate() to pass a data frame to f_ag rather than a vector.

Data availability limits

Many aggregation functions will return an aggregated value as long as at least one of the values passed to it is non-NA. For example, R’s mean() function:

# data with all NAs except 1 value
x <- c(NA, NA, NA, 1, NA)

mean(x)
#> [1] NA

mean(x, na.rm = TRUE)
#> [1] 1

Depending on how we set na.rm, we either get an answer or NA, and this is the same for many other aggregation functions (e.g. the ones built into COINr). Sometimes we might want a bit more control. For example, if we have five indicators in a group, it might only be reasonable to give an aggregated score if, say, at least three out of five indicators have non-NA values.

The Aggregate() function has the option to specify a data availability limit when aggregating. We simply set dat_thresh to a value between 0 and 1, and for each aggregation group, any unit that has a data availability lower than dat_thresh will get a NA value instead of an aggregated score. This is most easily illustrated on a data frame (see next section for more details on aggregating in data frames):

df1 <- data.frame(
  i1 = c(1, 2, 3),
  i2 = c(3, NA, NA),
  i3 = c(1, NA, 1)
)
df1
#>   i1 i2 i3
#> 1  1  3  1
#> 2  2 NA NA
#> 3  3 NA  1

We will require that at least 2/3 of the indicators should be non-NA to give an aggregated value.

# aggregate with arithmetic mean, equal weight and data avail limit of 2/3
Aggregate(df1, f_ag = "a_amean",
           f_ag_para = list(w = c(1,1,1)),
           dat_thresh = 2/3)
#> [1] 1.666667       NA 2.000000

Here we see that the second row is aggregated to give NA because it only has 1/3 data availability.

By level

We can also use a different aggregation function for each aggregation level by specifying f_ag as a vector of function names rather than a single function.

coin <- Aggregate(coin, dset = "Normalised", f_ag = c("a_amean", "a_gmean", "a_amean"))
#> Written data set to .$Data$Aggregated
#> (overwritten existing data set)

In this example, there are four levels in the index, which means there are three aggregation operations to be performed: from Level 1 to Level 2, from Level 2 to Level 3, and from Level 3 to Level 4. This means that f_ag vector must have n-1 entries, where n is the number of aggregation levels. The functions are run in the order of aggregation.

In the same way, if parameters need to be passed to the functions specified by f_ag, f_ag_para can be specified as a list of length n-1, where each element is a list of parameters.