class_docstr: Learning Vector Quantization (LVQ) algorithm.
  
  Notes
  -----
  - Input data needs to be normalized, because LVQ uses
    Euclidean distance to find clusters.
  
  - Training error is just a ratio of misclassified
    samples
  
  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``.
  
  {BaseNetwork.step}
  
  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
  
      .. code-block:: python
  
          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``.
  
  {BaseNetwork.show_epoch}
  
  {BaseNetwork.shuffle_data}
  
  {BaseNetwork.signals}
  
  {Verbose.verbose}
  
  Methods
  -------
  {BaseSkeleton.predict}
  
  {BaseSkeleton.fit}
  
  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])
code: def training_step(self):
      if self.n_updates_to_stepdrop is None:
          return self.step
  
      updates_ratio = 1 - self.n_updates / self.n_updates_to_stepdrop
      return self.minstep + (self.step - self.minstep) * updates_ratio
  
imports: from __future__ import division
  import numpy
  from neupy import init
  from neupy.utils import format_data
  from neupy.exceptions import NotTrained
  from neupy.algorithms.base import BaseNetwork
  from neupy.core.properties import IntProperty, Property, TypedListProperty, NumberProperty
label_desc: Use image node_id 2 for calling the LVQ obj's underlying member method code with example usage: obj.training_step() and returns: unknown, self