tensor_stream 0.3.0 → 0.4.0

data/{test_samples → samples}/iris.rb

@@ -1,18 +1,17 @@
 require "bundler/setup"
 require 'tensor_stream'
-require 'pry-byebug'
 
 # This neural network will predict the species of an iris based on sepal and petal size
 # Dataset: http://en.wikipedia.org/wiki/Iris_flower_data_set
-
+tf = TensorStream
 rows = File.readlines(File.join("samples","iris.data")).map {|l| l.chomp.split(',') }
 
 rows.shuffle!
 
 label_encodings = {
-  "Iris-setosa"     => [1, 0, 0],
-  "Iris-versicolor" => [0, 1, 0],
-  "Iris-virginica"  => [0, 0 ,1]
+  'Iris-setosa'     => [1, 0, 0],
+  'Iris-versicolor' => [0, 1, 0],
+  'Iris-virginica'  => [0, 0, 1]
 }
 
 x_data = rows.map {|row| row[0,4].map(&:to_f) }
@@ -40,7 +39,7 @@ y_test = y_data.slice(100, 50)
 
 test_cases = []
 x_train.each_with_index do |x, index|
-  test_cases << [x, y_train[index] ]
+  test_cases << [x, y_train[index]]
 end
 
 validation_cases = []
@@ -54,11 +53,10 @@ batch_size = 128
 display_step = 100
 
 # Network Parameters
-n_hidden_1 = 32 # 1st layer number of neurons
-n_hidden_2 = 32 # 2nd layer number of neurons
+n_hidden_1 = 4 # 1st layer number of neurons
 num_classes = 3 # MNIST total classes (0-9 digits)
 num_input = 4
-training_epochs = 10
+training_epochs = 100
 
 tf = TensorStream
 
@@ -68,26 +66,20 @@ y = tf.placeholder("float", shape: [nil, num_classes], name: 'y')
 
 # Store layers weight & bias
 weights = {
-    h1: tf.variable(tf.random_normal([num_input, n_hidden_1]), name: 'h1'),
-    h2: tf.variable(tf.random_normal([n_hidden_1, n_hidden_2]), name: 'h2'),
-    out: tf.variable(tf.random_normal([n_hidden_2, num_classes]), name: 'out')
+  h1: tf.variable(tf.random_normal([num_input, n_hidden_1]), name: 'h1'),
+  out: tf.variable(tf.random_normal([num_classes, num_classes]), name: 'out')
 }
 
 biases = {
-    b1: tf.variable(tf.random_normal([n_hidden_1]), name: 'b1'),
-    b2: tf.variable(tf.random_normal([n_hidden_2]), name: 'b2'),
-    out: tf.variable(tf.random_normal([num_classes]), name: 'b_out')
+  b1: tf.variable(tf.random_normal([n_hidden_1]), name: 'b1'),
+  out: tf.variable(tf.random_normal([num_classes]), name: 'b_out')
 }
 
-
 # Create model
 def neural_net(x, weights, biases)
-    # Hidden fully connected layer with 256 neurons
-    layer_1 =  TensorStream.add(TensorStream.matmul(x, weights[:h1]), biases[:b1], name: 'layer1_add')
-    # Hidden fully connected layer with 256 neurons
-    layer_2 = TensorStream.add(TensorStream.matmul(layer_1, weights[:h2]), biases[:b2], name: 'layer2_add')
+    layer_1 = TensorStream.tanh(TensorStream.add(TensorStream.matmul(x, weights[:h1]), biases[:b1], name: 'layer1_add'))
     # Output fully connected layer with a neuron for each class
-    TensorStream.matmul(layer_2, weights[:out]) + biases[:out]
+    TensorStream.sigmoid(TensorStream.matmul(layer_1, weights[:out]) + biases[:out])
 end
 
 # Construct model
@@ -105,11 +97,13 @@ TensorStream.session do |sess|
   sess.run(init)
   puts "Testing the untrained network..."
   loss = sess.run(cost, feed_dict: { x => x_train, y => y_train })
-  puts sess.run(loss)
+  puts loss
   puts "loss before training"
   (0..training_epochs).each do |epoch|
