tensor_stream 1.0.0 → 1.0.1

data/samples/{iris.rb → neural_networks/iris.rb}

@@ -1,34 +1,34 @@
 require "bundler/setup"
-require 'tensor_stream'
-# require 'tensor_stream/evaluator/opencl/opencl_evaluator'
+require "tensor_stream"
+# require 'tensor_stream/opencl'
 
 # 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 = File.readlines("samples/datasets/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) }
+x_data = rows.map {|row| row[0, 4].map(&:to_f) }
 y_data = rows.map {|row| label_encodings[row[4]] }
 
 # Normalize data values before feeding into network
-normalize = -> (val, high, low) {  (val - low) / (high - low) } # maps input to float between 0 and 1
+normalize = ->(val, high, low) { (val - low) / (high - low) } # maps input to float between 0 and 1
 
-columns = (0..3).map do |i|
+columns = (0..3).map { |i|
   x_data.map {|row| row[i] }
-end
+}
 
 x_data.map! do |row|
   row.map.with_index do |val, j|
     max, min = columns[j].max, columns[j].min
-    normalize.(val, max, min)
+    normalize.call(val, max, min)
   end
 end
 
@@ -45,11 +45,9 @@ end
 
 validation_cases = []
 x_test.each_with_index do |x, index|
-  validation_cases << [x, y_test[index] ]
+  validation_cases << [x, y_test[index]]
 end
 
-
-
 def init_weights(shape)
   # Weight initialization
   TensorStream.random_normal(shape, stddev: 0.1).var
@@ -58,8 +56,8 @@ end
 def forwardprop(x, w_1, w_2)
   # Forward-propagation.
   # IMPORTANT: yhat is not softmax since TensorFlow's softmax_cross_entropy_with_logits() does that internally.
-  h  = TensorStream.nn.sigmoid(x.matmul w_1)  # The \sigma function
-  h.matmul w_2  # The \varphi function
+  h = TensorStream.nn.sigmoid(x.matmul(w_1)) # The \sigma function
+  h.matmul w_2 # The \varphi function
 end
 
 x_size = x_train[0].size
@@ -81,15 +79,15 @@ cost    = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels: y, logi
 
 # updates =  TensorStream::Train::GradientDescentOptimizer.new(0.01).minimize(cost)
 # updates =  TensorStream::Train::MomentumOptimizer.new(0.01, 0.5, use_nesterov: true).minimize(cost)
-updates =  TensorStream::Train::RMSPropOptimizer.new(0.01).minimize(cost)
+updates = TensorStream::Train::RMSPropOptimizer.new(0.01).minimize(cost)
 
 # Run SGD
 sess = tf.session
 init = tf.global_variables_initializer
 sess.run(init)
-loss = sess.run(cost, feed_dict: { X => x_test, y => y_test })
+loss = sess.run(cost, feed_dict: {X => x_test, y => y_test})
 puts "loss test data set #{loss}"
-loss = sess.run(cost, feed_dict: { X => x_train, y => y_train })
+loss = sess.run(cost, feed_dict: {X => x_train, y => y_train})
 puts "Testing the untrained network..."
 puts loss
 start_time = Time.now
@@ -98,12 +96,12 @@ start_time = Time.now
     sess.run(updates, feed_dict: {X => [x_train[i]], y => [y_train[i]]})
   end
 
-  loss = sess.run(cost, feed_dict: { X => x_train, y => y_train })
+  loss = sess.run(cost, feed_dict: {X => x_train, y => y_train})
   puts "epoch: #{epoch}, loss #{loss}"
 end
 
-loss = sess.run(cost, feed_dict: { X => x_train, y => y_train })
+loss = sess.run(cost, feed_dict: {X => x_train, y => y_train})
 puts "loss after training #{loss}"
-loss = sess.run(cost, feed_dict: { X => x_test, y => y_test })
+loss = sess.run(cost, feed_dict: {X => x_test, y => y_test})
 puts "loss test data set #{loss}"
