#############################################################################################
# These functions build the normalized names of the algorithms handled in NetVotes.
#
# 03/2017 Vincent Labatut
#############################################################################################
#############################################################################################
# Unsigned networks partitioning algorithms info
#############################################################################################
COMDET.ALGO.VALUES <- c()
COMDET.ALGO.NAMES <- c()
COMDET.ALGO.EDGEBETW <- "EB"
# this implementation uses the weights and directions, if present
COMDET.ALGO.VALUES <- c(COMDET.ALGO.VALUES, COMDET.ALGO.EDGEBETW)
COMDET.ALGO.NAMES[COMDET.ALGO.EDGEBETW] <- "EdgeBetweenness"
COMDET.ALGO.INFOMAP <- "IM"
# this implementation uses the weights and directions, if present
COMDET.ALGO.VALUES <- c(COMDET.ALGO.VALUES, COMDET.ALGO.INFOMAP)
COMDET.ALGO.NAMES[COMDET.ALGO.INFOMAP] <- "InfoMap"
COMDET.ALGO.LABELPROP <- "LP"
# this implementation uses the weights and directions, if present
COMDET.ALGO.VALUES <- c(COMDET.ALGO.VALUES, COMDET.ALGO.LABELPROP)
COMDET.ALGO.NAMES[COMDET.ALGO.LABELPROP] <- "LabelPropagation"
COMDET.ALGO.LOUVAIN <- "LV"
# this implementation uses the weights, if present, but cannot use directions
COMDET.ALGO.VALUES <- c(COMDET.ALGO.VALUES, COMDET.ALGO.LOUVAIN)
COMDET.ALGO.NAMES[COMDET.ALGO.LOUVAIN] <- "Louvain"
COMDET.ALGO.WALKTRAP <- "WT"
# this implementation uses the weights, if present, and simply ignores directions
COMDET.ALGO.VALUES <- c(COMDET.ALGO.VALUES, COMDET.ALGO.WALKTRAP)
COMDET.ALGO.NAMES[COMDET.ALGO.WALKTRAP] <- "WalkTrap"
comdet.algo.ncg.value <- function(value) # returns the negative complementary value (i.e. short code) associated to the specified (positive) value
{ if(length(value)==0)
res <- c()
else
res <- paste("NCG",value,sep="-")
return(res)
}
for(value in COMDET.ALGO.VALUES) COMDET.ALGO.NAMES[comdet.algo.ncg.value(value)] <- paste("NCG",COMDET.ALGO.NAMES[value])
#TODO maybe we should allow parameters there too? (ie for regular community detection methods)
#############################################################################################
# Signed networks partitioning algorithms info
#############################################################################################
COMDET.ALGO.ILS <- "ILS"
COMDET.ALGO.GRASP <- "GRASP"
#############################################################################################
# Returns the code (short name) for the Iterated Local Search (ILS) partioning method. See
# the algorithm documentation for more details.
#
# rcc: whether to solve the correlation clustering (FALSE) or relaxed CC problem (TRUE).
# l: neighborhood size (during the local search).
# k: number of clusters (max number for RCC)
# alpha: randomness factor.
# gain: 0 for min imbalance,
# 1 for max modularity gain function,
# 2 for max negative modularity gain function,
# 3 for max positive-negative modularity gain function,
# 4 for max pos-neg mod gain function II,
# 5 for max pos-neg mod gain function III
# perturbation: maximal level of perturbation.
#
# returns: the short name corresponding to the ILS method with the specified parameters.
#############################################################################################
get.ils.code <- function(l, k, alpha, rcc, gain, perturbation)
{ result <- COMDET.ALGO.ILS
if(rcc)
result <- paste0(result,"-RCC")
else
result <- paste0(result,"-CC")
result <- paste0(result,"_l",l)
result <- paste0(result,"_k",k)
result <- paste0(result,"_a",alpha)
result <- paste0(result,"_g",gain)
result <- paste0(result,"_p",perturbation)
return(result)
}
#############################################################################################
# Returns the inline command for the Iterated Local Search (ILS) partioning method. See
# the algorithm documentation for more details.
#
# algo.name: short code associated to the algorithm.
# input.folder: relative path to the folder containing targeted graph file.
# out.folder: relative path to the folder in which the produced files will be placed.
# time.limit: maximum duration of the processing.
# iter.nbr: maximum number of iterations of the processing.
#
# returns: the command allowing to invoke the program externally.
#############################################################################################
get.ils.command <- function(algo.name, input.folder, out.folder, time.limit=1800, iter.nbr=500)
{ # init
input.file <- file.path(getwd(), input.folder, paste0(SIGNED.FILE,".G"))
output.folder <- file.path(getwd(), out.folder, algo.name)
command.folder <- file.path(getwd(),LIB.FOLDER,"mestrado","grasp","build")
result <- file.path(command.folder, "graspcc")
result <- paste0("mpirun -n 1 ",result)
# break down the specified code (short name)
tmp <- strsplit(x=algo.name, split="_", fixed=TRUE)[[1]]
params <- c()
for(s in tmp[2:length(tmp)])
{ params <- c(params,substr(s,2,nchar(s)))
names(params)[length(params)] <- substr(s,1,1)
}
# rcc flag
rcc.flag <- strsplit(x=tmp[1], split="-", fixed=TRUE)[[1]][2]
if(rcc.flag=="RCC")
params["rcc"] <- 1
else
params["rcc"] <- 0
# build command
result <- paste0(result, " --alpha ",params["a"])
result <- paste0(result, " --iterations ",iter.nbr)
result <- paste0(result, " --neighborhood_size ",params["l"])
result <- paste0(result, " --rcc ",params["rcc"])
result <- paste0(result, " --k ",params["k"])
result <- paste0(result, " --time-limit ",time.limit)
result <- paste0(result, " --input-file \"",input.file,"\"")
result <- paste0(result, " --output-folder \"",output.folder,"\"")
result <- paste0(result, " --gain-function-type ",params["g"])
result <- paste0(result, " --strategy ","ILS")
result <- paste0(result, " --perturbationLevelMax ",params["p"])
return(result)
}
#############################################################################################
# Returns the code (short name) for the Grasp partioning method. See the algorithm documentation
# for more details.
#
# rcc: whether to solve the correlation clustering (FALSE) or relaxed CC problem (TRUE).
# l: neighborhood size (during the local search).
# k: number of clusters (max number for RCC)
# alpha: randomness factor.
# gain: 0 for min imbalance,
# 1 for max modularity gain function,
# 2 for max negative modularity gain function,
# 3 for max positive-negative modularity gain function,
# 4 for max pos-neg mod gain function II,
# 5 for max pos-neg mod gain function III
# perturbation: maximal level of perturbation.
#
# returns: the short name corresponding to the Grasp method with the specified parameters.
#############################################################################################
get.grasp.code <- function(rcc, l, k, alpha, gain, perturbation)
{ result <- COMDET.ALGO.GRASP
if(rcc)
result <- paste0(result,"-RCC")
else
result <- paste0(result,"-CC")
result <- paste0(result,"_l",l)
result <- paste0(result,"_k",k)
result <- paste0(result,"_a",alpha)
result <- paste0(result,"_g",gain)
result <- paste0(result,"_p",perturbation)
return(result)
}
#############################################################################################
# Returns the inline command for the Greedy Randomized Adaptive Search Procedure (Grasp) partioning
# method. See the algorithm documentation for more details.
#
# algo.name: short code associated to the algorithm.
# input.folder: relative path to the folder containing targeted graph file.
# out.folder: relative path to the folder in which the produced files will be placed.
# time.limit: maximum duration of the processing.
# iter.nbr: maximum number of iterations of the processing.
#
# returns: the command allowing to invoke the program externally.
#############################################################################################
get.grasp.command <- function(algo.name, input.folder, out.folder, time.limit=1800, iter.nbr=500)
{ # init
input.file <- file.path(getwd(), input.folder, paste0(SIGNED.FILE,".G"))
output.folder <- file.path(getwd(), out.folder, algo.name)
command.folder <- file.path(getwd(),LIB.FOLDER,"mestrado","grasp","build")
result <- file.path(command.folder, "graspcc")
result <- paste0("mpirun -n 1 ",result)
# break down the specified code (short name)
tmp <- strsplit(x=algo.name, split="_", fixed=TRUE)[[1]]
params <- c()
for(s in tmp[2:length(tmp)])
{ params <- c(params,substr(s,2,nchar(s)))
names(params)[length(params)] <- substr(s,1,1)
}
# rcc flag
rcc.flag <- strsplit(x=tmp[1], split="-", fixed=TRUE)[[1]][2]
if(rcc.flag=="RCC")
params["rcc"] <- 1
else
params["rcc"] <- 0
# build command
result <- paste0(result, " --alpha ",params["a"])
result <- paste0(result, " --iterations ",iter.nbr)
result <- paste0(result, " --neighborhood_size ",params["l"])
result <- paste0(result, " --rcc ",params["rcc"])
result <- paste0(result, " --k ",params["k"])
result <- paste0(result, " --time-limit ",time.limit)
result <- paste0(result, " --input-file \"",input.file,"\"")
result <- paste0(result, " --output-folder \"",output.folder,"\"")
result <- paste0(result, " --gain-function-type ",params["g"])
result <- paste0(result, " --strategy ","GRASP")
result <- paste0(result, " --perturbationLevelMax ",params["p"])
return(result)
}
#############################################################################################
# Returns the full name based on the normalized (short) name. Note that for parameterized
# algorithms, this will just return a clean version of the short name, since it contains
# the parameter values.
#
# algo.names: short names of the considered algorithms.
#
# returns: the corresponding full names, to be used in plots for instance.
#############################################################################################
get.algo.names <- function(algo.names)
{ result <- c()
for(algo.name in algo.names)
{ # no parameters
if(algo.name %in% names(COMDET.ALGO.NAMES))
result <- c(result, COMDET.ALGO.NAMES[algo.name])
# parameters
else
result <- c(result, gsub(pattern="_", replacement=" ", x=algo.name, fixed=TRUE))
}
return(result)
}
#############################################################################################
# Returns the inline command for the specified algorithm. The "..." parameters are fetched
# to the algorithm-specific function.
#
# algo.name: short code associated to the algorithm, including its parameter values.
#
# returns: the command allowing to invoke the program externally.
#############################################################################################
get.algo.commands <- function(algo.names, ...)
{ result <- c()
for(algo.name in algo.names)
{ if(startsWith(algo.name,COMDET.ALGO.ILS))
result <- c(result, get.ils.command(algo.name, ...))
else if(startsWith(algo.name,COMDET.ALGO.GRASP))
result <- c(result, get.grasp.command(algo.name, ...))
}
return(result)
}