def trainArgs():
    """Arguments for SVM.train
    -  ``f=c(<kind>,<number>,[<train_fraction>],[<neg_fraction>])``
    
       Selects the fold generation method and the number of folds. If < 1.0,
       then the folds for training are generated from a subset with the
       specified size and the remaining samples are used for validation.
       Meaning of specific values: = 1 => each fold is a contiguous block =
       2 => alternating fold assignmend = 3 => random = 4 => stratified
       random = 5 => random subset ( and required)
    
       Allowed values: : integer between 1 and 5 : integer >= 1 : float >
       0.0 and <= 1.0 : float > 0.0 and < 1.0
    
       Default values: = 3 = 5 = 1.00
    
    -  ``g=c(<size>,<min_gamma>,<max_gamma>,[<scale>])``
    -  ``g=<gamma_list>``
    
       The first variant sets the size of the gamma grid and its endpoints
       and . The second variant uses for the gamma grid.
    
       Meaning of specific values: Flag indicating whether and are scaled
       based on the sample size, the dimension, and the diameter.
    
       Allowed values: : integer >= 1 : float > 0.0 : float > 0.0 : bool
    
       Default values: = 10 = 0.200 = 5.000 = 1
    
    -  ``GPU=<gpus>``
    
       Sets the number of GPUs that are going to be used. Currently, there
       is no checking whether your system actually has many GPUs. In
       addition, the number of used threads is reduced to .
    
       Allowed values: : integer between 0 and ???
    
       Default values: = 0
    
       Unfortunately, this option is not activated for the binaries you are
       currently using. Install CUDA and recompile to activate this option.
    
    -  ``h=[<level>]``
    
       Displays all help messages.
    
       Meaning of specific values: = 0 => short help messages = 1 =>
       detailed help messages
    
       Allowed values: : 0 or 1
    
       Default values: = 0
    
    -  ``i=c(<cold>,<warm>)``
    
       Selects the cold and warm start initialization methods of the solver.
       In general, this option should only be used in particular situations
       such as the implementation and testing of a new solver or when using
       the kernel cache.
    
       Meaning of specific values: For values between 0 and 6, both and have
       the same meaning taken from Steinwart et al, 'Training SVMs without
       offset', JMLR 2011. These are: 0 Sets all coefficients to zero. 1
       Sets all coefficients to C. 2 Uses the coefficients of the previous
       solution. 3 Multiplies all coefficients by C\\_new/C\\_old. 4
       Multiplies all unbounded SVs by C\\_new/C\\_old. 5 Multiplies all
       coefficients by C\\_old/C\\_new. 6 Multiplies all unbounded SVs by
       C\\_old/C\\_new.
    
       Allowed values: Depends on the solver, but the range of is always a
       subset of the range of .
    
       Default values: Depending on the solver, the (hopefully) most
       efficient method is chosen.
    
    -  ``k=c(<type>,[aux-file],[<Tr_mm_Pr>,[<size_P>],<Tr_mm>,[<size>],<Va_mm_Pr>,<Va_mm>])``
    
       Selects the type of kernel and optionally the memory model for the
       kernel matrices.
    
       Meaning of specific values: = 0 => Gaussian RBF = 1 => Poisson = 2 =>
       Experimental hierarchical Gauss kernel => Name of the file that
       contains additional information for the hierarchical Gauss kernel.
       Only this kernel type requires this option. = 0 => not contiguously
       stored matrix = 1 => contiguously stored matrix = 2 => cached matrix
       = 3 => no matrix stored => size of kernel cache in MB Here, X=Tr
       stands for the training matrix and X=Va for the validation matrix. In
       both cases, Y=Pr stands for the pre-kernel matrix, which stores the
       distances between the samples. If is set, then the other three flags
       need to be set, too. The values must only be set if a cache is
       chosen. NOTICE: Not all possible combinations are allowed.
    
       Allowed values: : integer between 0 and 2 : integer between 0 and 3 :
       integer not smaller than 1
    
       Default values: = 0 = 1 = 1024 = 512
    
    -  ``l=c(<size>,<min_lambda>,<max_lambda>,[<scale>])``
    -  ``l=c(<lambda_list>,[<interpret_as_C>])``
    
       The first variant sets the size of the lambda grid and its endpoints
       and . The second variant uses , after ordering, for the lambda grid.
    
       Meaning of specific values: Flag indicating whether is internally
       devided by the average number of samples per fold. Flag indicating
       whether the lambda list should be interpreted as a list of C values
    
       Allowed values: : integer >= 1 : float > 0.0 : float > 0.0 : bool :
       bool
    
       Default values: = 10 = 0.001 = 0.100 = 1 = 0
    
    -  ``L=c(<loss>,[<clipp>],[<neg_weight>,<pos_weight>])``
    
       Sets the loss that is used to compute empirical errors. The optional
       value specifies where the predictions are clipped during validation.
       The optional weights can only be set if specifies a loss that has
       weights.
    
       Meaning of specific values: = 0 => binary classification loss = 2 =>
       least squares loss = 3 => weighted least squares loss = 4 => pinball
       loss = 5 => your own template loss = -1.0 => clipp at smallest
       possible value (depends on labels) = 0.0 => no clipping is applied
    
       Allowed values: : values listed above : float >= -1.0 : float > 0.0 :
       float > 0.0
    
       Default values: = native loss of solver chosen by option -S = -1.000
       = set by option -W = set by option -W
    
    -  ``P=c(1,[<size>])``
    -  ``P=c(2,[<number>])``
    -  ``P=c(3,[<radius>],[<subset_size>])``
    -  ``P=c(4,[<size>],[<reduce>],[<subset_size>])``
    -  ``P=c(5,[<size>],[<ignore_fraction>],[<subset_size>],[<covers>])``
    
       Selects the working set partition method.
    
       Meaning of specific values: = 0 => do not split the working sets = 1
       => split the working sets in random chunks using maximum of each
       chunk. Default values are: = 2000 = 2 => split the working sets in
       random chunks using of chunks. Default values are: = 10 = 3 => split
       the working sets by Voronoi subsets using . If [subset\\_size] is set,
       a subset of this size is used to faster create the Voronoi partition.
       If subset\\_size == 0, the entire data set is used. Default values
       are: = 1.000 = 0 = 4 => split the working sets by Voronoi subsets
       using . The optional controls whether a heuristic to reduce the
       number of cells is used. If [subset\\_size] is set, a subset of this
       size is used to faster create the Voronoi partition. If subset\\_size
       == 0, the entire data set is used. Default values are: = 2000 = 1 =
       20000 = 5 => devide the working sets into overlapping regions of size
       . The process of creating regions is stopped when \\* samples have not
       been assigned to a region. These samples will then be assigned to the
       closest region. If is set, a subset of this size is used to find the
       regions. If subset\\_size == 0, the entire data set is used. Finally,
       controls the number of times the process of finding regions is
       repeated. Default values are:. = 2000 = 0.5 = 20000 = 1
    
       Allowed values: : integer between 0 and 5 : positive integer :
       positive integer : positive real : positive integer : bool : positive
       integer
    
       Default values: = 0
    
    -  ``r=<seed>``
    
       Initializes the random number generator with .
    
       Meaning of specific values: = -1 => a random seed based on the
       internal timer is used
    
       Allowed values: : integer between -1 and 2147483647
    
       Default values: = -1
    
    -  ``s=c(<clipp>,[<stop_eps>])``
    
       Sets the value at which the loss is clipped in the solver to . The
       optional parameter sets the threshold in the stopping criterion of
       the solver.
    
       Meaning of specific values: = -1.0 => Depending on the solver type
       clipp either at the smallest possible value (depends on labels), or
       do not clipp. = 0.0 => no clipping is applied
    
       Allowed values: : -1.0 or float >= 0.0. In addition, if > 0.0, then
       must not be smaller than the largest absolute value of the samples. :
       float > 0.0
    
       Default values: = -1.0 = 0.0010
    
    -  ``S=c(<solver>,[<NNs>])``
    
       Selects the SVM solver and the number of nearest neighbors used in
       the working set selection strategy (2D-solvers only).
    
       Meaning of specific values: = 0 => kernel rule for classification = 1
       => LS-SVM with 2D-solver = 2 => HINGE-SVM with 2D-solver = 3 =>
       QUANTILE-SVM with 2D-solver = 4 => EXPECTILE-SVM with 2D-solver = 5
       => Your SVM solver implemented in template\\_svm.\\*
    
       Allowed values: : integer between 0 and 5 : integer between 0 and 100
    
       Default values: = 2 = depends on the solver
    
    -  ``T=<threads>``
    
       Sets the number of threads that are going to be used. Each thread is
       assigned to a logical processor on the system, so that the number of
       allowed threads is bounded by the number of logical processors. On
       systems with activated hyperthreading each physical core runs one
       thread, if does not exceed the number of physical cores. Since hyper-
       threads on the same core share resources, using more threads than
       cores does usually not increase the performance significantly, and
       may even decrease it.
    
       Meaning of specific values: = 0 => 4 threads are used (all physical
       cores run one thread) = -1 => 3 threads are used (all but one of the
       physical cores run one thread)
    
       Allowed values: : integer between -1 and 4
    
       Default values: = 0
    
    -  ``w=c(<neg_weight>,<pos_weight>)``
    -  ``w=c(<min_weight>,<max_weight>,<size>,[<geometric>,<swap>])``
    -  ``w=c(<weight_list>,[<swap>])``
    
       Sets values for the weights, solvers should be trained with. For
       solvers that do not have weights this option is ignored. The first
       variants sets a pair of values. The second variant computes a
       sequence of weights of length . The third variant takes the list of
       weights.
    
       Meaning of specific values: = 1 => is the negative weight and is the
       positive weight. > 1 => many pairs are computed, where the positive
       weights are between and and the negative weights are 1 - pos\\_weight.
       Flag indicating whether the intermediate positive weights are
       geometrically or arithmetically distributed. Flag indicating whether
       the role of the positive and negative weights are interchanged.
    
       Allowed values: <... weight ...>: float > 0.0 and < 1.0 : integer > 0
       : bool : bool
    
       Default values: = 1.0 = 1.0 = 1 = 0 = 0
    
    -  ``W=<type>``
    
       Selects the working set selection method.
    
       Meaning of specific values: = 0 => take the entire data set = 1 =>
       multiclass 'all versus all' = 2 => multiclass 'one versus all' = 3 =>
       bootstrap with resamples of size
    
       Allowed values: : integer between 0 and 3
    
       Default values: = 0
    
    
    """
