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_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) 
```
mkl_block_norm
```
sg('mkl_block_norm', mkl_block_norm) 
```

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

Converters

set_converter
```
sg('set_converter') 
```
embed
```
[embedding]=sg('embed', target dim) 
```

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

one_class_linear_hmm_classify

[result]=sg('one_class_linear_hmm_classify')

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

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)