mvpa2.clfs.lars.LARS

Inheritance diagram of LARS

class mvpa2.clfs.lars.LARS(model_type='lasso', trace=False, normalize=True, intercept=True, max_steps=None, use_Gram=False, **kwargs)

Least angle regression (LARS).

LARS is the model selection algorithm from:

Bradley Efron, Trevor Hastie, Iain Johnstone and Robert Tibshirani, Least Angle Regression Annals of Statistics (with discussion) (2004) 32(2), 407-499. A new method for variable subset selection, with the lasso and ‘epsilon’ forward stagewise methods as special cases.

Similar to SMLR, it performs a feature selection while performing classification, but instead of starting with all features, it starts with none and adds them in, which is similar to boosting.

This learner behaves more like a ridge regression in that it returns prediction values and it treats the training labels as continuous.

In the true nature of the PyMVPA framework, this algorithm is actually implemented in R by Trevor Hastie and wrapped via RPy. To make use of LARS, you must have R and RPy installed as well as the LARS contributed package. You can install the R and RPy with the following command on Debian-based machines:

sudo aptitude install python-rpy python-rpy-doc r-base-dev

You can then install the LARS package by running R as root and calling:

install.packages()

Notes

Available conditional attributes:

  • calling_time+: Time (in seconds) it took to call the node
  • estimates+: Internal classifier estimates the most recent predictions are based on
  • predicting_time+: Time (in seconds) which took classifier to predict
  • predictions+: Most recent set of predictions
  • raw_results: Computed results before invoking postproc. Stored only if postproc is not None.
  • trained_dataset: The dataset it has been trained on
  • trained_nsamples+: Number of samples it has been trained on
  • trained_targets+: Set of unique targets it has been trained on
  • training_stats: Confusion matrix of learning performance
  • training_time+: Time (in seconds) it took to train the learner

(Conditional attributes enabled by default suffixed with +)

Methods

clone() Create full copy of the classifier.
generate(ds) Yield processing results.
get_postproc() Returns the post-processing node or None.
get_sensitivity_analyzer(**kwargs) Returns a sensitivity analyzer for LARS.
get_space() Query the processing space name of this node.
is_trained([dataset]) Either classifier was already trained.
predict(obj, data, *args, **kwargs)
repredict(obj, data, *args, **kwargs)
reset()
retrain(dataset, **kwargs) Helper to avoid check if data was changed actually changed Useful if just some aspects of classifier were changed since its previous training.
set_postproc(node) Assigns a post-processing node Set to None to disable postprocessing.
set_space(name) Set the processing space name of this node.
summary() Providing summary over the classifier
train(ds) The default implementation calls _pretrain(), _train(), and finally _posttrain().
untrain() Reverts changes in the state of this node caused by previous training

Initialize LARS.

See the help in R for further details on the following parameters:

Parameters:

model_type : string

Type of LARS to run. Can be one of (‘lasso’, ‘lar’, ‘forward.stagewise’, ‘stepwise’).

trace : boolean

Whether to print progress in R as it works.

normalize : boolean

Whether to normalize the L2 Norm.

intercept : boolean

Whether to add a non-penalized intercept to the model.

max_steps : None or int

If not None, specify the total number of iterations to run. Each iteration adds a feature, but leaving it none will add until convergence.

use_Gram : boolean

Whether to compute the Gram matrix (this should be false if you have more features than samples.)

enable_ca : None or list of str

Names of the conditional attributes which should be enabled in addition to the default ones

disable_ca : None or list of str

Names of the conditional attributes which should be disabled

auto_train : bool

Flag whether the learner will automatically train itself on the input dataset when called untrained.

force_train : bool

Flag whether the learner will enforce training on the input dataset upon every call.

space: str, optional :

Name of the ‘processing space’. The actual meaning of this argument heavily depends on the sub-class implementation. In general, this is a trigger that tells the node to compute and store information about the input data that is “interesting” in the context of the corresponding processing in the output dataset.

postproc : Node instance, optional

Node to perform post-processing of results. This node is applied in __call__() to perform a final processing step on the to be result dataset. If None, nothing is done.

descr : str

Description of the instance

Methods

clone() Create full copy of the classifier.
generate(ds) Yield processing results.
get_postproc() Returns the post-processing node or None.
get_sensitivity_analyzer(**kwargs) Returns a sensitivity analyzer for LARS.
get_space() Query the processing space name of this node.
is_trained([dataset]) Either classifier was already trained.
predict(obj, data, *args, **kwargs)
repredict(obj, data, *args, **kwargs)
reset()
retrain(dataset, **kwargs) Helper to avoid check if data was changed actually changed Useful if just some aspects of classifier were changed since its previous training.
set_postproc(node) Assigns a post-processing node Set to None to disable postprocessing.
set_space(name) Set the processing space name of this node.
summary() Providing summary over the classifier
train(ds) The default implementation calls _pretrain(), _train(), and finally _posttrain().
untrain() Reverts changes in the state of this node caused by previous training
get_sensitivity_analyzer(**kwargs)

Returns a sensitivity analyzer for LARS.

weights

NeuroDebian

NITRC-listed