title: MultiLayer Neural Network
body: <p>Below is the code (taken from somewhere on the internet) that I am trying to use for Multilayer neural network.</p>
  
  <pre><code>import math
  import random
  
  BIAS = -1
  
  """
  To view the structure of the Neural Network, type
  print network_name
  """
  
  class Neuron:
      def __init__(self, n_inputs ):
          self.n_inputs = n_inputs
          self.set_weights( [random.uniform(0,1) for x in range(0,n_inputs+1)] ) # +1 for bias weight
  
      def sum(self, inputs ):
          # Does not include the bias
          return sum(val*self.weights[i] for i,val in enumerate(inputs))
  
      def set_weights(self, weights ):
          self.weights = weights
  
      def __str__(self):
          return 'Weights: %s, Bias: %s' % ( str(self.weights[:-1]),str(self.weights[-1]) )
  
  class NeuronLayer:
      def __init__(self, n_neurons, n_inputs):
          self.n_neurons = n_neurons
          self.neurons = [Neuron( n_inputs ) for _ in range(0,self.n_neurons)]
  
      def __str__(self):
          return 'Layer:\n\t'+'\n\t'.join([str(neuron) for neuron in self.neurons])+''
  
  class NeuralNetwork:
      def __init__(self, n_inputs, n_outputs, n_neurons_to_hl, n_hidden_layers):
          self.n_inputs = n_inputs
          self.n_outputs = n_outputs
          self.n_hidden_layers = n_hidden_layers
          self.n_neurons_to_hl = n_neurons_to_hl
  
          # Do not touch
          self._create_network()
          self._n_weights = None
          # end
  
      def _create_network(self):
          if self.n_hidden_layers&gt;0:
              # create the first layer
              self.layers = [NeuronLayer( self.n_neurons_to_hl,self.n_inputs )]
  
              # create hidden layers
              self.layers += [NeuronLayer( self.n_neurons_to_hl,self.n_neurons_to_hl ) for _ in range(0,self.n_hidden_layers)]
  
              # hidden-to-output layer
              self.layers += [NeuronLayer( self.n_outputs,self.n_neurons_to_hl )]
          else:
              # If we don't require hidden layers
              self.layers = [NeuronLayer( self.n_outputs,self.n_inputs )]
  
      def get_weights(self):
          weights = []
  
          for layer in self.layers:
              for neuron in layer.neurons:
                  weights += neuron.weights
  
          return weights
  
      @property
      def n_weights(self):
          if not self._n_weights:
              self._n_weights = 0
              for layer in self.layers:
                  for neuron in layer.neurons:
                      self._n_weights += neuron.n_inputs+1 # +1 for bias weight
          return self._n_weights
  
      def set_weights(self, weights ):
          assert len(weights)==self.n_weights, "Incorrect amount of weights."
  
          stop = 0
          for layer in self.layers:
              for neuron in layer.neurons:
                  start, stop = stop, stop+(neuron.n_inputs+1)
                  neuron.set_weights( weights[start:stop] )
          return self
  
      def update(self, inputs ):
          assert len(inputs)==self.n_inputs, "Incorrect amount of inputs."
  
          for layer in self.layers:
              outputs = []
              for neuron in layer.neurons:
                  tot = neuron.sum(inputs) + neuron.weights[-1]*BIAS
                  outputs.append( self.sigmoid(tot) )
              inputs = outputs   
          return outputs
  
      def sigmoid(self, activation,response=1 ):
          # the activation function
          try:
              return 1/(1+math.e**(-activation/response))
          except OverflowError:
              return float("inf")
  
      def __str__(self):
          return '\n'.join([str(i+1)+' '+str(layer) for i,layer in enumerate(self.layers)])
  </code></pre>
  
  <p>My input is a text file containing multiple rows. Each row contains a data-point of dimension 16 (the first 16 elements of the row) and 17th element is the class to which the data point belongs.</p>
  
  <p><strong>Input.txt</strong></p>
  
  <pre><code>1,3,2,2,1,10,2,2,1,9,2,9,1,6,2,8,2
  2,1,3,2,2,8,7,7,5,7,6,8,2,8,3,8,4
  4,6,6,5,5,8,8,3,5,7,8,7,5,10,4,6,2
  6,9,6,11,6,7,7,8,5,9,8,8,4,9,7,9,5
  1,1,2,2,1,7,7,8,5,7,6,7,2,8,7,9,1
  3,8,5,6,4,10,6,3,6,11,4,7,3,8,2,9,3
  4,7,5,5,5,8,6,6,7,6,6,6,2,8,7,10,1
  6,10,9,8,8,11,6,2,4,9,4,6,9,6,2,8,11
  </code></pre>
  
  <p>The class is always in the range [1,11]
  After learning the input, the expected output for each data-point should be its corresponding class (it may not be right always).
  I am creating an object of NeuralNetwork class and then trying to use the update method.
  But, I am not clear how to use it properly. Please guide me how to use it for the above input.</p>