Our first neuronal network using TensorFlow !!!

[Antonio Linares]

Inspired by this example:
https://youtu.be/-9H_eVZdtN8

Here it is the TensorFlow neuronal network to solve it:

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfdef multilayer_perceptron( x, weights, biases ):    # Hidden layer with RELU activation    layer_1 = tf.add( tf.matmul( x, weights[ 'h1' ] ), biases[ 'b1' ] )    layer_1 = tf.nn.relu(layer_1)    # Output layer with linear activation    out_layer = tf.matmul( layer_1, weights[ 'out' ] ) + biases[ 'out' ]     return out_layersession = tf.Session()nInputs = 7  # Number of inputs to the neuronal networknHiddenPerceptrons = 12nTypes = 10  # Number of different types in the outputnLearningRate = 0.002nTrainingEpochs = 500# Input dataaInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]input = tf.placeholder( "float", shape=( None, nInputs ) )output = tf.placeholder( "float", shape=( None, nTypes ) )# Store layers weight & biasweights = { 'h1': tf.Variable(tf.random_normal( [ nInputs, nHiddenPerceptrons ] ) ),            'out': tf.Variable(tf.random_normal( [ nHiddenPerceptrons, nTypes ] ) ) }biases = { 'b1': tf.Variable( tf.random_normal( [ nHiddenPerceptrons ] ) ),           'out': tf.Variable( tf.random_normal( [ nTypes ] ) ) }# Create modelnetwork = multilayer_perceptron( input, weights, biases )loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=network, labels=output ) )optimizer = tf.train.AdamOptimizer( learning_rate = nLearningRate ).minimize( loss )init = tf.global_variables_initializer()with tf.Session() as session:   session.run( init )   # Training cycle   for epoch in range( nTrainingEpochs ) :       avg_error = 0       for n in range( len( aInputs ) ) :          cost = session.run( [ optimizer, loss ], { input: [ aInputs[ n ] ], output: [ aOutputs[ n ] ] } )          # Compute average error          avg_error += cost[ 1 ] / len( aInputs )               print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )   print( "Optimization Finished" )   # Test model on train data   print( "Testing:" )   for n in range( len( aInputs ) ) :      print( tf.argmax( network, 1 ).eval( { input: [ aInputs[ n ] ] } )[ 0 ] )

From a cmd window type:
python tf_nn.py

and you will see how the neuronal network learns (the error decreases) and finally when we test it, the right values appear!

Epoch: 0491 error= 0.010902708
Epoch: 0492 error= 0.010839775
Epoch: 0493 error= 0.010745070
Epoch: 0494 error= 0.010681662
Epoch: 0495 error= 0.010590052
Epoch: 0496 error= 0.010513857
Epoch: 0497 error= 0.010433172
Epoch: 0498 error= 0.010375975
Epoch: 0499 error= 0.010283007
Epoch: 0500 error= 0.010227598
Optimization Finished
Testing:
0
1
2
3
4
5
6
7
8
9

[Antonio Linares]

Progressively turning it into a class

It is easier to modify existing code step by step, in order to find bugs, instead of making many changes at once in the code. Python code
and TensorFlow code is tricky and changes must be implemented progressively.

This example is properly working and we are closer to have a working generic class TNeuronalNetwork that we may use from FWH

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfclass TNeuronalNetwork :       input = None   output = None   nLearningRate = 0.002   nTrainingEpochs = 500   network = None   loss = None   optimizer = None   def New( self, aTopology ) :      self.input = tf.placeholder( "float", shape=( None, aTopology[ 0 ] ) )      self.output = tf.placeholder( "float", shape=( None, aTopology[ -1 ] ) )      self.network = self.BuildNetwork( aTopology )      self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=self.network, labels=self.output ) )      self.optimizer = tf.train.AdamOptimizer( learning_rate = self.nLearningRate ).minimize( self.loss )      return self         def BuildNetwork( self, aTopology ) :      return multilayer_perceptron( self.input, aTopology[ 0 ], aTopology[ 1 ], aTopology[ -1 ] )def multilayer_perceptron( input, nInputs, nHiddenPerceptrons, nTypes ):    # Hidden layer with RELU activation    network = tf.add( tf.matmul( input, tf.Variable( tf.random_normal( [ nInputs, nHiddenPerceptrons ] ) ) ),                       tf.Variable( tf.random_normal( [ nHiddenPerceptrons ] ) ) )    network = tf.nn.relu( network )    # Output layer with linear activation    network = tf.matmul( network, tf.Variable( tf.random_normal( [ nHiddenPerceptrons, nTypes ] ) ) ) + \                         tf.Variable( tf.random_normal( [ nTypes ] ) )     return networksession = tf.Session()aInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]oNN = TNeuronalNetwork().New( [ 7, 12, 10 ] )   # 7 inputs, 12 perceptrons for a single hidden layer, 10 outputs init = tf.global_variables_initializer()with tf.Session() as session:   session.run( init )   # Training cycle   for epoch in range( oNN.nTrainingEpochs ) :       avg_error = 0       for n in range( len( aInputs ) ) :          cost = session.run( [ oNN.optimizer, oNN.loss ], { oNN.input: [ aInputs[ n ] ], oNN.output: [ aOutputs[ n ] ] } )          # Compute average error          avg_error += cost[ 1 ] / len( aInputs )               print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )   print( "Optimization Finished" )   # Test model on train data   print( "Testing:" )   for n in range( len( aInputs ) ) :      print( tf.argmax( oNN.network, 1 ).eval( { oNN.input: [ aInputs[ n ] ] } )[ 0 ] )

