neupy.algorithms.SOFM

class neupy.algorithms.SOFM

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: Euclidean 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 based 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)

func

Alias for field number 1

name

Alias for field number 0

class GridTypeMethods(name, find_neighbours, find_step_scaler)

find_neighbours

Alias for field number 1

find_step_scaler

Alias for field number 2

name

Alias for field number 0

distance = None

features_grid = None

grid_type = None

init_weights(X_train)

learning_radius = None

n_outputs = None

one_training_update(X_train, y_train=None)

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"))}

predict_raw(X)

reduce_radius_after = None

reduce_std_after = None

reduce_step_after = None

std = None

train(X_train, epochs=100)

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)

weight = None

Search

Install NeuPy

pip install neupy

Learn more about NeuPy reading tutorials and documentation.

Issues and feature requests

If you find a bug or want to suggest a new feature feel free to create an issue on Github