-    sess.run(optimizer, feed_dict: { x => x_train, y => y_train })
-    loss = sess.run(cost, feed_dict: { x => x_train, y => y_train })
+    x_train.zip(y_train).each do |t_x, t_y|
+      sess.run(optimizer, feed_dict: { x => [t_x], y => [t_y] })
+      loss = sess.run(cost, feed_dict: { x => [t_x], y => [t_y] })
+    end
     puts "loss #{loss}"
   end
   loss = sess.run(cost, feed_dict: { x => x_train, y => y_train })

data/samples/logistic_regression.rb

@@ -2,7 +2,6 @@
 
 require "bundler/setup"
 require 'tensor_stream'
-require 'pry-byebug'
 
 tf = TensorStream
 

data/test_samples/raw_neural_net_sample.rb

@@ -1,7 +1,26 @@
+""" Neural Network.
+
+A 2-Hidden Layers Fully Connected Neural Network (a.k.a Multilayer Perceptron)
+implementation with TensorFlow. This example is using the MNIST database
+of handwritten digits (http://yann.lecun.com/exdb/mnist/).
+
+Links:
+    [MNIST Dataset](http://yann.lecun.com/exdb/mnist/).
+
+Author: Aymeric Damien
+Project: https://github.com/aymericdamien/TensorFlow-Examples/
+"""
 require "bundler/setup"
 require 'tensor_stream'
+require 'mnist-learn'
+require 'tensor_stream/evaluator/opencl_evaluator'
 require 'pry-byebug'
 
+tf = TensorStream
+# Import MNIST data
+mnist = Mnist.read_data_sets('/tmp/data', one_hot: true)
+
+# Parameters
 learning_rate = 0.1
 num_steps = 500
 batch_size = 128
@@ -13,42 +32,80 @@ n_hidden_2 = 256 # 2nd layer number of neurons
 num_input = 784 # MNIST data input (img shape: 28*28)
 num_classes = 10 # MNIST total classes (0-9 digits)
 
-tf = TensorStream
-
 # tf Graph input
-X = tf.placeholder("float", shape: [nil, num_input])
-Y = tf.placeholder("float", shape: [nil, num_classes])
+X = tf.placeholder(:float64, shape: [nil, num_input])
+Y = tf.placeholder(:float64, shape: [nil, num_classes])
 
 # Store layers weight & bias
