neupy.algorithms.LVQ

class neupy.algorithms.LVQ[source]

Learning Vector Quantization (LVQ) algorithm.

Parameters:
n_inputs : int

Number of input units. It should be equal to the number of features in the input data set.

n_subclasses : int, None

Defines total number of subclasses. Values should be greater or equal to the number of classes. None will set up number of subclasses equal to the number of classes. Defaults to None (or the same as n_classes).

n_classes : int

Number of classes in the data set.

prototypes_per_class : list, None

Defines number of prototypes per each class. For instance, if n_classes=3 and n_subclasses=8 then there are can be 3 subclasses for the first class, 3 for the second one and 2 for the third one (3 + 3 + 2 == 8). The following example can be specified as prototypes_per_class=[3, 3, 2].

There are two rules that apply to this parameter:

  1. sum(prototypes_per_class) == n_subclasses
  2. len(prototypes_per_class) == n_classes

The None value will distribute approximately equal number of subclasses per each class. It’s approximately, because, for cases, when n_subclasses % n_classes != 0 there is no way to distribute equal number of subclasses per each class.

Defaults to None.

step : float

Learning rate, defaults to 0.1.

n_updates_to_stepdrop : int or None

If this options is not equal to None then after every update LVQ reduces step size and do it until number of applied updates would reach the n_updates_to_stepdrop value. The minimum possible step size defined in the minstep parameter.

Be aware that number of updates is not the same as number of epochs. LVQ applies update after each propagated sample through the network. Relations between this parameter and maximum number of epochs is following

n_updates_to_stepdrop = n_samples * n_max_epochs

If parameter equal to None then step size wouldn’t be reduced after each update.

Defaults to None.

minstep : float

Step size would never be lower than this value. This property useful only in case if n_updates_to_stepdrop is not None. Defaults to 1e-5.

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

  • Input data needs to be normalized, because LVQ uses Euclidean distance to find clusters.
  • Training error is just a ratio of misclassified samples

Examples

>>> import numpy as np
>>> from neupy import algorithms
>>>
>>> X = np.array([[0, 0], [0, 1], [1, 0], [1, 1], [2, 2], [1, 2]])
>>> y = np.array([0, 0, 0, 1, 1, 1])
>>>
>>> lvqnet = algorithms.LVQ(n_inputs=2, n_classes=2)
>>> lvqnet.train(X, y, epochs=100)
>>> lvqnet.predict([[2, 1], [-1, -1]])
array([1, 0])

Methods

predict(X) Predicts output for the specified input.
fit(*args, **kwargs) Alias to the train method.
minstep = None[source]
n_classes = None[source]
n_inputs = None[source]
n_subclasses = None[source]
n_updates_to_stepdrop = None[source]
one_training_update(X_train, y_train)[source]

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

Parameters:
epoch : int

Current epoch number.
options = {'minstep': Option(class_name='LVQ', value=NumberProperty(name="minstep")), 'n_classes': Option(class_name='LVQ', value=IntProperty(name="n_classes")), 'n_inputs': Option(class_name='LVQ', value=IntProperty(name="n_inputs")), 'n_subclasses': Option(class_name='LVQ', value=IntProperty(name="n_subclasses")), 'n_updates_to_stepdrop': Option(class_name='LVQ', value=IntProperty(name="n_updates_to_stepdrop")), 'prototypes_per_class': Option(class_name='LVQ', value=TypedListProperty(name="prototypes_per_class")), '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")), 'step': Option(class_name='BaseNetwork', value=NumberProperty(name="step")), 'verbose': Option(class_name='Verbose', value=VerboseProperty(name="verbose")), 'weight': Option(class_name='LVQ', value=Property(name="weight"))}[source]
predict(X)[source]
prototypes_per_class = None[source]
train(X_train, y_train, *args, **kwargs)[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.
training_step[source]
weight = None[source]