-puts("time elapsed ", Time.now.to_i - start_time.to_i)
+puts("time elapsed ", Time.now.to_i - start_time.to_i)

data/samples/{mnist_data.rb → neural_networks/mnist_data.rb}

@@ -7,17 +7,18 @@
 #   mnist-learn gem
 #   opencl_ruby_ffi gem
 require "bundler/setup"
-require 'tensor_stream'
-require 'mnist-learn'
+require "tensor_stream"
+require "mnist-learn"
 
 # Enable OpenCL hardware accelerated computation, not using OpenCL can be very slow
-# require 'tensor_stream/opencl'
+# gem install tensor_stream-opencl
+require 'tensor_stream/opencl'
 
 tf = TensorStream
 
 # Import MNIST data
 puts "downloading minst data"
-mnist = Mnist.read_data_sets('/tmp/data', one_hot: true)
+mnist = Mnist.read_data_sets("/tmp/data", one_hot: true)
 puts "downloading finished"
 
 x = Float.placeholder shape: [nil, 784]
@@ -45,19 +46,18 @@ sess.run(init)
 (0...1000).each do |i|
   # load batch of images and correct answers
   batch_x, batch_y = mnist.train.next_batch(100)
-  train_data = { x => batch_x, y_ => batch_y }
+  train_data = {x => batch_x, y_ => batch_y}
 
   # train
   sess.run(train_step, feed_dict: train_data)
-  if (i % 10 == 0)
+  if i % 10 == 0
     # success? add code to print it
     a, c = sess.run([accuracy, cross_entropy], feed_dict: train_data)
     puts "#{i} train accuracy #{a}, error #{c}"
 
     # success on test data?
-    test_data = { x => mnist.test.images, y_ => mnist.test.labels }
+    test_data = {x => mnist.test.images, y_ => mnist.test.labels}
     a, c = sess.run([accuracy, cross_entropy], feed_dict: test_data)
     puts " test accuracy #{a}, error #{c}"
   end
 end
-

data/samples/neural_networks/raw_neural_net_sample.rb

@@ -0,0 +1,112 @@
+""" 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/
+
+The mnist-learn gem is required as well as an OpenCL compatible device with drivers correctly installed
+"""
+require "bundler/setup"
+require "tensor_stream"
+require "mnist-learn"
+
+tf = TensorStream
+# Import MNIST data
+puts "downloading minst data"
+mnist = Mnist.read_data_sets("/tmp/data", one_hot: true)
+puts "downloading finished"
+
+# Parameters
+learning_rate = 0.001
+momentum = 0.01
+num_steps = 100
+batch_size = 128
+display_step = 5
+
+# Network Parameters
+n_hidden_1 = 256 # 1st layer number of neurons
+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 Graph input
+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]), dtype: :float64, name: "h1"),
+  "h2" => tf.variable(tf.random_normal([n_hidden_1, n_hidden_2]), dtype: :float64, name: "h2"),
+  "out" => tf.variable(tf.random_normal([n_hidden_2, num_classes]), dtype: :float64, name: "out"),
+}
+
+biases = {
+  "b1" => tf.variable(tf.random_normal([n_hidden_1]), dtype: :float64, name: "b1"),
+  "b2" => tf.variable(tf.random_normal([n_hidden_2]), dtype: :float64, name: "b2"),
+  "out" => tf.variable(tf.random_normal([num_classes]), dtype: :float64, name: "out2"),
+}
+
+# Create model
+def neural_net(x, weights, biases)
+  tf = TensorStream
+  # Hidden fully connected layer with 256 neurons
+  layer_1 = tf.add(tf.matmul(x, weights["h1"]), biases["b1"])
+  # Hidden fully connected layer with 256 neurons
+  layer_2 = tf.add(tf.matmul(layer_1, weights["h2"]), biases["b2"])
+  # Output fully connected layer with a neuron for each class
+  tf.matmul(layer_2, weights["out"]) + biases["out"]
+end
+
+# Construct model
+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_v2(
+  logits: logits, labels: Y
+))
+
+optimizer = TensorStream::Train::MomentumOptimizer.new(learning_rate, momentum, use_nesterov: true)
+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 do |sess|
+  # Run the initializer
+  sess.run(init)
+
+  print("Testing Accuracy:", \
+    sess.run(accuracy, feed_dict: {X => mnist.test.images,
+                                   Y => mnist.test.labels,}))
+
+  (1..num_steps + 1).each do |step|
+    batch_x, batch_y = mnist.train.next_batch(batch_size)
+    # Run optimization op (backprop)
+    sess.run(train_op, feed_dict: {X => batch_x, Y => batch_y})
+    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("\nStep " + step.to_s + ", Minibatch Loss= " + \
+              loss.to_s + ", Training Accuracy= " + \
+              acc.to_s)
+    end
+  end
+  print("\nOptimization Finished!")
+  print("\nTesting Accuracy after optimization:", \
+    sess.run(accuracy, feed_dict: {X => mnist.test.images,
+                                   Y => mnist.test.labels,}))
+end