[Antonio Linares]

Getting simpler:

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfclass TNeuronalNetwork :       input = None   output = None   nLearningRate = 0.002   nTrainingEpochs = 500   network = None   loss = None   optimizer = None   def New( self, aTopology ) :      self.input = tf.placeholder( "float", shape=( None, aTopology[ 0 ] ) )      self.output = tf.placeholder( "float", shape=( None, aTopology[ -1 ] ) )      self.network = self.BuildNetwork( aTopology )      self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=self.network, labels=self.output ) )      self.optimizer = tf.train.AdamOptimizer( learning_rate = self.nLearningRate ).minimize( self.loss )      return self         def BuildNetwork( self, aTopology ) :      return multilayer_perceptron( self.input, aTopology )def multilayer_perceptron( input, aTopology ):    # Hidden layer with RELU activation    network = tf.add( tf.matmul( input, tf.Variable( tf.random_normal( [ aTopology[ 0 ], aTopology[ 1 ] ] ) ) ),                       tf.Variable( tf.random_normal( [ aTopology[ 1 ] ] ) ) )    network = tf.nn.relu( network )    # Output layer with linear activation    network = tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ 1 ], aTopology[ -1 ] ] ) ) ) + \                         tf.Variable( tf.random_normal( [ aTopology[ -1 ] ] ) )     return networksession = tf.Session()aInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]oNN = TNeuronalNetwork().New( [ 7, 12, 10 ] )   # 7 inputs, 12 perceptrons for a single hidden layer, 10 outputsinit = tf.global_variables_initializer()with tf.Session() as session:   session.run( init )   # Training cycle   for epoch in range( oNN.nTrainingEpochs ) :       avg_error = 0       for n in range( len( aInputs ) ) :          cost = session.run( [ oNN.optimizer, oNN.loss ], { oNN.input: [ aInputs[ n ] ], oNN.output: [ aOutputs[ n ] ] } )          # Compute average error          avg_error += cost[ 1 ] / len( aInputs )               print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )   print( "Optimization Finished" )   # Test model on train data   print( "Testing:" )   for n in range( len( aInputs ) ) :      print( tf.argmax( oNN.network, 1 ).eval( { oNN.input: [ aInputs[ n ] ] } )[ 0 ] )

[Antonio Linares]

