Static Command Line Interface Function Reference

Features

• pr_loqo

  [results]=sg('pr_loqo', 'Var1', Var1, 'Var2', Var2) 

• 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>]) 

• add_multiple_features

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

• add_dotfeatures

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

• set_features

  sg('set_features', 'TRAIN|TEST', features[, DNABINFILE|<ALPHABET>][, [from_position_list|slide_window], window size, [position_list|shift], skip) 

• 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]) 

• 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_normalization

  sg('set_kernel_normalization', IDENTITY|AVGDIAG|SQRTDIAG|FIRSTELEMENT|VARIANCE|ZEROMEANCENTER, size[, kernel-specific parameters]) 

• 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, 'TRAIN|TEST') 

• get_kernel_matrix

  [K]]=sg('get_kernel_matrix', ['TRAIN|TEST') 

• 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) 

• get_dotfeature_weights_combined

  [W]=sg('get_dotfeature_weights_combined', 'TRAIN|TEST') 

• set_dotfeature_weights_combined

  sg('set_dotfeature_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', '0|1') 

• set_kernel_optimization_type

  sg('set_kernel_optimization_type', 'FASTBUTMEMHUNGRY|SLOWBUTMEMEFFICIENT') 

• set_solver

  sg('set_solver', 'AUTO|CPLEX|GLPK|INTERNAL') 

• set_constraint_generator

  sg('set_constraint_generator', 'LIBSVM_ONECLASS|LIBSVM_MULTICLASS|LIBSVM|SVMLIGHT|LIGHT|SVMLIGHT_ONECLASS|GPBTSVM|MPDSVM|GNPPSVM|GMNPSVM') 

• set_prior_probs

  sg('set_prior_probs', 'pos probs, neg_probs') 

• set_prior_probs_from_labels

  sg('set_prior_probs_from_labels', 'labels') 

• 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', [index in case of MultiClassSVM]) 

• get_clustering

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

• new_svm

  sg('new_svm', 'LIBSVM_ONECLASS|LIBSVM_MULTICLASS|LIBSVM|SVMLIGHT|LIGHT|LIGHT_ONECLASS|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|LIGHT_ONECLASS|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_classifier

  [filename, type]=sg('load_classifier') 

• save_classifier

  sg('save_classifier', filename) 

• get_num_svms

  [number of SVMs in MultiClassSVM]=sg('get_num_svms') 

• get_svm

  [bias, alphas]=sg('get_svm', [index in case of MultiClassSVM]) 

• set_svm

  sg('set_svm', bias, alphas) 

• set_linear_classifier

  sg('set_linear_classifier', bias, w) 

• get_svm_objective

  [objective]=sg('get_svm_objective') 

• compute_svm_primal_objective

  [objective]=sg('compute_svm_primal_objective') 

• compute_svm_dual_objective

  [objective]=sg('compute_svm_dual_objective') 

• compute_mkl_primal_objective

  [objective]=sg('compute_mkl_primal_objective') 

• compute_mkl_dual_objective

  [objective]=sg('compute_mkl_dual_objective') 

• compute_relative_mkl_duality_gap

  [gap]=sg('compute_relative_mkl_duality_gap') 

• compute_absolute_mkl_duality_gap

  [gap]=sg('compute_absolute_mkl_duality_gap') 

• 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_nu

  sg('svm_nu', nu) 

• mkl_parameters

  sg('mkl_parameters', weight_epsilon, C_MKL [, mkl_norm ]) 

• elasticnet_lambda

  sg('elasticnet_lambda', ent_lambda) 

• svm_max_train_time

  sg('svm_max_train_time', max_train_time) 

• 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) 

• mkl_use_interleaved_optimization

  sg('mkl_use_interleaved_optimization', enable_interleaved_optimization) 

• krr_tau

  sg('krr_tau', tau) 

Preprocessors

• add_preproc

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

• del_preproc

  sg('del_preproc') 

• 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) 

• set_feature_matrix_sparse

  sg('set_feature_matrix_sparse', sp1, sp2) 

• 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') 

Signals

• signals_set_model

  sg('signals_set_model', arg1) 

• signals_set_positions

  sg('signals_set_positions', positions) 

• signals_set_labels

  sg('signals_set_labels', labels) 

• signals_set_split

  sg('signals_set_split', split) 

• signals_set_train_mask

  sg('signals_set_train_mask', ) 

• signals_add_feature

  sg('signals_add_feature', feature) 

• signals_add_kernel

  sg('signals_add_kernel', kernelparam) 

• signals_run

  sg('signals_run', arg1) 

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_subkernels

  sg('precompute_subkernels') 

• precompute_content_svms

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

• get_lin_feat

  [lin_feat]=sg('get_lin_feat') 

• set_lin_feat

  sg('set_lin_feat', lin_feat) 

• init_dyn_prog

  sg('init_dyn_prog', num_svms) 

• clean_up_dyn_prog

  sg('clean_up_dyn_prog') 

• init_intron_list

  sg('init_intron_list', start_positions, end_positions, quality) 

• precompute_tiling_features

  sg('precompute_tiling_features', intensities, probe_pos, tiling_plif_ids) 

• long_transition_settings

  sg('long_transition_settings', use_long_transitions, threshold, max_len) 

• 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]) 

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) 

• init_random

  sg('init_random', value_to_initialize_RNG_with) 

• 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') 

• whos

  sg('whos') 

• run_python

  [results]=sg('run_python', 'Var1', Var1, 'Var2', Var2,..., python_function) 

• run_octave

  [results]=sg('run_octave', 'Var1', Var1, 'Var2', Var2,..., octave_function) 

• run_r

  [results]=sg('run_r', 'Var1', Var1, 'Var2', Var2,..., r_function)