neupy.algorithms.SOFM

class neupy.algorithms.SOFM[source]

Self-Organizing Feature Map (SOFM or SOM).

Parameters:
n_inputs : int

Number of features (columns) in the input data.

n_outputs : int or None

Number of outputs. Parameter is optional in case if feature_grid was specified.

if n_outputs is None:
    n_outputs = np.prod(feature_grid)
learning_radius : int

Parameter defines radius within which we consider all neurons as neighbours to the winning neuron. The bigger the value the more neurons will be updated after each iteration.

The 0 values means that we don’t update neighbour neurons.

Defaults to 0.

std : int, float

Parameters controls learning rate for each neighbour. The further neighbour neuron from the winning neuron the smaller that learning rate for it. Learning rate scales based on the factors produced by the normal distribution with center in the place of a winning neuron and standard deviation specified as a parameter. The learning rate for the winning neuron is always equal to the value specified in the step parameter and for neighbour neurons it’s always lower.

The bigger the value for this parameter the bigger learning rate for the neighbour neurons.

Defaults to 1.

features_grid : list, tuple, None

Feature grid defines shape of the output neurons. The new shape should be compatible with the number of outputs. It means that the following condition should be true:

np.prod(features_grid) == n_outputs

SOFM implementation supports n-dimensional grids. For instance, in order to specify grid as cube instead of the regular rectangular shape we can set up options as the following:

SOFM(
    ...
    features_grid=(5, 5, 5),
    ...
)

Defaults to (n_outputs, 1).

grid_type : {rect, hexagon}

Defines connection type in feature grid. Type defines which neurons we will consider as closest to the winning neuron during the training.

  • rect - Connections between neurons will be organized in hexagonal grid.
  • hexagon - Connections between neurons will be organized in hexagonal grid. It works only for 1d or 2d grids.

Defaults to rect.

distance : {euclid, dot_product, cos}

Defines function that will be used to compute closest weight to the input sample.

  • dot_product: Just a regular dot product between data sample and network’s weights
  • euclid: Euclidian distance between data sample and network’s weights
  • cos: Cosine distance between data sample and network’s weights

Defaults to euclid.

reduce_radius_after : int or None

Every specified number of epochs learning_radius parameter will be reduced by 1. Process continues until learning_radius equal to 0.

The None value disables parameter reduction during the training.

Defaults to 100.

reduce_step_after : int or None

Defines reduction rate at which parameter step will be reduced using the following formula:

step = step / (1 + current_epoch / reduce_step_after)

The None value disables parameter reduction during the training.

Defaults to 100.

reduce_std_after : int or None

Defines reduction rate at which parameter std will be reduced using the following formula:

std = std / (1 + current_epoch / reduce_std_after)

The None value disables parameter reduction during the training.

Defaults to 100.

weight : array-like, Initializer or {init_pca, sample_from_data}

Neural network weights. Value defined manualy should have shape (n_inputs, n_outputs).

Also, it’s possible to initialized weights base on the training data. There are two options:

  • sample_from_data - Before starting the training will randomly take number of training samples equal to number of expected outputs.
  • init_pca - Before training starts SOFM will applies PCA on a covariance matrix build from the training samples. Weights will be generated based on the two eigenvectors associated with the largest eigenvalues.

Defaults to Normal().

step : float

Learning rate, defaults to 0.1.

show_epoch : int

This property controls how often the network will display information about training. It has to be defined as positive integer. For instance, number 100 mean that network shows summary at 1st, 100th, 200th, 300th … and last epochs.

Defaults to 1.

shuffle_data : bool

If it’s True than training data will be shuffled before the training. Defaults to True.

signals : dict, list or function

Function that will be triggered after certain events during the training.

verbose : bool

Property controls verbose output in terminal. The True value enables informative output in the terminal and False - disable it. Defaults to False.

Notes

  • Training data samples should have normalized features.

Examples

>>> import numpy as np
>>> from neupy import algorithms, utils
>>>
>>> utils.reproducible()
>>>
>>> data = np.array([
...     [0.1961, 0.9806],
...     [-0.1961, 0.9806],
...     [-0.5812, -0.8137],
...     [-0.8137, -0.5812],
... ])
>>>
>>> sofm = algorithms.SOFM(
...     n_inputs=2,
...     n_outputs=2,
...     step=0.1,
...     learning_radius=0
... )
>>> sofm.train(data, epochs=100)
>>> sofm.predict(data)
array([[0, 1],
       [0, 1],
       [1, 0],
       [1, 0]])

Methods

init_weights(train_data) Initialized weights besed on the input data. It works only for the init_pca and sample_from_data options. For other cases it will throw an error.
predict(X) Predicts output for the specified input.
train(X_train, epochs=100) Train neural network.
fit(*args, **kwargs) Alias to the train method.
class DistanceParameter(name, func)[source]
func[source]

Alias for field number 1

name[source]

Alias for field number 0

class GridTypeMethods(name, find_neighbours, find_step_scaler)[source]
find_neighbours[source]

Alias for field number 1

find_step_scaler[source]

Alias for field number 2

name[source]

Alias for field number 0

distance = None[source]
features_grid = None[source]
grid_type = None[source]
init_weights(X_train)[source]
learning_radius = None[source]
n_outputs = None[source]
one_training_update(X_train, y_train=None)[source]

Function would be trigger before run all training procedure related to the current epoch.

Parameters:
epoch : int

Current epoch number.

options = {'distance': Option(class_name='SOFM', value=ChoiceProperty(name="distance")), 'features_grid': Option(class_name='SOFM', value=TypedListProperty(name="features_grid")), 'grid_type': Option(class_name='SOFM', value=ChoiceProperty(name="grid_type")), 'learning_radius': Option(class_name='SOFM', value=IntProperty(name="learning_radius")), 'n_inputs': Option(class_name='BaseAssociative', value=IntProperty(name="n_inputs")), 'n_outputs': Option(class_name='SOFM', value=IntProperty(name="n_outputs")), 'reduce_radius_after': Option(class_name='SOFM', value=IntProperty(name="reduce_radius_after")), 'reduce_std_after': Option(class_name='SOFM', value=IntProperty(name="reduce_std_after")), 'reduce_step_after': Option(class_name='SOFM', value=IntProperty(name="reduce_step_after")), 'show_epoch': Option(class_name='BaseNetwork', value=IntProperty(name="show_epoch")), 'shuffle_data': Option(class_name='BaseNetwork', value=Property(name="shuffle_data")), 'signals': Option(class_name='BaseNetwork', value=Property(name="signals")), 'std': Option(class_name='SOFM', value=NumberProperty(name="std")), 'step': Option(class_name='BaseNetwork', value=NumberProperty(name="step")), 'verbose': Option(class_name='Verbose', value=VerboseProperty(name="verbose")), 'weight': Option(class_name='SOFM', value=SOFMWeightParameter(name="weight"))}[source]
predict_raw(X)[source]
reduce_radius_after = None[source]
reduce_std_after = None[source]
reduce_step_after = None[source]
std = None[source]
train(X_train, epochs=100)[source]

Method train neural network.

Parameters:
X_train : array-like
y_train : array-like or None
X_test : array-like or None
y_test : array-like or None
epochs : int

Defaults to 100.

epsilon : float or None

Defaults to None.

update_indexes(layer_output)[source]
weight = None[source]