Static R Interface Function Reference

Features

• load_features

  sg('load_features', filename, feature_class, type, target[, size[, comp_features]]) 

• save_features

  sg('save_features', filename, type, target) 

• clean_features

  sg('clean_features', 'TRAIN|TEST') 

• get_features

  [features] <- sg('get_features', 'TRAIN|TEST') 

• add_features

  sg('add_features', 'TRAIN|TEST', features[, DNABINFILE|<ALPHABET>]) 

• set_features

  sg('set_features', 'TRAIN|TEST', features[, DNABINFILE|<ALPHABET>]) 

• set_ref_features

  sg('set_ref_features', 'TRAIN|TEST') 

• del_last_features

  sg('del_last_features', 'TRAIN|TEST') 

• convert

  sg('convert', 'TRAIN|TEST', from_class, from_type, to_class, to_type[, order, start, gap, reversed]) 

• from_position_list

  sg('from_position_list', 'TRAIN|TEST', winsize, shift[, skip]) 

• slide_window

  sg('slide_window', 'TRAIN|TEST', winsize, shift[, skip]) 

• reshape

  sg('reshape', 'TRAIN|TEST, num_feat, num_vec) 

• load_labels

  sg('load_labels', filename, 'TRAIN|TARGET') 

• set_labels

  sg('set_labels', 'TRAIN|TEST', labels) 

• get_labels

  [labels] <- sg('get_labels', 'TRAIN|TEST') 

Kernel

• set_kernel

  sg('set_kernel', type, size[, kernel-specific parameters]) 

• add_kernel

  sg('add_kernel', weight, kernel-specific parameters) 

• del_last_kernel

  sg('del_last_kernel') 

• init_kernel

  sg('init_kernel', 'TRAIN|TEST') 

• clean_kernel

  sg('clean_kernel') 

• save_kernel

  sg('save_kernel', filename) 

• load_kernel_init

  sg('load_kernel_init', filename) 

• save_kernel_init

  sg('save_kernel_init', filename) 

• get_kernel_matrix

  [K] <- sg('get_kernel_matrix') 

• set_custom_kernel

  sg('set_custom_kernel', kernelmatrix, 'DIAG|FULL|FULL2DIAG') 

• set_WD_position_weights

  sg('set_WD_position_weights', W[, 'TRAIN|TEST']) 

• get_subkernel_weights

  [W] <- sg('get_subkernel_weights') 

• set_subkernel_weights

  sg('set_subkernel_weights', W) 

• set_subkernel_weights_combined

  sg('set_subkernel_weights_combined', W, idx) 

• set_last_subkernel_weights

  sg('set_last_subkernel_weights', W) 

• get_WD_position_weights

  [W] <- sg('get_WD_position_weights') 

• get_last_subkernel_weights

  [W] <- sg('get_last_subkernel_weights') 

• compute_by_subkernels

  [W] <- sg('compute_by_subkernels') 

• init_kernel_optimization

  sg('init_kernel_optimization') 

• get_kernel_optimization

  [W] <- sg('get_kernel_optimization') 

• delete_kernel_optimization

  sg('delete_kernel_optimization') 

• use_diagonal_speedup

  sg('use_diagonal_speedup', USAGE_STR0|1USAGE_STR) 

• set_kernel_optimization_type

  sg('set_kernel_optimization_type', USAGE_STRFASTBUTMEMHUNGRY|SLOWBUTMEMEFFICIENTUSAGE_STR) 

• resize_kernel_cache

  sg('resize_kernel_cache', size) 

Distance

• set_distance

  sg('set_distance', type, data type[, distance-specific parameters]) 

• init_distance

  sg('init_distance', 'TRAIN|TEST') 

• get_distance_matrix

  [D] <- sg('get_distance_matrix') 

Classifier

• classify

  [result] <- sg('classify') 

• svm_classify

  [result] <- sg('svm_classify') 

• classify_example

  [result] <- sg('classify_example', feature_vector_index) 

• svm_classify_example

  [result] <- sg('svm_classify_example', feature_vector_index) 

• get_classifier

  [bias, weights] <- sg('get_classifier') 

• get_clustering

  [radi, centers|merge_distances, pairs] <- sg('get_clustering') 

• new_svm

  sg('new_svm', 'LIBSVM_ONECLASS|LIBSVM_MULTICLASS|LIBSVM|SVMLIGHT|LIGHT|SVMLIN|GPBTSVM|MPDSVM|GNPPSVM|GMNPSVM|SUBGRADIENTSVM|WDSVMOCAS|SVMOCAS|SVMSGD|SVMBMRM|SVMPERF|KERNELPERCEPTRON|PERCEPTRON|LIBLINEAR_LR|LIBLINEAR_L2|LDA|LPM|LPBOOST|SUBGRADIENTLPM|KNN') 

• new_classifier

  sg('new_classifier', 'LIBSVM_ONECLASS|LIBSVM_MULTICLASS|LIBSVM|SVMLIGHT|LIGHT|SVMLIN|GPBTSVM|MPDSVM|GNPPSVM|GMNPSVM|SUBGRADIENTSVM|WDSVMOCAS|SVMOCAS|SVMSGD|SVMBMRM|SVMPERF|KERNELPERCEPTRON|PERCEPTRON|LIBLINEAR_LR|LIBLINEAR_L2|LDA|LPM|LPBOOST|SUBGRADIENTLPM|KNN') 

• new_regression

  sg('new_regression', 'SVRLIGHT|LIBSVR|KRR') 

• new_clustering

  sg('new_clustering', 'KMEANS|HIERARCHICAL') 

• load_svm

  [filename, type] <- sg('load_svm') 

• get_svm

  [bias, alphas] <- sg('get_svm') 

• set_svm

  sg('set_svm', bias, alphas) 

• get_svm_objective

  [objective] <- sg('get_svm_objective') 

• do_auc_maximization

  sg('do_auc_maximization', 'auc') 

• set_perceptron_parameters

  sg('set_perceptron_parameters', learnrate, maxiter) 

• train_classifier

  sg('train_classifier', [classifier-specific parameters]) 

• train_regression

  sg('train_regression') 

• train_clustering

  sg('train_clustering') 

• svm_train

  sg('svm_train', [classifier-specific parameters]) 

• svm_test

  sg('svm_test') 

• svm_qpsize

  sg('svm_qpsize', size) 

• svm_max_qpsize

  sg('svm_max_qpsize', size) 

• svm_bufsize

  sg('svm_bufsize', size) 

• c

  sg('c', C1[, C2]) 

• svm_epsilon

  sg('svm_epsilon', epsilon) 

• svr_tube_epsilon

  sg('svr_tube_epsilon', tube_epsilon) 

• svm_one_class_nu

  sg('svm_one_class_nu', nu) 

• mkl_parameters

  sg('mkl_parameters', weight_epsilon, C_MKL) 

• svm_max_train_time

  sg('svm_max_train_time', max_train_time) 

• use_precompute

  sg('use_precompute', enable_precompute) 

• use_mkl

  sg('use_mkl', enable_mkl) 

• use_shrinking

  sg('use_shrinking', enable_shrinking) 

• use_batch_computation

  sg('use_batch_computation', enable_batch_computation) 

• use_linadd

  sg('use_linadd', enable_linadd) 

• svm_use_bias

  sg('svm_use_bias', enable_bias) 

• krr_tau

  sg('krr_tau', tau) 

Preprocessors

• add_preproc

  sg('add_preproc', preproc[, preproc-specific parameters]) 

• del_preproc

  sg('del_preproc') 

• load_preproc

  sg('load_preproc', filename) 

• save_preproc

  sg('save_preproc', filename) 

• attach_preproc

  sg('attach_preproc', 'TRAIN|TEST', force) 

• clean_preproc

  sg('clean_preproc') 

HMM

• new_hmm

  sg('new_hmm', N, M) 

• load_hmm

  sg('load_hmm', filename) 

• save_hmm

  sg('save_hmm', filename[, save_binary]) 

• get_hmm

  [p, q, a, b] <- sg('get_hmm') 

• append_hmm

  sg('append_hmm', p, q, a, b) 

• append_model

  sg('append_model', 'filename'[, base1, base2]) 

• set_hmm

  sg('set_hmm', p, q, a, b) 

• set_hmm_as

  sg('set_hmm_as', POS|NEG|TEST) 

• chop

  sg('chop', chop) 

• pseudo

  sg('pseudo', pseudo) 

• load_defs

  sg('load_defs', filename, init) 

• hmm_classify

  [result] <- sg('hmm_classify') 

• hmm_test

  sg('hmm_test', output name[, ROC filename[, neglinear[, poslinear]]]) 

• one_class_linear_hmm_classify

  [result] <- sg('one_class_linear_hmm_classify') 

• one_class_hmm_test

  sg('one_class_hmm_test', output name[, ROC filename[, linear]]) 

• one_class_hmm_classify

  [result] <- sg('one_class_hmm_classify') 

• one_class_hmm_classify_example

  [result] <- sg('one_class_hmm_classify_example', feature_vector_index) 

• hmm_classify_example

  [result] <- sg('hmm_classify_example', feature_vector_index) 

• output_hmm

  sg('output_hmm') 

• output_hmm_defined

  sg('output_hmm_defined') 

• hmm_likelihood

  [likelihood] <- sg('hmm_likelihood') 

• likelihood

  sg('likelihood') 

• save_hmm_likelihood

  sg('save_hmm_likelihood', filename[, save_binary]) 

• get_viterbi_path

  [path, likelihood] <- sg('get_viterbi_path', dim) 

• vit_def

  sg('vit_def') 

• vit

  sg('vit') 

• bw

  sg('bw') 

• bw_def

  sg('bw_def') 

• bw_trans

  sg('bw_trans') 

• linear_train

  sg('linear_train') 

• save_hmm_path

  sg('save_hmm_path', filename[, save_binary]) 

• convergence_criteria

  sg('convergence_criteria', num_iterations, epsilon) 

• normalize_hmm

  sg('normalize_hmm', [keep_dead_states]) 

• add_states

  sg('add_states', states, value) 

• permutation_entropy

  sg('permutation_entropy', width, seqnum) 

• relative_entropy

  [result] <- sg('relative_entropy') 

• entropy

  [result] <- sg('entropy') 

• set_feature_matrix

  sg('set_feature_matrix', features) 

• new_plugin_estimator

  sg('new_plugin_estimator', pos_pseudo, neg_pseudo) 

• train_estimator

  sg('train_estimator') 

• test_estimator

  sg('test_estimator') 

• plugin_estimate_classify_example

  [result] <- sg('plugin_estimate_classify_example', feature_vector_index) 

• plugin_estimate_classify

  [result] <- sg('plugin_estimate_classify') 

• set_plugin_estimate

  sg('set_plugin_estimate', emission_probs, model_sizes) 

• get_plugin_estimate

  [emission_probs, model_sizes] <- sg('get_plugin_estimate') 

Structure

• best_path

  sg('best_path', from, to) 

• best_path_2struct

  [prob, path, pos] <- sg('best_path_2struct', p, q, cmd_trans, seq, pos, genestr, penalties, penalty_info, nbest, content_weights, segment_sum_weights) 

• set_plif_struct

  sg('set_plif_struct', id, name, limits, penalties, transform, min_value, max_value, use_cache, use_svm) 

• get_plif_struct

  [id, name, limits, penalties, transform, min_value, max_value, use_cache, use_svm] <- sg('get_plif_struct') 

• precompute_content_svms

  sg('precompute_content_svms', sequence, position_list, weights) 

• set_model

  sg('set_model', content_weights, transition_pointers, use_orf, mod_words) 

• best_path_trans

  [prob, path, pos] <- sg('best_path_trans', p, q, nbest, seq_path, a_trans, segment_loss) 

• best_path_trans_deriv

  [p_deriv, q_deriv, cmd_deriv, penalties_deriv, my_scores, my_loss] <- sg('best_path_trans_deriv', , my_path, my_pos, p, q, cmd_trans, seq, pos, genestr, penalties, state_signals, penalty_info, dict_weights, mod_words [, segment_loss, segmend_ids_mask]) 

• best_path_no_b

  [prob, path] <- sg('best_path_no_b', p, q, a, max_iter) 

• best_path_trans_simple

  [prob, path] <- sg('best_path_trans_simple', p, q, cmd_trans, seq, nbest) 

• best_path_no_b_trans

  [prob, path] <- sg('best_path_no_b_trans', p, q, cmd_trans, max_iter, nbest) 

POIM

• compute_poim_wd

  [W] <- sg('compute_poim_wd', max_order, distribution) 

• get_SPEC_consensus

  [W] <- sg('get_SPEC_consensus') 

• get_SPEC_scoring

  [W] <- sg('get_SPEC_scoring', max_order) 

• get_WD_consensus

  [W] <- sg('get_WD_consensus') 

• get_WD_scoring

  [W] <- sg('get_WD_scoring', max_order) 

Utility

• crc

  [crc32] <- sg('crc', string) 

• !

  sg('!', system_command) 

• exit

  sg('exit') 

• quit

  sg('quit') 

• exec

  sg('exec', filename) 

• set_output

  sg('set_output', 'STDERR|STDOUT|filename') 

• set_threshold

  sg('set_threshold', threshold) 

• threads

  sg('threads', num_threads) 

• translate_string

  [translation] <- sg('translate_string', string, order, start) 

• clear

  sg('clear') 

• tic

  sg('tic') 

• toc

  sg('toc') 

• print

  sg('print', msg) 

• echo

  sg('echo', level) 

• loglevel

  sg('loglevel', 'ALL|DEBUG|INFO|NOTICE|WARN|ERROR|CRITICAL|ALERT|EMERGENCY') 

• syntax_highlight

  sg('syntax_highlight', 'ON|OFF') 

• progress

  sg('progress', 'ON|OFF') 

• get_version

  [version] <- sg('get_version') 

• help

  sg('help')