class_docstr: Growing Neural Gas (GNG) algorithm.
  
  Current algorithm has two modifications that hasn't been mentioned
  in the paper, but they help to speed up training.
  
  - The ``n_start_nodes`` parameter provides possibility to increase
    number of nodes during initialization step. It's useful when
    algorithm takes a lot of time building up large amount of neurons.
  
  - The ``min_distance_for_update`` parameter allows to speed up
    training when some data samples has neurons very close to them. The
    ``min_distance_for_update`` parameter controls threshold for the
    minimum distance for which we will want to update weights.
  
  Parameters
  ----------
  n_inputs : int
      Number of features in each sample.
  
  n_start_nodes : int
      Number of nodes that algorithm generates from the data during
      the initialization step. Defaults to ``2``.
  
  step : float
      Step (learning rate) for the neuron winner. Defaults to ``0.2``.
  
  neighbour_step : float
      Step (learning rate) for the neurons that connected via edges
      with neuron winner. This value typically has to be smaller than
      ``step`` value. Defaults to ``0.05``.
  
  max_edge_age : int
      It means that if edge won't be updated for ``max_edge_age`` iterations
      than it would be removed. The larger the value the more updates we
      allow to do before removing edge. Defaults to ``100``.
  
  n_iter_before_neuron_added : int
      Each ``n_iter_before_neuron_added`` weight update algorithm add new
      neuron. The smaller the value the more frequently algorithm adds
      new neurons to the network. Defaults to ``1000``.
  
  error_decay_rate : float
      This error decay rate would be applied to every neuron in the
      graph after each training iteration. It ensures that old errors
      will be reduced over time. Defaults to ``0.995``.
  
  after_split_error_decay_rate : float
      This decay rate reduces error for neurons with largest errors
      after algorithm added new neuron. This value typically lower than
      ``error_decay_rate``. Defaults to ``0.5``.
  
  max_nodes : int
      Maximum number of nodes that would be generated during the training.
      This parameter won't stop training when maximum number of nodes
      will be exceeded. Defaults to ``1000``.
  
  min_distance_for_update : float
      Parameter controls for which neurons we want to apply updates.
      In case if euclidean distance between data sample and closest
      neurons will be less than the ``min_distance_for_update`` value than
      update would be skipped for this data sample. Setting value to zero
      will disable effect provided by this parameter. Defaults to ``0``.
  
  {BaseNetwork.show_epoch}
  
  {BaseNetwork.shuffle_data}
  
  {BaseNetwork.signals}
  
  {Verbose.verbose}
  
  Methods
  -------
  train(X_train, epochs=100)
      Network learns topological structure of the data. Learned
      structure will be stored in the ``graph`` attribute.
  
  {BaseSkeleton.fit}
  
  initialize_nodes(data)
      Network initializes nodes randomly sampling ``n_start_nodes``
      from the data. It would be applied automatically before
      the training in case if graph is empty.
  
      Note: Node re-initialization can reset network.
  
  Notes
  -----
  - Unlike other algorithms this network doesn't make predictions.
    Instead, it learns topological structure of the data in form of
    the graph. After that training, structure of the network can be
    extracted from the ``graph`` attribute.
  
  - In order to speed up training, it might be useful to increase
    the ``n_start_nodes`` parameter.
  
  - During the training it happens that nodes learn topological
    structure of one part of the data better than the other, mostly
    because of the different data sample density in different places.
    Increasing the ``min_distance_for_update`` can speed up training
    ignoring updates for the neurons that very close to the data sample.
    (below specified ``min_distance_for_update`` value). Training can be
    stopped in case if none of the neurons has been updated during
    the training epoch.
  
  Attributes
  ----------
  graph : NeuralGasGraph instance
      This attribute stores all neurons and connections between them
      in the form of undirected graph.
  
  {BaseNetwork.Attributes}
  
  Examples
  --------
  >>> from neupy import algorithms
  >>> from sklearn.datasets import make_blobs
  >>>
  >>> data, _ = make_blobs(
  ...     n_samples=1000,
  ...     n_features=2,
  ...     centers=2,
  ...     cluster_std=0.4,
  ... )
  >>>
  >>> neural_gas = algorithms.GrowingNeuralGas(
  ...     n_inputs=2,
  ...     shuffle_data=True,
  ...     verbose=True,
  ...     max_edge_age=10,
  ...     n_iter_before_neuron_added=50,
  ...     max_nodes=100,
  ... )
  >>> neural_gas.graph.n_nodes
  100
  >>> len(neural_gas.graph.edges)
  175
  >>> edges = list(neural_gas.graph.edges.keys())
  >>> neuron_1, neuron_2 = edges[0]
  >>>
  >>> neuron_1.weight
  array([[-6.77166299,  2.4121606 ]])
  >>> neuron_2.weight
  array([[-6.829309  ,  2.27839633]])
  
  References
  ----------
  [1] A Growing Neural Gas Network Learns Topologies, Bernd Fritzke
code: def initialize_nodes(self, data):
      self.graph = NeuralGasGraph()
  
      for sample in sample_data_point(data, n=self.n_start_nodes):
          self.graph.add_node(NeuronNode(sample.reshape(1, -1)))
  
imports: from operator import attrgetter
  import numpy
  from neupy.utils import format_data
  from neupy.exceptions import StopTraining
  from neupy.algorithms.base import BaseNetwork
  from neupy.core.properties import NumberProperty, ProperFractionProperty, IntProperty
label_desc: Use image node_id 3 for calling the GrowingNeuralGas obj's underlying member method code with example usage: obj.initialize_nodes(data) without return types