← machine_learning package

LarsRegression

Estimate a continuous output value from features using Least-Angle (LARS) Regression.

LARS regression is a straightfoward and principled statistical technique to learn a linear mapping between input data and desired output values from training data. LARS is very similar to LASSO, but tends to be faster when the number of features is much higher than the number of data points. LASSO regression can be used when there is a very large number of irrelevant features in the data, as along as the relevant features are relatively few. This is also called sparsity regularization. If there are very few trials, or some extensive stretches of the data exhibit only one class, the procedure used to find the optimal regularization strength (cross-validation) can fail with an error that there were too few or no trials of a given class present. LARS regression assumes that both inputs and outputs are Gaussian distributed, that is, have no or very few major statistical outliers. If the output follows a radically different distribution, for instance between 0 and 1, or nonnegative, or discrete values, then different methods may be more appropriate (for instance, classification methods for disrete values). To ameliorate the issue of outliers in the data, the raw data can be cleaned of artifacts with various artifact removal methods. To the extent that the assumptions hold true, this method is highly competitive with other (sparse) linear methods. There are several other nodes that implement similar methods that have advantages in specific circumstances. Like all machine learning methods, this method needs to be calibrated ("trained") before it can make any predictions on data. For this, the method requires training instances and associated training labels. The typical way to get such labels associated with time-series data is to make sure that a marker stream is included in the data, which is usually imported together with the data using one of the Import nodes, or received over the network alongside with the data, e.g., using the LSL Input node (with a non-empty marker query). These markers are then annotated with target labels using the Assign Targets node. To generate instances of training data for each of the training markers, one usually uses the Segmentation node to extract segments from the continuous time series around each marker. Since this machine learning method is not capable of being trained incrementally on streaming data, the method requires a data packet that contains the entire training data; this training data packet can either be accumulated online and then released in one shot using the Accumulate Calibration Data node, or it can be imported from a separate calibration recording and then spliced into the processing pipeline using the Inject Calibration Data, where it passes through the same nodes as the regular data until it reaches the machine learning node, where it is used for calibration. Once this node is calibrated, the trainable state of this node can be saved to a model file and later loaded for continued use. More Info... Version 1.1.0

Ports/Properties

data

Data to process.

• verbose name: Data
• default value: None
• port type: DataPort
• value type: Packet (can be None)
• data direction: INOUT

num_folds

Number of cross-validation folds for parameter search or instance variable to split by (LOO). Cross-validation proceeds by splitting up the data into this many blocks of trials, and then tests the method on each block. For each fold, the method is re-trained on all the other blocks, excluding the test block (therefore, the total running time is proportional to the number of folds). This is not a randomized cross-validation, but a blockwise cross-validation, which is usually the correct choice if the data stem from a time series. If there are few trials in the data, one can use a higher number here (e.g., 10) to ensure that more data is available for training. Setting this to one will yield leave-one-out CV, and if a group field was specified, then leave-one-group-out CV. A now-derepcated use was to instead pass the name of the group field directly into num_folds to achieve the same.

• verbose name: Number Of Cross-Validation Folds
• default value: 5
• port type: Port
• value type: object (can be None)

cv_group_field

Optionally a field indicating the group from which each trial is sourced. If given, then data will be split such that test sets contain unseen groups. Examples groups are SubjectID, SessionID, etc.

• verbose name: Grouping Field (Cross-Validation)
• default value:
• port type: StringPort
• value type: str (can be None)

cv_stratified

Optionally perform stratified cross-validation. This means that all the folds have the same relative percentage of trials with each label. Note that this requires labels to be quantized or binned to be meaningful.

• verbose name: Stratified Cross-Validation
• default value: False
• port type: BoolPort
• value type: bool (can be None)

num_alphas

Number of values in regularization search grid. This method determines the optimal regularization strength by testing a number of different strength values between the minimum and maximum value. The running time increases with a finer search grid, but the found solution may be slightly better regularized when using a fine grid (e.g., 100 values) instead of a coarse grid (e.g., 20 values).

• verbose name: Number Of Values In Reg. Search Grid
• default value: 100
• port type: IntPort
• value type: int (can be None)

max_iter

Maximum number of iterations. This is one of the stopping criteria to limit the compute time. The default is usually fine, and gains from increasing the number of iterations will be minimal (it can be worth experimenting with lower iteration numbers if the algorithm must finish in a fixed time budget, at a cost of potentially less accurate solutions).

• verbose name: Maximum Number Of Iterations
• default value: 500
• port type: IntPort
• value type: int (can be None)

num_jobs

Number of parallel compute jobs. This value only affects the running time and not the results. Values between 1 and twice the number of CPU cores make sense to expedite computation, but may temporarily reduce the responsiveness of the machine. The value of -1 stands for all available CPU cores.

• verbose name: Number Of Parallel Jobs
• default value: 1
• port type: IntPort
• value type: int (can be None)

verbosity

Verbosity level. Higher numbers will produce more extensive diagnostic output.

• verbose name: Verbosity Level
• default value: 0
• port type: IntPort
• value type: int (can be None)

normalize_features

Normalize features. Should only be disabled if the data comes with a predictable scale (e.g., normalized in some other way).

• verbose name: Normalize Features
• default value: True
• port type: BoolPort
• value type: bool (can be None)

include_bias

Include a bias term. If false, your features need to be centered, or include a dummy feature set to 1.

• verbose name: Include Bias Term
• default value: True
• port type: BoolPort
• value type: bool (can be None)

precompute

Precompute shared data. Precompute some shared data that is reused during parameter search. Aside from 'auto', this can be set to True or False. Auto attempts to determine the best choice automatically.

• verbose name: Precompute Shared Data
• default value: auto
• port type: Port
• value type: object (can be None)

epsilon

Degeneracy regularization. This parameter can be used to ensure that the underlying computation does not fail with singular results. Can be increased in cases where the number of features is very high compared to the number of observations.

• verbose name: Epsilon
• default value: 2.220446049250313e-16
• port type: FloatPort
• value type: float (can be None)

initialize_once

Calibrate the model only once. If set to False, then this node will recalibrate itself whenever a non-streaming data chunk is received that has both training labels and associated training instances.

• verbose name: Calibrate Only Once
• default value: True
• port type: BoolPort
• value type: bool (can be None)

dont_reset_model

Do not reset the model when the preceding graph is changed. Normally, when certain parameters of preceding nodes are being changed, the model will be reset. If this is enabled, the model will persist, but there is a chance that the model is incompatible when input data format to this node has changed.

• verbose name: Do Not Reset Model
• default value: False
• port type: BoolPort
• value type: bool (can be None)

set_breakpoint

Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

• verbose name: Set Breakpoint (Debug Only)
• default value: False
• port type: BoolPort
• value type: bool (can be None)

metadata

User-definable meta-data associated with the node. Usually reserved for technical purposes.

• verbose name: Metadata
• default value: {}
• port type: DictPort
• value type: dict (can be None)