pyoselm.elm.ELMClassifier¶

class pyoselm.elm.ELMClassifier(n_hidden=20, alpha=0.5, rbf_width=1.0, activation_func='sigmoid', activation_args=None, user_components=None, regressor=None, binarizer=LabelBinarizer(neg_label=- 1), random_state=None)[source]¶

Classification model based on Extreme Learning Machine.

An Extreme Learning Machine (ELM) is a single layer feedforward network with a random hidden layer components and ordinary linear least squares fitting of the hidden->output weights by default. [1][2]

ELMClassifier is an ELMRegressor subclass that first binarizes the data, then uses the superclass to compute the decision function that is then unbinarized to yield the prediction.

The params for the RandomLayer used in the input transform are exposed in the ELMClassifier constructor.

Parameters

n_hidden (int, optional (default=20)) – Number of units to generate in the SimpleRandomLayer
activation_func ({callable, string} optional (default='sigmoid')) –
Function used to transform input activation

It must be one of ‘tanh’, ‘sine’, ‘tribas’, ‘inv_tribase’, ‘sigmoid’, ‘hardlim’, ‘softlim’, ‘gaussian’, ‘multiquadric’, ‘inv_multiquadric’ or a callable. If a callable is given, it will be used to compute the hidden unit activations.
activation_args (dictionary, optional (default=None)) – Supplies keyword arguments for a callable activation_func
random_state (int, RandomState instance or None (default=None)) – Control the pseudo random number generator used to generate the hidden unit weights at fit time.

`classes_`

Array of class labels

Type: numpy array of shape [n_classes]

Examples

>>> from pyoselm import ELMClassifier
>>> from sklearn.datasets import load_digits
>>> X, y = load_digits(n_class=10, return_X_y=True)
>>> model = ELMClassifier(n_hidden=50,
...                       activation_func="sigmoid",
...                       random_state=123)
>>> model.fit(X, y)
ELMClassifier(activation_func='sigmoid', n_hidden=50, random_state=123)
>>> model.score(X, y)
0.8241513633834168

See also

RandomLayer, RBFRandomLayer, MLPRandomLayer, GenELMRegressor, GenELMClassifier, ELMClassifier

References

1

http://www.extreme-learning-machines.org

2

G.-B. Huang, Q.-Y. Zhu and C.-K. Siew, “Extreme Learning Machine: Theory and Applications”, Neurocomputing, vol. 70, pp. 489-501,

__init__(n_hidden=20, alpha=0.5, rbf_width=1.0, activation_func='sigmoid', activation_args=None, user_components=None, regressor=None, binarizer=LabelBinarizer(neg_label=- 1), random_state=None)[source]¶: Initialize self. See help(type(self)) for accurate signature.

Methods

`__init__`([n_hidden, alpha, rbf_width, …])	Initialize self.
`decision_function`(X)	This function return the decision function values related to each class on an array of test vectors X.
`fit`(X, y)	Fit the model using X, y as training data.
`get_params`([deep])	Get parameters for this estimator.
`predict`(X)	Predict values using the model
`predict_proba`(X)	Predict probability values using the model
`score`(X, y, **kwargs)	Force use of accuracy score since it doesn’t inherit from ClassifierMixin
`set_params`(**params)	Set the parameters of this estimator.

Attributes

is_fitted

Check if model was fitted

decision_function(X)[source]¶

This function return the decision function values related to each class on an array of test vectors X.

Parameters: X (array-like of shape [n_samples, n_features]) –
Returns: C – Decision function values related to each class, per sample. In the two-class case, the shape is [n_samples,]
Return type: array of shape [n_samples, n_classes] or [n_samples,]

fit(X, y)[source]¶

Fit the model using X, y as training data.

Parameters

X ({array-like, sparse matrix} of shape [n_samples, n_features]) – Training vectors, where n_samples is the number of samples and n_features is the number of features.
y (array-like of shape [n_samples, n_outputs]) – Target values (class labels in classification, real numbers in regression)

Returns

self – Returns an instance of self.

Return type

object

get_params(deep=True)¶

Get parameters for this estimator.

Parameters: deep (bool, default=True) – If True, will return the parameters for this estimator and contained subobjects that are estimators.
Returns: params – Parameter names mapped to their values.
Return type: dict

property is_fitted¶

Check if model was fitted

Returns
Return type: boolean, True if model is fitted

predict(X)[source]¶

Predict values using the model

Parameters: X ({array-like, sparse matrix} of shape [n_samples, n_features]) –
Returns: C – Predicted values.
Return type: numpy array of shape [n_samples, n_outputs]

predict_proba(X)[source]¶

Predict probability values using the model

Parameters: X ({array-like, sparse matrix} of shape [n_samples, n_features]) –
Returns: P – Predicted probability values.
Return type: numpy array of shape [n_samples, n_outputs]

score(X, y, **kwargs)[source]¶: Force use of accuracy score since it doesn’t inherit from ClassifierMixin

set_params(**params)¶

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as Pipeline). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Parameters: **params (dict) – Estimator parameters.
Returns: self – Estimator instance.
Return type: estimator instance