data/samples/{rnn.rb → neural_networks/rnn.rb}

@@ -6,11 +6,10 @@
 #
 
 require "bundler/setup"
-require 'tensor_stream'
+require "tensor_stream"
 # require 'tensor_stream/opencl'
 # require 'pry-byebug'
 
-
 tf = TensorStream
 
 num_epochs = 100
@@ -23,30 +22,27 @@ batch_size = 5
 num_batches = total_series_length / batch_size / truncated_backprop_length
 randomizer = TensorStream.random_uniform([total_series_length], minval: 0, maxval: 2)
 
-
 def generate_data(randomizer, total_series_length, batch_size, echo_step)
   x = randomizer.eval
   y = x.rotate(-echo_step)
 
   y[echo_step] = 0
 
-  x = TensorStream::TensorShape.reshape(x, [batch_size, -1])  # The first index changing slowest, subseries as rows
+  x = TensorStream::TensorShape.reshape(x, [batch_size, -1]) # The first index changing slowest, subseries as rows
   y = TensorStream::TensorShape.reshape(y, [batch_size, -1])
   [x, y]
 end
 
-batchX_placeholder = tf.placeholder(:float32, shape: [batch_size, truncated_backprop_length], name: 'batch_x')
-batchY_placeholder = tf.placeholder(:int32, shape: [batch_size, truncated_backprop_length], name: 'batch_y')
-
-init_state = tf.placeholder(:float32, shape: [batch_size, state_size], name: 'init_state')
-
+batchX_placeholder = tf.placeholder(:float32, shape: [batch_size, truncated_backprop_length], name: "batch_x")
+batchY_placeholder = tf.placeholder(:int32, shape: [batch_size, truncated_backprop_length], name: "batch_y")
 
-W = tf.variable(tf.random_uniform([state_size+1, state_size]), dtype: :float32, name: 'W')
-b = tf.variable(tf.zeros([state_size]), dtype: :float32, name: 'b')
+init_state = tf.placeholder(:float32, shape: [batch_size, state_size], name: "init_state")
 
-W2 = tf.variable(tf.random_uniform([state_size, num_classes]), dtype: :float32, name: 'W2')
-b2 = tf.variable(tf.zeros([num_classes]), dtype: :float32, name: 'b2')
+W = tf.variable(tf.random_uniform([state_size + 1, state_size]), dtype: :float32, name: "W")
+b = tf.variable(tf.zeros([state_size]), dtype: :float32, name: "b")
 
