R模块化接口例子

本页面包含了所有R模块化接口的例子。

• Classifier
• Distribution
• Kernel
• Mkl
• Preproc

要运行这些例子只需要

R -f name_of_example.R

或者启动R并输入

source('name_of_example.R')

Classifier

• ../examples/documented/r_modular/classifier_gmnpsvm_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_multiclass <- as.real(read.table('../data/label_train_multiclass.dat'))
  
  # gmnpsvm
  print('GMNPSVM')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 2.1
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  C <- 1.3
  epsilon <- 1e-5
  num_threads <- as.integer(1)
  labels <- Labels(label_train_multiclass)
  
  svm <- GMNPSVM(C, kernel, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_gpbtsvm_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # gpbtsvm
  print('GPBTSVM')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 2.1
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  C <- 0.017
  epsilon <- 1e-5
  num_threads <- as.integer(2)
  labels <- Labels(label_train_twoclass)
  
  svm <- GPBTSVM(C, kernel, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_knn_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_multiclass <- as.real(read.table('../data/label_train_multiclass.dat'))
  
  # knn
  print('KNN')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  distance <- EuclidianDistance()
  
  k <- as.integer(3)
  num_threads <- as.integer(1)
  labels <- Labels(label_train_multiclass)
  
  knn <- KNN(k, distance, labels)
  dump <- knn$parallel$set_num_threads(knn$parallel, num_threads)
  dump <- knn$train(knn, feats_train)
  lab <- knn$classify(knn, feats_test)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_lda_modular.R

  library(shogun)
  
  fm_train_real <- t(as.matrix(read.table('../data/fm_train_real.dat')))
  fm_test_real <- t(as.matrix(read.table('../data/fm_test_real.dat')))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat')$V1)
  
  # lda
  print('LDA')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  
  gamma <- 3
  labels <- Labels(label_train_twoclass)
  
  lda <- LDA(gamma, feats_train, labels)
  dump <- lda$train(lda)
  
  dump <- lda$get_bias(lda)
  dump <- lda$get_w(lda)
  dump <- lda$set_features(lda, feats_test)
  lab <- lda$classify(lda)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_liblinear_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # liblinear
  print('LibLinear')
  
  realfeat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, realfeat)
  realfeat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, realfeat)
  
  C <- 1.42
  epsilon <- 1e-5
  num_threads <- as.integer(1)
  labels <- Labels(label_train_twoclass)
  
  svm <- LibLinear(C, feats_train, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$set_bias_enabled(svm, TRUE)
  dump <- svm$train(svm)
  
  dump <- svm$set_features(svm, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_libsvm_modular.R

  library(shogun)
  
  fm_train_real <- t(as.matrix(read.table('../data/fm_train_real.dat')))
  fm_test_real <- t(as.matrix(read.table('../data/fm_test_real.dat')))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat')$V1)
  
  # libsvm
  print('LibSVM')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 2.1
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  C <- 1.017
  epsilon <- 1e-5
  num_threads <- as.integer(2)
  labels <- Labels(label_train_twoclass)
  
  svm <- LibSVM(C, kernel, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_libsvmmulticlass_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_multiclass <- as.real(read.table('../data/label_train_multiclass.dat'))
  
  # libsvmmulticlass
  print('LibSVMMultiClass')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 2.1
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  C <- 1.017
  epsilon <- 1e-5
  num_threads <- as.integer(8)
  labels <- Labels(label_train_multiclass)
  
  svm <- LibSVMMultiClass(C, kernel, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_libsvmoneclass_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # libsvm oneclass
  print('LibSVMOneClass')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 2.1
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  C <- 1.017
  epsilon <- 1e-5
  num_threads <- as.integer(4)
  
  svm <- LibSVMOneClass(C, kernel)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  
  

• ../examples/documented/r_modular/classifier_mpdsvm_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_multiclass <- as.real(read.table('../data/label_train_multiclass.dat'))
  
  # libsvmmulticlass
  print('LibSVMMultiClass')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 2.1
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  C <- 1.2
  epsilon <- 1e-5
  num_threads <- as.integer(8)
  labels <- Labels(label_train_multiclass)
  
  svm <- LibSVMMultiClass(C, kernel, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_perceptron_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # perceptron
  print('Perceptron')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  
  learn_rate <- 1.
  max_iter <- as.integer(1000)
  num_threads <- as.integer(1)
  labels <- Labels(label_train_twoclass)
  
  perceptron <- Perceptron(feats_train, labels)
  dump <- perceptron$set_learn_rate(perceptron, learn_rate)
  dump <- perceptron$set_max_iter(perceptron, max_iter)
  dump <- perceptron$train(perceptron)
  
  dump <- perceptron$set_features(perceptron, feats_test)
  lab <- perceptron$classify(perceptron)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_subgradientsvm_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # subgradient based svm
  print('SubGradientSVM')
  
  realfeat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, realfeat)
  realfeat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, realfeat)
  
  C <- 1.42
  epsilon <- 1e-3
  num_threads <- as.integer(1)
  max_train_time <- 1.
  labels <- Labels(label_train_twoclass)
  
  svm <- SubGradientSVM(C, feats_train, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$set_bias_enabled(svm, FALSE)
  dump <- svm$set_max_train_time(svm, max_train_time)
  dump <- svm$train(svm)
  
  dump <- svm$set_features(svm, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_svmlight_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  label_train_dna <- as.real(read.table('../data/label_train_dna42.dat'))
  
  # svm light
  dosvmlight <- function()
  {
  	print('SVMLight')
  
  	feats_train <- StringCharFeatures("DNA")
  	dump <- feats_train$set_features(feats_train, fm_train_dna)
  	feats_test <- StringCharFeatures("DNA")
  	dump <- feats_test$set_features(feats_test, fm_test_dna)
  	degree <- as.integer(20)
  
  	kernel <- WeightedDegreeStringKernel(feats_train, feats_train, degree)
  
  	C <- 1.017
  	epsilon <- 1e-5
  	num_threads <- as.integer(3)
  	labels <- Labels(as.real(label_train_dna))
  
  	svm <- SVMLight(C, kernel, labels)
  	dump <- svm$set_epsilon(svm, epsilon)
  	dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  	dump <- svm$train(svm)
  
  	dump <- kernel$init(kernel, feats_train, feats_test)
  	lab <- svm$classify(svm)
  	out <- lab$get_labels(lab)
  }
  try(dosvmlight())
  

• ../examples/documented/r_modular/classifier_svmlin_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # svm lin
  print('SVMLin')
  
  realfeat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, realfeat)
  realfeat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, realfeat)
  
  C <- 1.42
  epsilon <- 1e-5
  num_threads <- as.integer(1)
  labels <- Labels(label_train_twoclass)
  
  svm <- SVMLin(C, feats_train, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$set_bias_enabled(svm, TRUE)
  dump <- svm$train(svm)
  
  dump <- svm$set_features(svm, feats_test)
  dump <- svm$get_bias(svm)
  dump <- svm$get_w(svm)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_svmocas_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # svm ocas
  print('SVMOcas')
  
  realfeat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, realfeat)
  realfeat <- RealFeatures(fm_test_real)
  dump <- feats_test <- SparseRealFeatures()
  feats_test$obtain_from_simple(feats_test, realfeat)
  
  C <- 1.42
  epsilon <- 1e-5
  num_threads <- as.integer(1)
  labels <- Labels(label_train_twoclass)
  
  svm <- SVMOcas(C, feats_train, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$set_bias_enabled(svm, FALSE)
  dump <- svm$train(svm)
  
  dump <- svm$set_features(svm, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

• ../examples/documented/r_modular/classifier_svmsgd_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_twoclass <- as.real(read.table('../data/label_train_twoclass.dat'))
  
  # sgd
  print('SVMSGD')
  
  realfeat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, realfeat)
  realfeat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, realfeat)
  
  C <- 2.3
  num_threads <- as.integer(1)
  labels <- Labels(label_train_twoclass)
  
  svm <- SVMSGD(C, feats_train, labels)
  #dump <- svm$io$set_loglevel(svm$io, 0)
  dump <- svm$set_epochs(num_iter)
  dump <- svm$train(svm)
  
  dump <- svm$set_features(svm, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

Distribution

• ../examples/documented/r_modular/distribution_histogram_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  
  # Histogram
  print('Histogram')
  
  order <- as.integer(3)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- FALSE
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_train_dna)
  feats=StringWordFeatures(charfeat$get_alphabet())
  dump <- feats$obtain_from_char(feats, charfeat, start, order, gap, reverse)
  preproc=SortWordString()
  dump <- preproc$init(preproc, feats)
  dump <- feats$add_preproc(feats, preproc)
  dump <- feats$apply_preproc(feats)
  
  histo=Histogram(feats)
  dump <- histo$train(histo)
  
  dump <- histo$get_histogram()
  
  num_examples <- feats$get_num_vectors()
  num_param <- histo$get_num_model_parameters()
  
  # commented out as this is quite time consuming
  #derivs=matrix(0,num_param, num_examples)
  #for (i in 0:(num_examples-1))
  #{
  #	for (j in 0:(num_param-1))
  #	{
  #		derivs[j,i]=histo$get_log_derivative(histo, j, i)
  #	}
  #}
  dump <- histo$get_log_likelihood(histo, as.integer(0))
  dump <- histo$get_log_likelihood_sample()
  

• ../examples/documented/r_modular/distribution_hmm_modular.R

  library(shogun)
  
  fm_train_cube <- as.matrix(read.table('../data/fm_train_cube.dat', colClasses=c('character')))
  
  # HMM
  print('HMM')
  
  N <- as.integer(3)
  M <- as.integer(6)
  pseudo <- 1e-1
  order <- as.integer(1)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- FALSE
  num_examples <- as.integer(2)
  
  charfeat <- StringCharFeatures("CUBE")
  dump <- charfeat$set_features(charfeat, fm_train_cube)
  feats <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats$obtain_from_char(feats, charfeat, start, order, gap, reverse)
  preproc <- SortWordString()
  dump <- preproc$init(preproc, feats)
  dump <- feats$add_preproc(feats, preproc)
  dump <- feats$apply_preproc(feats)
  
  hmm <- HMM(feats, N, M, pseudo)
  dump <- hmm$train(hmm)
  dump <- hmm$baum_welch_viterbi_train(hmm, "BW_NORMAL")
  
  num_examples <- feats$get_num_vectors()
  num_param <- hmm$get_num_model_parameters()
  
  derivs <- matrix(0, num_param, num_examples)
  for (i in 0:(num_examples-1))
  {
  	for (j in 0:(num_param-1))
  	{
  		derivs[j,i] <- hmm$get_log_derivative(hmm, j, i)
  	}
  }
  
  best_path <- 0
  best_path_state <- 0
  
  for (i in 0:(num_examples-1))
  {
  	best_path = best_path + hmm$best_path(hmm, i)
  	for (j in 0:(N-1))
  	{
  		best_path_state = best_path_state + hmm$get_best_path_state(hmm, i, j)
  	}
  }
  
  dump <- hmm$get_log_likelihood(hmm, as.integer(0))
  dump <- hmm$get_log_likelihood_sample()
  

• ../examples/documented/r_modular/distribution_linearhmm_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  
  # Linear HMM
  print('LinearHMM')
  
  order <- as.integer(3)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- FALSE
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_train_dna)
  feats <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats$obtain_from_char(feats, charfeat, start, order, gap, reverse)
  preproc <- SortWordString()
  dump <- preproc$init(preproc, feats)
  dump <- feats$add_preproc(feats, preproc)
  dump <- feats$apply_preproc(feats)
  
  hmm <- LinearHMM(feats)
  dump <- hmm$train(hmm)
  
  dump <- hmm$get_transition_probs()
  
  num_examples <- feats$get_num_vectors()
  num_param <- hmm$get_num_model_parameters()
  derivs <- matrix(0, num_param, num_examples)
  
  for (i in 0:(num_examples-1))
  {
  	for (j in 0:(num_param-1))
  	{
  		derivs[j,i] <- hmm$get_log_derivative(hmm, j, i)
  	}
  }
  
  dump <- hmm$get_log_likelihood(hmm, as.integer(0))
  dump <- hmm$get_log_likelihood_sample()
  

Kernel

• ../examples/documented/r_modular/kernel_auc_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # auc
  #print('AUC')
  #
  #feats_train <- RealFeatures(fm_train_real)
  #feats_test <- RealFeatures(fm_test_real)
  #width <- 1.7
  #subkernel <- GaussianKernel(feats_train, feats_test, width)
  #
  #num_feats <- 2; # do not change!
  #len_train <- 11
  #len_test <- 17
  #data <- uint16((len_train-1)*rand(num_feats, len_train))
  #feats_train <- WordFeatures(data)
  #data <- uint16((len_test-1)*rand(num_feats, len_test))
  #feats_test <- WordFeatures(data)
  #
  #kernel <- AUCKernel(feats_train, feats_test, subkernel)
  #
  #km_train <- kernel$get_kernel_matrix()
  #kernel$init(kernel, feats_train, feats_test)
  #km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_chi2_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # chi2
  print('Chi2')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 1.4
  size_cache <- as.integer(10)
  
  kernel <- Chi2Kernel(feats_train, feats_train, width, size_cache)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_combined_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # combined
  print('Combined')
  
  kernel <- CombinedKernel()
  feats_train <- CombinedFeatures()
  feats_test <- CombinedFeatures()
  
  subkfeats_train <- RealFeatures(fm_train_real)
  subkfeats_test <- RealFeatures(fm_test_real)
  subkernel <- GaussianKernel(as.integer(10), 1.6)
  dump <- feats_train$append_feature_obj(feats_train, subkfeats_train)
  dump <- feats_test$append_feature_obj(feats_test, subkfeats_test)
  dump <- kernel$append_kernel(kernel, subkernel)
  
  subkfeats_train <- StringCharFeatures("DNA")
  dump <- subkfeats_train$set_features(subkfeats_train, fm_train_dna)
  subkfeats_test <- StringCharFeatures("DNA")
  dump <- subkfeats_test$set_features(subkfeats_test, fm_test_dna)
  degree <- as.integer(3)
  subkernel <- FixedDegreeStringKernel(as.integer(10), degree)
  dump <- feats_train$append_feature_obj(feats_train, subkfeats_train)
  dump <- feats_test$append_feature_obj(feats_test, subkfeats_test)
  dump <- kernel$append_kernel(kernel, subkernel)
  
  subkfeats_train <- StringCharFeatures("DNA")
  dump <- subkfeats_train$set_features(subkfeats_train, fm_train_dna)
  subkfeats_test <- StringCharFeatures("DNA")
  dump <- subkfeats_test$set_features(subkfeats_test, fm_test_dna)
  subkernel <- LocalAlignmentStringKernel(as.integer(10))
  dump <- feats_train$append_feature_obj(feats_train, subkfeats_train)
  dump <- feats_test$append_feature_obj(feats_test, subkfeats_test)
  dump <- kernel$append_kernel(kernel, subkernel)
  
  dump <- kernel$init(kernel, feats_train, feats_train)
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_comm_ulong_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # comm_ulong_string
  print('CommUlongString')
  
  order <- as.integer(3)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- FALSE
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_train_dna)
  feats_train <- StringUlongFeatures(charfeat$get_alphabet())
  dump <- feats_train$obtain_from_char(feats_train, charfeat, start, order, gap, reverse)
  preproc <- SortUlongString()
  dump <- preproc$init(preproc, feats_train)
  dump <- feats_train$add_preproc(feats_train, preproc)
  dump <- feats_train$apply_preproc(feats_train)
  
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_test_dna)
  feats_test <- StringUlongFeatures(charfeat$get_alphabet())
  dump <- feats_test$obtain_from_char(feats_test, charfeat, start, order, gap, reverse)
  dump <- feats_test$add_preproc(feats_test, preproc)
  dump <- feats_test$apply_preproc(feats_test)
  
  use_sign <- FALSE
  
  kernel <- CommUlongStringKernel(feats_train, feats_train, use_sign)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_comm_word_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # comm_word_string
  print('CommWordString')
  
  order <- as.integer(3)
  gap <- as.integer(0)
  start <- as.integer(order-1)
  reverse <- FALSE
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_train_dna)
  feats_train <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats_train$obtain_from_char(feats_train, charfeat, start, order, gap, reverse)
  preproc <- SortWordString()
  dump <- preproc$init(preproc, feats_train)
  dump <- feats_train$add_preproc(feats_train, preproc)
  dump <- feats_train$apply_preproc(feats_train)
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_test_dna)
  feats_test <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats_test$obtain_from_char(feats_test, charfeat, start, order, gap, reverse)
  dump <- feats_test$add_preproc(feats_test, preproc)
  dump <- feats_test$apply_preproc(feats_test)
  
  use_sign <- FALSE
  
  kernel <- CommWordStringKernel(feats_train, feats_train, use_sign)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_const_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # const
  print('Const')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  c <- 23.
  
  kernel <- ConstKernel(feats_train, feats_train, c)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_custom_modular.R

  library(shogun)
  
  ## custom
  #print('Custom')
  #
  #dim <- 7
  #data <- rand(dim, dim)
  #feats <- RealFeatures(data)
  #symdata <- data+data'
  #lowertriangle <- array([symdata[(x,y)] for x in xrange(symdata.shape[1])
  #	for y in xrange(symdata.shape[0]) if y< <- x])
  #
  #kernel <- CustomKernel(feats, feats)
  #
  #kernel$set_triangle_kernel_matrix_from_triangle(lowertriangle)
  #km_triangletriangle <- kernel$get_kernel_matrix()
  #
  #kernel$set_triangle_kernel_matrix_from_full(symdata)
  #km_fulltriangle <- kernel$get_kernel_matrix()
  #
  #kernel$set_full_kernel_matrix_from_full(data)
  #km_fullfull <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_diag_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # diag
  print('Diag')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  diag <- 23.
  
  kernel <- DiagKernel(feats_train, feats_train, diag)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_distance_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # distance
  print('Distance')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 1.7
  distance <- EuclidianDistance()
  
  kernel <- DistanceKernel(feats_train, feats_test, width, distance)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_fixed_degree_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # fixed_degree_string
  print('FixedDegreeString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  degree <- as.integer(3)
  
  kernel <- FixedDegreeStringKernel(feats_train, feats_train, degree)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_gaussian_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # gaussian
  print('Gaussian')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 1.9
  
  kernel <- GaussianKernel(feats_train, feats_train, width)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_gaussian_shift_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # gaussian_shift
  print('GaussianShift')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  width <- 1.8
  max_shift <- as.integer(2)
  shift_step <- as.integer(1)
  
  kernel <- GaussianShiftKernel(
  	feats_train, feats_train, width, max_shift, shift_step)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_histogramword_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  label_train_dna <- as.real(as.matrix(read.table('../data/label_train_dna.dat')))
  
  # plugin_estimate
  print('PluginEstimate w/ HistogramWord')
  
  order <- as.integer(3)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- FALSE
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_train_dna)
  feats_train <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats_train$obtain_from_char(feats_train, charfeat, start, order, gap, reverse)
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_test_dna)
  feats_test <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats_test$obtain_from_char(feats_test, charfeat, start, order, gap, reverse)
  
  pie <- PluginEstimate()
  labels <- Labels(label_train_dna)
  dump <- pie$set_labels(pie, labels)
  dump <- pie$set_features(pie, feats_train)
  dump <- pie$train(pie)
  
  kernel <- HistogramWordStringKernel(feats_train, feats_train, pie)
  km_train <- kernel$get_kernel_matrix()
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  dump <- pie$set_features(pie, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_linear_byte_modular.R

  library(shogun)
  
  fm_train_byte <- as.matrix(read.table('../data/fm_train_byte'))
  fm_test_byte <- as.matrix(read.table('../data/fm_test_byte'))
  
  # linear byte
  print('LinearByte')
  
  num_feats <- 11
  feats_train <- ByteFeatures(RAWBYTE)
  feats_train$copy_feature_matrix(traindata_byte)
  
  feats_test <- ByteFeatures(RAWBYTE)
  feats_test$copy_feature_matrix(testdata_byte)
  
  kernel <- LinearByteKernel(feats_train, feats_train)
  
  km_train <- kernel$get_kernel_matrix()
  kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_linear_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # linear
  print('Linear')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  scale <- 1.2
  
  kernel <- LinearKernel()
  dump <- kernel$set_normalizer(kernel, AvgDiagKernelNormalizer(scale))
  dump <- kernel$init(kernel, feats_train, feats_train)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_linear_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # linear_string
  print('LinearString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  
  kernel <- LinearStringKernel(feats_train, feats_train)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_linear_word_modular.R

  library(shogun)
  
  fm_train_word <- as.matrix(read.table('../data/fm_train_word.dat'))
  fm_test_word <- as.matrix(read.table('../data/fm_test_word.dat'))
  
  ## linear_word
  #print('LinearWord')
  #
  #feats_train <- WordFeatures(fm_train_word)
  #feats_test <- WordFeatures(fm_test_word)
  #do_rescale <- TRUE
  #scale <- 1.4
  #
  #kernel <- LinearWordKernel(feats_train, feats_train, do_rescale, scale)
  #
  #km_train <- kernel$get_kernel_matrix()
  #kernel$init(kernel, feats_train, feats_test)
  #km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_local_alignment_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # local_alignment_string
  print('LocalAlignmentString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  
  kernel <- LocalAlignmentStringKernel(feats_train, feats_train)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_localityimprovedstring_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # locality_improved_string
  print('LocalityImprovedString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  l <- as.integer(5)
  inner_degree <- as.integer(5)
  outer_degree <- as.integer(7)
  
  kernel <- LocalityImprovedStringKernel(
  	feats_train, feats_train, l, inner_degree, outer_degree)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_oligo_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # oligo_string
  print('OligoString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  k <- as.integer(3)
  width <- 1.2
  size_cache <- as.integer(10)
  
  kernel <- OligoStringKernel(size_cache,  k, width)
  dump <- kernel$init(kernel, feats_train, feats_train)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_poly_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # poly
  print('Poly')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  degree <- as.integer(4)
  inhomogene <- FALSE
  
  kernel <- PolyKernel(
  	feats_train, feats_train, degree, inhomogene)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_polymatchstring_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # poly_match_string
  print('PolyMatchString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  degree <- as.integer(3)
  inhomogene <- FALSE
  
  kernel <- PolyMatchStringKernel(feats_train, feats_train, degree, inhomogene)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_polymatchword_modular.R

  library(shogun)
  
  fm_train_word <- as.matrix(read.table('../data/fm_train_word.dat'))
  fm_test_word <- as.matrix(read.table('../data/fm_test_word.dat'))
  
  ## poly_match_word
  #print('PolyMatchWord')
  #
  #feats_train <- WordFeatures(traindata_word)
  #feats_test <- WordFeatures(testdata_word)
  #degree <- 2
  #inhomogene <- TRUE
  #
  #kernel <- PolyMatchWordKernel(feats_train, feats_train, degree, inhomogene)
  #
  #km_train <- kernel$get_kernel_matrix()
  #kernel$init(kernel, feats_train, feats_test)
  #km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_sigmoid_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # sigmoid
  print('Sigmoid')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  size_cache <- as.integer(10)
  gamma <- 1.2
  coef0 <- 1.3
  
  kernel <- SigmoidKernel(feats_train, feats_train, size_cache, gamma, coef0)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_simple_locality_improved_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # simple_locality_improved_string
  print('SimpleLocalityImprovedString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  l <- as.integer(5)
  inner_degree <- as.integer(5)
  outer_degree <- as.integer(7)
  
  kernel <- SimpleLocalityImprovedStringKernel(
  	feats_train, feats_train, l, inner_degree, outer_degree)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_sparsegaussian_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # sparse_gaussian
  print('SparseGaussian')
  
  feat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, feat)
  feat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, feat)
  width <- 1.1
  
  kernel <- SparseGaussianKernel(feats_train, feats_train, width)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_sparselinear_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # sparse_linear
  print('SparseLinear')
  
  feat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, feat)
  feat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, feat)
  scale <- 1.1
  
  kernel <- SparseLinearKernel()
  dump <- kernel$set_normalizer(kernel, AvgDiagKernelNormalizer(scale))
  dump <- kernel$init(kernel, feats_train, feats_train)
  

• ../examples/documented/r_modular/kernel_sparsepoly_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  # sparse_poly
  print('SparsePoly')
  
  feat <- RealFeatures(fm_train_real)
  feats_train <- SparseRealFeatures()
  dump <- feats_train$obtain_from_simple(feats_train, feat)
  feat <- RealFeatures(fm_test_real)
  feats_test <- SparseRealFeatures()
  dump <- feats_test$obtain_from_simple(feats_test, feat)
  size_cache <- as.integer(10)
  degree <- as.integer(3)
  inhomogene <- TRUE
  
  kernel <- SparsePolyKernel(feats_train, feats_train, size_cache, degree,
  	inhomogene)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_top_modular.R

  library(shogun)
  
  size_cache=as.integer(0)
  fm_train_cube <- as.matrix(read.table('../data/fm_train_cube.dat', colClasses=c('character')))
  fm_test_cube <- as.matrix(read.table('../data/fm_test_cube.dat', colClasses=c('character')))
  
  # top_fisher
  print('TOP/Fisher on PolyKernel')
  
  N <- as.integer(3)
  M <- as.integer(6)
  pseudo <- 1e-1
  order <- as.integer(1)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- FALSE
  
  charfeat <- StringCharFeatures("CUBE")
  dump <- charfeat$set_features(charfeat, fm_train_cube)
  wordfeats_train <- StringWordFeatures(charfeat$get_alphabet())
  dump <- wordfeats_train$obtain_from_char(wordfeats_train, charfeat, start, order, gap, reverse)
  preproc <- SortWordString()
  dump <- preproc$init(preproc, wordfeats_train)
  dump <- wordfeats_train$add_preproc(wordfeats_train, preproc)
  dump <- wordfeats_train$apply_preproc(wordfeats_train)
  
  charfeat <- StringCharFeatures("CUBE")
  dump <- charfeat$set_features(charfeat, fm_test_cube)
  wordfeats_test <- StringWordFeatures(charfeat$get_alphabet())
  dump <- wordfeats_test$obtain_from_char(wordfeats_test, charfeat, start, order, gap, reverse)
  dump <- wordfeats_test$add_preproc(wordfeats_test, preproc)
  dump <- wordfeats_test$apply_preproc(wordfeats_test)
  
  pos <- HMM(wordfeats_train, N, M, pseudo)
  dump <- pos$train(pos)
  dump <- pos$baum_welch_viterbi_train(pos, "BW_NORMAL")
  neg <- HMM(wordfeats_train, N, M, pseudo)
  dump <- neg$train(neg)
  dump <- neg$baum_welch_viterbi_train(neg, "BW_NORMAL")
  pos_clone <- HMM(pos)
  neg_clone <- HMM(neg)
  dump <- pos_clone$set_observations(pos_clone, wordfeats_test)
  dump <- neg_clone$set_observations(neg_clone, wordfeats_test)
  
  feats_train <- TOPFeatures(size_cache, pos, neg, FALSE, FALSE)
  feats_test <- TOPFeatures(size_cache, pos_clone, neg_clone, FALSE, FALSE)
  kernel <- PolyKernel(feats_train, feats_train, as.integer(1), FALSE)
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  
  feats_train <- FKFeatures(size_cache, pos, neg)
  dump <- feats_train$set_opt_a(feats_train, -1); #estimate prior
  feats_test <- FKFeatures(size_cache, pos_clone, neg_clone)
  dump <- feats_test$set_a(feats_test, feats_train$get_a()); #use prior from training data
  kernel <- PolyKernel(feats_train, feats_train, as.integer(1), FALSE)
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  
  

• ../examples/documented/r_modular/kernel_weighted_comm_word_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # weighted_comm_word_string
  print('WeightedCommWordString')
  
  order <- as.integer(3)
  start <- as.integer(order-1)
  gap <- as.integer(0)
  reverse <- TRUE
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_train_dna)
  feats_train <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats_train$obtain_from_char(feats_train, charfeat, start, order, gap, reverse)
  preproc <- SortWordString()
  dump <- preproc$init(preproc, feats_train)
  dump <- feats_train$add_preproc(feats_train, preproc)
  dump <- feats_train$apply_preproc(feats_train)
  
  charfeat <- StringCharFeatures("DNA")
  dump <- charfeat$set_features(charfeat, fm_test_dna)
  feats_test <- StringWordFeatures(charfeat$get_alphabet())
  dump <- feats_test$obtain_from_char(feats_test, charfeat, start, order, gap, reverse)
  dump <- feats_test$add_preproc(feats_test, preproc)
  dump <- feats_test$apply_preproc(feats_test)
  
  use_sign <- FALSE
  
  kernel <- WeightedCommWordStringKernel(feats_train, feats_train, use_sign)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_weighted_degree_position_string_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # weighted_degree_position_string
  print('WeightedDegreePositionString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  degree <- as.integer(20)
  
  kernel <- WeightedDegreePositionStringKernel(feats_train, feats_train, degree)
  
  #kernel$set_shifts(zeros(len(fm_train_dna[0]), dtype <- int))
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_weighteddegreestring_modular.R

  library(shogun)
  
  fm_train_dna <- as.matrix(read.table('../data/fm_train_dna.dat'))
  fm_test_dna <- as.matrix(read.table('../data/fm_test_dna.dat'))
  
  # weighted_degree_string
  print('WeightedDegreeString')
  
  feats_train <- StringCharFeatures("DNA")
  dump <- feats_train$set_features(feats_train, fm_train_dna)
  feats_test <- StringCharFeatures("DNA")
  dump <- feats_test$set_features(feats_test, fm_test_dna)
  degree <- as.integer(20)
  
  kernel <- WeightedDegreeStringKernel(feats_train, feats_train, degree)
  
  #weights <- arange(1,degree+1,dtype <- double)[::-1]/ \
  #	sum(arange(1,degree+1,dtype <- double))
  #kernel$set_wd_weights(weights)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/kernel_wordmatch_modular.R

  library(shogun)
  
  # Explicit examples on how to use the different kernels
  
  fm_train_word <- as.matrix(read.table('../data/fm_train_word.dat'))
  fm_test_word <- as.matrix(read.table('../data/fm_test_word.dat'))
  
  ## word_match
  #print('WordMatch')
  #
  #feats_train <- WordFeatures(fm_train_word)
  #feats_test <- WordFeatures(fm_test_word)
  #degree <- 3
  #do_rescale <- TRUE
  #scale <- 1.4
  #
  #kernel <- WordMatchKernel(feats_train, feats_train, degree, do_rescale, scale)
  #
  #km_train <- kernel$get_kernel_matrix()
  #kernel$init(kernel, feats_train, feats_test)
  #km_test <- kernel$get_kernel_matrix()
  

Mkl

• ../examples/documented/r_modular/mkl_multiclass_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  label_train_multiclass <- as.real(read.table('../data/label_train_multiclass.dat'))
  
  # MKLMultiClass
  print('MKLMultiClass')
  
  
  kernel <- CombinedKernel()
  feats_train <- CombinedFeatures()
  feats_test <- CombinedFeatures()
  
  subkfeats_train <- RealFeatures(fm_train_real)
  subkfeats_test <- RealFeatures(fm_test_real)
  subkernel <- GaussianKernel(as.integer(10), 1.2)
  dump <- feats_train$append_feature_obj(feats_train, subkfeats_train)
  dump <- feats_test$append_feature_obj(feats_test, subkfeats_test)
  dump <- kernel$append_kernel(kernel, subkernel)
  
  kernel <- CombinedKernel()
  feats_train <- CombinedFeatures()
  feats_test <- CombinedFeatures()
  
  subkfeats_train <- RealFeatures(fm_train_real)
  subkfeats_test <- RealFeatures(fm_test_real)
  subkernel <- LinearKernel(as.integer(10))
  dump <- feats_train$append_feature_obj(feats_train, subkfeats_train)
  dump <- feats_test$append_feature_obj(feats_test, subkfeats_test)
  dump <- kernel$append_kernel(kernel, subkernel)
  
  kernel <- CombinedKernel()
  feats_train <- CombinedFeatures()
  feats_test <- CombinedFeatures()
  
  subkfeats_train <- RealFeatures(fm_train_real)
  subkfeats_test <- RealFeatures(fm_test_real)
  subkernel <- PolyKernel(as.integer(10), as.integer(2))
  dump <- feats_train$append_feature_obj(feats_train, subkfeats_train)
  dump <- feats_test$append_feature_obj(feats_test, subkfeats_test)
  dump <- kernel$append_kernel(kernel, subkernel)
  dump <- kernel$init(kernel, feats_train, feats_train)
  
  C <- 1.2
  epsilon <- 1e-5
  mkl_eps <- 0.001 
  mkl_norm <- 1
  num_threads <- as.integer(1)
  labels <- Labels(label_train_multiclass)
  
  svm <- MKLMultiClass(C, kernel, labels)
  dump <- svm$set_epsilon(svm, epsilon)
  dump <- svm$parallel$set_num_threads(svm$parallel, num_threads)
  dump <- svm$set_mkl_epsilon(svm,mkl_eps)
  dump <- svm$set_mkl_norm(1.5)
  dump <- svm$train(svm)
  
  dump <- kernel$init(kernel, feats_train, feats_test)
  lab <- svm$classify(svm)
  out <- lab$get_labels(lab)
  

Preproc

• ../examples/documented/r_modular/preproc_logplusone_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  #LogPlusOne
  print('LogPlusOne')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  
  preproc <- LogPlusOne()
  dump <- preproc$init(preproc, feats_train)
  dump <- feats_train$add_preproc(feats_train, preproc)
  dump <- feats_train$apply_preproc(feats_train)
  dump <- feats_test$add_preproc(feats_test, preproc)
  dump <- feats_test$apply_preproc(feats_train)
  
  width <- 1.4
  size_cache <- as.integer(10)
  
  kernel <- Chi2Kernel(feats_train, feats_train, width, size_cache)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/preproc_normone_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  #NormOne
  print('NormOne')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  
  preproc <- NormOne()
  dump <- preproc$init(preproc, feats_train)
  dump <- feats_train$add_preproc(feats_train, preproc)
  dump <- feats_train$apply_preproc(feats_train)
  dump <- feats_test$add_preproc(feats_test, preproc)
  dump <- feats_test$apply_preproc(feats_test)
  
  width <- 1.4
  size_cache <- as.integer(10)
  
  kernel <- Chi2Kernel(feats_train, feats_train, width, size_cache)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()
  

• ../examples/documented/r_modular/preproc_prunevarsubmean_modular.R

  library(shogun)
  
  fm_train_real <- as.matrix(read.table('../data/fm_train_real.dat'))
  fm_test_real <- as.matrix(read.table('../data/fm_test_real.dat'))
  
  #PruneVarSubMean
  print('PruneVarSubMean')
  
  feats_train <- RealFeatures(fm_train_real)
  feats_test <- RealFeatures(fm_test_real)
  
  preproc <- PruneVarSubMean()
  dump <- preproc$init(preproc, feats_train)
  dump <- feats_train$add_preproc(feats_train, preproc)
  dump <- feats_train$apply_preproc(feats_train)
  dump <- feats_test$add_preproc(feats_test, preproc)
  dump <- feats_test$apply_preproc(feats_test)
  
  width <- 1.4
  size_cache <- as.integer(10)
  
  kernel <- Chi2Kernel(feats_train, feats_train, width, size_cache)
  
  km_train <- kernel$get_kernel_matrix()
  dump <- kernel$init(kernel, feats_train, feats_test)
  km_test <- kernel$get_kernel_matrix()