-@weights = {
-    h1: tf.variable(tf.random_normal([num_input, n_hidden_1])),
-    h2: tf.variable(tf.random_normal([n_hidden_1, n_hidden_2])),
-    out: tf.variable(tf.random_normal([n_hidden_2, num_classes]))
+weights = {
+    'h1' => tf.variable(tf.random_normal([num_input, n_hidden_1]), dtype: :float64),
+    'h2' => tf.variable(tf.random_normal([n_hidden_1, n_hidden_2]), dtype: :float64),
+    'out' => tf.variable(tf.random_normal([n_hidden_2, num_classes]), dtype: :float64)
 }
 
-@biases = {
-    b1: tf.variable(tf.random_normal([n_hidden_1])),
-    b2: tf.variable(tf.random_normal([n_hidden_2])),
-    out: tf.variable(tf.random_normal([num_classes]))
+biases = {
+    'b1' => tf.variable(tf.random_normal([n_hidden_1]), dtype: :float64),
+    'b2' => tf.variable(tf.random_normal([n_hidden_2]), dtype: :float64),
+    'out' => tf.variable(tf.random_normal([num_classes]), dtype: :float64)
 }
 
 
 # Create model
-def neural_net(x)
+def neural_net(x, weights, biases)
+    tf = TensorStream
     # Hidden fully connected layer with 256 neurons
-    layer_1 =  TensorStream.add(TensorStream.matmul(x, @weights[:h1]), @biases[:b1])
+    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
     # Hidden fully connected layer with 256 neurons
-    layer_2 = TensorStream.add(TensorStream.matmul(layer_1, @weights[:h2]), @biases[:b2])
+    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
     # Output fully connected layer with a neuron for each class
-    TensorStream.matmul(layer_2, @weights[:out]) + @biases[:out]
-end
-
-def softmax(logits)
-  TensorStream.exp(logits) / TensorStream.reduce_sum(TensorStream.exp(logits))
+    tf.matmul(layer_2, weights['out']) + biases['out']
 end
 
 # Construct model
-logits = neural_net(X)
-prediction = softmax(logits)
+logits = neural_net(X, weights, biases)
+prediction = tf.nn.softmax(logits)
+
+# Define loss and optimizer
+loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
+    logits: logits, labels: Y))
+
+optimizer = TensorStream::Train::GradientDescentOptimizer.new(learning_rate)
+train_op = optimizer.minimize(loss_op)
+
+# Evaluate model
+correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
+accuracy = tf.reduce_mean(tf.cast(correct_pred, :float32))
+
+# tf.add_check_numerics_ops
+
+# Initialize the variables (i.e. assign their default value)
+init = tf.global_variables_initializer
+
+# Start training
+tf.session(:opencl_evaluator) do |sess|
+    # Run the initializer
+    sess.run(init)
+
+    (1..num_steps+1).each do |step|
+        
+        batch_x, batch_y = mnist.train.next_batch(batch_size)
+        # Run optimization op (backprop)
+        puts "...."
+        sess.run(train_op, feed_dict: { X => batch_x, Y => batch_y })
+        puts "----"
+        if step % display_step == 0 || step == 1
+        # Calculate batch loss and accuracy
+        loss, acc = sess.run([loss_op, accuracy], feed_dict: { X => batch_x, Y => batch_y})
+        print("Step " + str(step) + ", Minibatch Loss= " + \
+                "{:.4f}".format(loss) + ", Training Accuracy= " + \
+                "{:.3f}".format(acc))
+        end
+    end
+
+    print("Optimization Finished!")
 
-puts prediction.to_math
+    # Calculate accuracy for MNIST test images
+    print("Testing Accuracy:", \
+        sess.run(accuracy, feed_dict: {  X => mnist.test.images,
+                                        Y => mnist.test.labels}))
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-04 00:00:00.000000000 Z
+date: 2018-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -238,15 +238,19 @@ files:
 - ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - benchmark/benchmark.rb
+- benchmark_intel.txt
+- benchmark_nvidia.txt
 - bin/console
 - bin/setup
 - lib/tensor_stream.rb
 - lib/tensor_stream/control_flow.rb
+- lib/tensor_stream/debugging/debugging.rb
 - lib/tensor_stream/device.rb
 - lib/tensor_stream/evaluator/buffer.rb
 - lib/tensor_stream/evaluator/evaluator.rb
@@ -274,6 +278,8 @@ files:
 - lib/tensor_stream/evaluator/kernels/sigmoid_grad.cl
 - lib/tensor_stream/evaluator/kernels/sign.cl
 - lib/tensor_stream/evaluator/kernels/sin.cl
+- lib/tensor_stream/evaluator/kernels/softmax.cl
+- lib/tensor_stream/evaluator/kernels/softmax_grad.cl
 - lib/tensor_stream/evaluator/kernels/sqrt.cl
 - lib/tensor_stream/evaluator/kernels/square.cl
 - lib/tensor_stream/evaluator/kernels/sub.cl
@@ -309,17 +315,19 @@ files:
 - lib/tensor_stream/train/saver.rb
 - lib/tensor_stream/trainer.rb
 - lib/tensor_stream/types.rb
+- lib/tensor_stream/utils.rb
 - lib/tensor_stream/variable.rb
 - lib/tensor_stream/version.rb
+- samples/error.graphml
 - samples/gradient_sample.graphml
 - samples/iris.data
+- samples/iris.rb
 - samples/linear_regression.rb
 - samples/logistic_regression.rb
 - samples/nearest_neighbor.rb
 - tensor_stream.gemspec
 - test_samples/error.graphml
 - test_samples/gradient_sample.graphml
-- test_samples/iris.rb
 - test_samples/raw_neural_net_sample.rb
 - test_samples/test.py
 - test_samples/test2.py