+W2 = tf.variable(tf.random_uniform([state_size, num_classes]), dtype: :float32, name: "W2")
+b2 = tf.variable(tf.zeros([num_classes]), dtype: :float32, name: "b2")
 
 inputs_series = tf.unpack(batchX_placeholder, axis: 1)
 labels_series = tf.unpack(batchY_placeholder, axis: 1)
@@ -56,23 +52,23 @@ states_series = []
 
 inputs_series.each do |current_input|
   current_input = tf.reshape(current_input, [batch_size, 1])
-  input_and_state_concatenated = tf.concat([current_input, current_state], 1)  # Increasing number of columns
-  next_state = tf.tanh(tf.matmul(input_and_state_concatenated, W) + b)  # Broadcasted addition
+  input_and_state_concatenated = tf.concat([current_input, current_state], 1) # Increasing number of columns
+  next_state = tf.tanh(tf.matmul(input_and_state_concatenated, W) + b) # Broadcasted addition
   states_series << next_state
   current_state = next_state
 end
 
-logits_series = states_series.collect do |state|
+logits_series = states_series.collect { |state|
   tf.matmul(state, W2) + b2
-end
+}
 
-predictions_series = logits_series.collect do |logits|
+predictions_series = logits_series.collect { |logits|
   tf.nn.softmax(logits)
-end
+}
 
-losses = logits_series.zip(labels_series).collect do |logits, labels|
+losses = logits_series.zip(labels_series).collect { |logits, labels|
   tf.nn.sparse_softmax_cross_entropy_with_logits(logits: logits, labels: labels)
-end
+}
 total_loss = tf.reduce_mean(losses)
 
 train_step = TensorStream::Train::AdagradOptimizer.new(0.1).minimize(total_loss)
@@ -93,16 +89,17 @@ tf.session do |sess|
       batchY = y.map { |y| y[start_idx...end_idx] }
 
       _total_loss, _train_step, _current_state, _predictions_series = sess.run(
-          [total_loss, train_step, current_state, predictions_series],
-          feed_dict: {
-              batchX_placeholder => batchX,
-              batchY_placeholder => batchY,
-              init_state => _current_state
-          })
-
-      if batch_idx%10 == 0
-          print("Step",batch_idx, " Loss ", _total_loss, "\n")
+        [total_loss, train_step, current_state, predictions_series],
+        feed_dict: {
+          batchX_placeholder => batchX,
+          batchY_placeholder => batchY,
+          init_state => _current_state,
+        }
+      )
+
+      if batch_idx % 10 == 0
+        print("Step", batch_idx, " Loss ", _total_loss, "\n")
       end
     end
   end
-end
+end

data/samples/{nearest_neighbor.rb → others/nearest_neighbor.rb}

@@ -1,4 +1,4 @@
-'''
+""'
 A nearest neighbor learning algorithm example using TensorFlow library.
 This example is using the MNIST database of handwritten digits
 (http://yann.lecun.com/exdb/mnist/)
@@ -7,19 +7,19 @@ Author: Aymeric Damien
 Project: https://github.com/aymericdamien/TensorFlow-Examples/
 
 Make sure to install the mnist-learn gem !!
-'''
+'""
 require "bundler/setup"
-require 'tensor_stream'
-require 'mnist-learn'
+require "tensor_stream"
+require "mnist-learn"
 
 tf = TensorStream
 
 # Import MNIST data
-mnist = Mnist.read_data_sets('/tmp/data', one_hot: true)
+mnist = Mnist.read_data_sets("/tmp/data", one_hot: true)
 
 # In this example, we limit mnist data
-Xtr, Ytr = mnist.train.next_batch(5000) #5000 for training (nn candidates)
-Xte, Yte = mnist.test.next_batch(200) #200 for testing
+Xtr, Ytr = mnist.train.next_batch(5000) # 5000 for training (nn candidates)
+Xte, Yte = mnist.test.next_batch(200) # 200 for testing
 
 # tf Graph Input
 xtr = tf.placeholder(:float, shape: [nil, 784])