Finally it is automatically building x amount of hidden layers!!!

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfclass TNeuronalNetwork :       input = None   output = None   nLearningRate = 0.002   nTrainingEpochs = 500   network = None   loss = None   optimizer = None   def New( self, aTopology ) :      self.input = tf.placeholder( "float", shape=( None, aTopology[ 0 ] ) )      self.output = tf.placeholder( "float", shape=( None, aTopology[ -1 ] ) )      self.network = self.BuildNetwork( aTopology )      self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=self.network, labels=self.output ) )      self.optimizer = tf.train.AdamOptimizer( learning_rate = self.nLearningRate ).minimize( self.loss )      return self         def BuildNetwork( self, aTopology ) :      return multilayer_perceptron( self.input, aTopology )def multilayer_perceptron( input, aTopology ) :   for n in range( len( aTopology ) - 2 ) :      # Hidden layers with RELU activation      if n == 0 :         network = tf.add( tf.matmul( input, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                            tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )      else :         network = tf.add( tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                            tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )      network = tf.nn.relu( network )   # Output layer with linear activation   network = tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ -2 ], aTopology[ -1 ] ] ) ) ) + \                        tf.Variable( tf.random_normal( [ aTopology[ -1 ] ] ) )    return networksession = tf.Session()aInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]oNN = TNeuronalNetwork().New( [ 7, 12, 10 ] )  # You may try with different topologies like [ 7, 12, 20, 10 ] etc.init = tf.global_variables_initializer()with tf.Session() as session:   session.run( init )   # Training cycle   for epoch in range( oNN.nTrainingEpochs ) :       avg_error = 0       for n in range( len( aInputs ) ) :          cost = session.run( [ oNN.optimizer, oNN.loss ], { oNN.input: [ aInputs[ n ] ], oNN.output: [ aOutputs[ n ] ] } )          # Compute average error          avg_error += cost[ 1 ] / len( aInputs )               print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )   print( "Optimization Finished" )   # Test model on train data   print( "Testing:" )   for n in range( len( aInputs ) ) :      print( tf.argmax( oNN.network, 1 ).eval( { oNN.input: [ aInputs[ n ] ] } )[ 0 ] )

[Antonio Linares]

Simpler and easier:

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfclass TNeuronalNetwork :       input = None   output = None   nLearningRate = 0.002   nTrainingEpochs = 500   network = None   loss = None   optimizer = None   def New( self, aTopology ) :      self.input = tf.placeholder( "float", shape=( None, aTopology[ 0 ] ) )      self.output = tf.placeholder( "float", shape=( None, aTopology[ -1 ] ) )      self.network = self.BuildNetwork( aTopology )      self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=self.network, labels=self.output ) )      self.optimizer = tf.train.AdamOptimizer( learning_rate = self.nLearningRate ).minimize( self.loss )      return self         def BuildNetwork( self, aTopology ) :      return multilayer_perceptron( self.input, aTopology )   def Train( self, aInputs, aOutputs ) :      for epoch in range( self.nTrainingEpochs ) :         avg_error = 0         for n in range( len( aInputs ) ) :            cost = session.run( [ self.optimizer, self.loss ], { self.input: [ aInputs[ n ] ], self.output: [ aOutputs[ n ] ] } )            avg_error += cost[ 1 ] / len( aInputs )                 print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )      print( "Optimization Finished" )def multilayer_perceptron( input, aTopology ) :   for n in range( len( aTopology ) - 2 ) :      # Hidden layers with RELU activation      if n == 0 :         network = tf.add( tf.matmul( input, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                            tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )      else :         network = tf.add( tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                            tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )      network = tf.nn.relu( network )   # Output layer with linear activation   network = tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ -2 ], aTopology[ -1 ] ] ) ) ) + \                        tf.Variable( tf.random_normal( [ aTopology[ -1 ] ] ) )    return networksession = tf.Session()aInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]oNN = TNeuronalNetwork().New( [ 7, 12, 10 ] )init = tf.global_variables_initializer()with tf.Session() as session:   session.run( init )   oNN.Train( aInputs, aOutputs )   # Test model on train data   print( "Testing:" )   for n in range( len( aInputs ) ) :      print( tf.argmax( oNN.network, 1 ).eval( { oNN.input: [ aInputs[ n ] ] } )[ 0 ] )

[Antonio Linares]

using an external file to simplify our code:

test.py

Code: Select all | Expand

import tf_nnaInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]oNN = tf_nn.TNeuronalNetwork().New( [ 7, 12, 10 ] )oNN.Train( aInputs, aOutputs )

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfclass TNeuronalNetwork :       input = None   output = None   nLearningRate = 0.002   nTrainingEpochs = 500   network = None   loss = None   optimizer = None   session = None   session = tf.Session()   def New( self, aTopology ) :      self.input = tf.placeholder( "float", shape=( None, aTopology[ 0 ] ) )      self.output = tf.placeholder( "float", shape=( None, aTopology[ -1 ] ) )      self.network = self.BuildNetwork( aTopology )      self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=self.network, labels=self.output ) )      self.optimizer = tf.train.AdamOptimizer( learning_rate = self.nLearningRate ).minimize( self.loss )       self.session = tf.Session()      self.session.run( tf.global_variables_initializer() )      return self         def BuildNetwork( self, aTopology ) :      return multilayer_perceptron( self.input, aTopology )   def Train( self, aInputs, aOutputs ) :      for epoch in range( self.nTrainingEpochs ) :         avg_error = 0         for n in range( len( aInputs ) ) :            cost = self.session.run( [ self.optimizer, self.loss ], { self.input: [ aInputs[ n ] ], self.output: [ aOutputs[ n ] ] } )            avg_error += cost[ 1 ] / len( aInputs )                 print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )      print( "Optimization Finished" )def multilayer_perceptron( input, aTopology ) :   for n in range( len( aTopology ) - 2 ) :      # Hidden layers with RELU activation      if n == 0 :         network = tf.add( tf.matmul( input, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                            tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )      else :         network = tf.add( tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                            tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )      network = tf.nn.relu( network )   # Output layer with linear activation   network = tf.matmul( network, tf.Variable( tf.random_normal( [ aTopology[ -2 ], aTopology[ -1 ] ] ) ) ) + \                        tf.Variable( tf.random_normal( [ aTopology[ -1 ] ] ) )    return network

