misvm: Fit MI-SVM model to the data

Description

This function fits the MI-SVM model, first proposed by Andrews et al. (2003). It is a variation on the traditional SVM framework that carefully treats data from the multiple instance learning paradigm, where instances are grouped into bags, and a label is only available for each bag.

Usage

# S3 method for default
misvm(
  x,
  y,
  bags,
  cost = 1,
  method = c("heuristic", "mip", "qp-heuristic"),
  weights = TRUE,
  control = list(kernel = "linear", sigma = if (is.vector(x)) 1 else 1/ncol(x),
    nystrom_args = list(m = nrow(x), r = nrow(x), sampling = "random"), max_step = 500,
    type = "C-classification", scale = TRUE, verbose = FALSE, time_limit = 60, start =
    FALSE),
  ...
)
# S3 method for formula
misvm(formula, data, ...)
# S3 method for mi_df
misvm(x, ...)
# S3 method for mild_df
misvm(x, .fns = list(mean = mean, sd = stats::sd), cor = FALSE, ...)

Value

An object of class misvm. The object contains at least the following components:

*_fit: A fit object depending on the method parameter. If method = 'heuristic', this will be an svm fit from the e1071 package. If method = 'mip', 'qp-heuristic' this will be gurobi_fit from a model optimization.
call_type: A character indicating which method misvm() was called with.
features: The names of features used in training.
levels: The levels of y that are recorded for future prediction.
cost: The cost parameter from function inputs.
weights: The calculated weights on the cost parameter.
repr_inst: The instances from positive bags that are selected to be most representative of the positive instances.
n_step: If method %in% c('heuristic', 'qp-heuristic'), the total steps used in the heuristic algorithm.
x_scale: If scale = TRUE, the scaling parameters for new predictions.

Arguments

x

A data.frame, matrix, or similar object of covariates, where each row represents an instance. If a mi_df object is passed, y, bags are automatically extracted, and all other columns will be used as predictors. If a mild_df object is passed, y, bags, instances are automatically extracted, and all other columns will be used as predictors.

y

A numeric, character, or factor vector of bag labels for each instance. Must satisfy length(y) == nrow(x). Suggest that one of the levels is 1, '1', or TRUE, which becomes the positive class; otherwise, a positive class is chosen and a message will be supplied.

bags

A vector specifying which instance belongs to each bag. Can be a string, numeric, of factor.

cost

The cost parameter in SVM. If method = 'heuristic', this will be fed to kernlab::ksvm(), otherwise it is similarly in internal functions.

method

The algorithm to use in fitting (default 'heuristic'). When method = 'heuristic', which employs an algorithm similar to Andrews et al. (2003). When method = 'mip', the novel MIP method will be used. When method = 'qp-heuristic, the heuristic algorithm is computed using the dual SVM. See details.

weights

named vector, or TRUE, to control the weight of the cost parameter for each possible y value. Weights multiply against the cost vector. If TRUE, weights are calculated based on inverse counts of instances with given label, where we only count one positive instance per bag. Otherwise, names must match the levels of y.

control

list of additional parameters passed to the method that control computation with the following components:

kernel either a character the describes the kernel ('linear' or 'radial') or a kernel matrix at the instance level.
sigma argument needed for radial basis kernel.
nystrom_args a list of parameters to pass to kfm_nystrom(). This is used when method = 'mip' and kernel = 'radial' to generate a Nystrom approximation of the kernel features.
max_step argument used when method = 'heuristic'. Maximum steps of iteration for the heuristic algorithm.
type: argument used when method = 'heuristic'. The type argument is passed to e1071::svm().
scale argument used for all methods. A logical for whether to rescale the input before fitting.
verbose argument used when method = 'mip'. Whether to message output to the console.
time_limit argument used when method = 'mip'. FALSE, or a time limit (in seconds) passed to gurobi() parameters. If FALSE, no time limit is given.
start argument used when method = 'mip'. If TRUE, the mip program will be warm_started with the solution from method = 'qp-heuristic' to potentially improve speed.

...

Arguments passed to or from other methods.

formula

a formula with specification mi(y, bags) ~ x which uses the mi function to create the bag-instance structure. This argument is an alternative to the x, y, bags arguments, but requires the data argument. See examples.

data

If formula is provided, a data.frame or similar from which formula elements will be extracted.

.fns

(argument for misvm.mild_df() method) list of functions to summarize instances over.

cor

(argument for misvm.mild_df() method) logical, whether to include correlations between all features in the summarization.

Methods (by class)

misvm(default): Method for data.frame-like objects
misvm(formula): Method for passing formula
misvm(mi_df): Method for mi_df objects, automatically handling bag names, labels, and all covariates.
misvm(mild_df): Method for mild_df objects. Summarize samples to the instance level based on specified functions, then perform misvm() on instance level data.

Author

Sean Kent, Yifei Liu

Details

Several choices of fitting algorithm are available, including a version of the heuristic algorithm proposed by Andrews et al. (2003) and a novel algorithm that explicitly solves the mixed-integer programming (MIP) problem using the gurobi package optimization back-end.

References

Andrews, S., Tsochantaridis, I., & Hofmann, T. (2002). Support vector machines for multiple-instance learning. Advances in neural information processing systems, 15.

Kent, S., & Yu, M. (2022). Non-convex SVM for cancer diagnosis based on morphologic features of tumor microenvironment arXiv preprint arXiv:2206.14704

Examples

Run this code

set.seed(8)
mil_data <- generate_mild_df(nbag = 20,
                             positive_prob = 0.15,
                             sd_of_mean = rep(0.1, 3))
df <- build_instance_feature(mil_data, seq(0.05, 0.95, length.out = 10))

# Heuristic method
mdl1 <- misvm(x = df[, 4:123], y = df$bag_label,
              bags = df$bag_name, method = "heuristic")
mdl2 <- misvm(mi(bag_label, bag_name) ~ X1_mean + X2_mean + X3_mean, data = df)

# MIP method
if (require(gurobi)) {
  mdl3 <- misvm(x = df[, 4:123], y = df$bag_label,
                bags = df$bag_name, method = "mip")
}

predict(mdl1, new_data = df, type = "raw", layer = "bag")

# summarize predictions at the bag layer
library(dplyr)
df %>%
  bind_cols(predict(mdl2, df, type = "class")) %>%
  bind_cols(predict(mdl2, df, type = "raw")) %>%
  distinct(bag_name, bag_label, .pred_class, .pred)

Run the code above in your browser using DataLab