@@ -34,7 +34,7 @@ pred = tf.argmin(distance, 0)
 accuracy = 0.0
 
 # Initialize the variables (i.e. assign their default value)
-init = tf.global_variables_initializer()
+init = tf.global_variables_initializer
 
 # Start training
 tf.session do |sess|
@@ -43,13 +43,13 @@ tf.session do |sess|
   Xte.size.times do |i|
     # Get nearest neighbor
     nn_index = sess.run(pred, feed_dict: {xtr => Xtr, xte => Xte[i]})
-    print("Test ", i, "Prediction: ",Ytr[nn_index].max, \
-            "True Class: ", Yte[i].max, "\n")
+    print("Test ", i, "Prediction: ", Ytr[nn_index].max, \
+      "True Class: ", Yte[i].max, "\n")
     if Ytr[nn_index].max == Yte[i].max
-      accuracy += 1.0/ Xte.size
+      accuracy += 1.0 / Xte.size
     end
   end
 
   print("Done!")
   print("Accuracy:", accuracy)
-end
+end

data/samples/regression/linear_regression.rb

@@ -0,0 +1,63 @@
+require "tensor_stream"
+
+tf = TensorStream
+
+learning_rate = 0.01
+training_epochs = 1000
+display_step = 50
+
+train_x = [3.3, 4.4, 5.5, 6.71, 6.93, 4.168, 9.779, 6.182, 7.59, 2.167,
+           7.042, 10.791, 5.313, 7.997, 5.654, 9.27, 3.1,]
+
+train_y = [1.7, 2.76, 2.09, 3.19, 1.694, 1.573, 3.366, 2.596, 2.53, 1.221,
+           2.827, 3.465, 1.65, 2.904, 2.42, 2.94, 1.3,]
+
+n_samples = train_x.size
+
+x_value = Float.placeholder
+y_value = Float.placeholder
+
+# Set model weights
+weight = rand.t.var name: "weight"
+
+bias = rand.t.var name: "bias"
+
+# Construct a linear model
+pred = x_value * weight + bias
+
+# Mean squared error
+cost = ((pred - y_value)**2).reduce / (2 * n_samples)
+
+# Other optimizers --
+#
+# optimizer = TensorStream::Train::MomentumOptimizer.new(learning_rate, momentum, use_nesterov: true).minimize(cost)
+# optimizer = TensorStream::Train::AdamOptimizer.new(learning_rate).minimize(cost)
+# optimizer = TensorStream::Train::AdadeltaOptimizer.new(1.0).minimize(cost)
+# optimizer = TensorStream::Train::AdagradOptimizer.new(0.01).minimize(cost)
+# optimizer = TensorStream::Train::RMSPropOptimizer.new(0.01, centered: true).minimize(cost)
+optimizer = TensorStream::Train::GradientDescentOptimizer.new(learning_rate).minimize(cost)
+
+# Initialize the variables (i.e. assign their default value)
+init = tf.global_variables_initializer
+
+tf.session do |sess|
+  start_time = Time.now
+  sess.run(init)
+
+  (0..training_epochs).each do |epoch|
+    train_x.zip(train_y).each do |x, y|
+      sess.run(optimizer, feed_dict: {x_value => x, y_value => y})
+    end
+
+    if (epoch + 1) % display_step == 0
+      c = sess.run(cost, feed_dict: {x_value => train_x, y_value => train_y})
+      puts("Epoch:", "%04d" % (epoch + 1), "cost=", c, \
+        "W=", sess.run(weight), "b=", sess.run(bias))
+    end
+  end
+
+  puts "Optimization Finished!"
+  training_cost = sess.run(cost, feed_dict: {x_value => train_x, y_value => train_y})
+  puts "Training cost=", training_cost, "W=", sess.run(weight), "b=", sess.run(bias), '\n'
+  puts "time elapsed ", Time.now.to_i - start_time.to_i
+end