[Antonio Linares]

Enhanced class and simplified example:

test.py

Code: Select all | Expand

import tf_nnaInputs = [ [ 1, 1, 1, 0, 1, 1, 1 ],  # zero                 2            [ 1, 0, 0, 0, 0, 0, 1 ],  # one               -------             [ 1, 1, 0, 1, 1, 1, 0 ],  # two            3  |     |  1            [ 1, 1, 0, 1, 0, 1, 1 ],  # three             |  4  |              [ 1, 0, 1, 1, 0, 0, 1 ],  # four              -------            [ 0, 1, 1, 1, 0, 1, 1 ],  # five              |     |              [ 0, 1, 1, 1, 1, 1, 1 ],  # six            5  |     |  7                 [ 1, 1, 0, 0, 0, 0, 1 ],  # seven             -------               [ 1, 1, 1, 1, 1, 1, 1 ],  # eight                6            [ 1, 1, 1, 1, 0, 1, 1 ] ] # nineaOutputs = [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]oNN = tf_nn.TNeuronalNetwork().New( [ 7, 12, 10 ] )oNN.Learn( aInputs, aOutputs )oNN.Calculate( aInputs )

tf_nn.py

Code: Select all | Expand

# Building a neuronal network with TensorFlowimport tensorflow as tfclass TNeuronalNetwork :       input = None   output = None   nLearningRate = 0.002   nTrainingEpochs = 500   network = None   loss = None   optimizer = None   session = None   session = tf.Session()   def New( self, aTopology ) :      self.input = tf.placeholder( "float", shape=( None, aTopology[ 0 ] ) )      self.output = tf.placeholder( "float", shape=( None, aTopology[ -1 ] ) )      self.BuildLayers( aTopology )      self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=self.network, labels=self.output ) )      self.optimizer = tf.train.AdamOptimizer( learning_rate = self.nLearningRate ).minimize( self.loss )       self.session = tf.Session()      self.session.run( tf.global_variables_initializer() )      return self         def BuildLayers( self, aTopology ) :      for n in range( len( aTopology ) - 2 ) :         # Hidden layers with RELU activation         if n == 0 :            self.network = tf.add( tf.matmul( self.input, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                                    tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )         else :            self.network = tf.add( tf.matmul( self.network, tf.Variable( tf.random_normal( [ aTopology[ n ], aTopology[ n + 1 ] ] ) ) ),                                    tf.Variable( tf.random_normal( [ aTopology[ n + 1 ] ] ) ) )         self.network = tf.nn.relu( self.network )      # Output layer with linear activation      self.network = tf.matmul( self.network, tf.Variable( tf.random_normal( [ aTopology[ -2 ], aTopology[ -1 ] ] ) ) ) + \                                tf.Variable( tf.random_normal( [ aTopology[ -1 ] ] ) )    def Learn( self, aInputs, aOutputs ) :      for epoch in range( self.nTrainingEpochs ) :         avg_error = 0         for n in range( len( aInputs ) ) :            cost = self.session.run( [ self.optimizer, self.loss ], { self.input: [ aInputs[ n ] ], self.output: [ aOutputs[ n ] ] } )            avg_error += cost[ 1 ] / len( aInputs )                 print( "Epoch:", '%04d' % ( epoch + 1 ), "error=", "{:.9f}".format( avg_error ) )      print( "Optimization Finished" )   def Calculate( self, aInputs ) :         for n in range( len( aInputs ) ) :         print( tf.argmax( self.network, 1 ).eval( { self.input: [ aInputs[ n ] ] }, session= self.session )[ 0 ] )