tensorflow 0.1.1 → 0.1.2

data/lib/tensorflow/math.rb

@@ -224,8 +224,10 @@ module TensorFlow
         RawOps.log1p(x: x)
       end
 
-      # def log_sigmoid
-      # end
+      def log_sigmoid(x)
+        x = TensorFlow.convert_to_tensor(x)
+        negative(RawOps.softplus(features: -x))
+      end
 
       def log_softmax(logits)
         RawOps.log_softmax(logits: logits)
@@ -243,8 +245,9 @@ module TensorFlow
         RawOps.logical_or(x: x, y: y)
       end
 
-      # def logical_xor
-      # end
+      def logical_xor(x, y)
+        logical_and(logical_or(x, y), logical_not(logical_and(x, y)))
+      end
 
       def maximum(x, y)
         RawOps.maximum(x: x, y: y)
@@ -262,11 +265,13 @@ module TensorFlow
         RawOps.mul(x: x, y: y)
       end
 
-      # def multiply_no_nan
-      # end
+      def multiply_no_nan(x, y)
+        RawOps.mul_no_nan(x: x, y: y)
+      end
 
-      # def negative
-      # end
+      def negative(x)
+        RawOps.neg(x: x)
+      end
 
       # def nextafter
       # end
@@ -300,8 +305,11 @@ module TensorFlow
       # def reduce_all
       # end
 
-      # def reduce_any
-      # end
+      def reduce_any(input_tensor, axis: nil, keepdims: false)
+        input_tensor = TensorFlow.convert_to_tensor(input_tensor)
+        axis ||= reduction_dims(input_tensor)
+        RawOps.any(input: input_tensor, reduction_indices: axis, keep_dims: keepdims)
+      end
 
       # def reduce_euclidean_norm
       # end
@@ -309,26 +317,46 @@ module TensorFlow
       # def reduce_logsumexp
       # end
 
-      # def reduce_max
-      # end
+      def reduce_max(input_tensor, axis: nil, keepdims: false)
+        input_tensor = TensorFlow.convert_to_tensor(input_tensor)
+        axis ||= reduction_dims(input_tensor)
+        RawOps.max(input: input_tensor, reduction_indices: axis, keep_dims: keepdims)
+      end
 
-      # def reduce_mean
-      # end
+      def reduce_mean(input_tensor, axis: nil, keepdims: false)
+        input_tensor = TensorFlow.convert_to_tensor(input_tensor)
+        axis ||= reduction_dims(input_tensor)
+        RawOps.mean(input: input_tensor, reduction_indices: axis, keep_dims: keepdims)
+      end
 
-      # def reduce_min
-      # end
+      def reduce_min(input_tensor, axis: nil, keepdims: false)
+        input_tensor = TensorFlow.convert_to_tensor(input_tensor)
+        axis ||= reduction_dims(input_tensor)
+        RawOps.min(input: input_tensor, reduction_indices: axis, keep_dims: keepdims)
+      end
 
-      # def reduce_prod
-      # end
+      def reduce_prod(input_tensor, axis: nil, keepdims: false)
+        input_tensor = TensorFlow.convert_to_tensor(input_tensor)
+        axis ||= reduction_dims(input_tensor)
+        RawOps.prod(input: input_tensor, reduction_indices: axis, keep_dims: keepdims)
+      end
 
-      # def reduce_std
-      # end
+      def reduce_std(input_tensor, axis: nil, keepdims: false)
+        variance = reduce_variance(input_tensor, axis: axis, keepdims: keepdims)
+        sqrt(variance)
+      end
 
-      # def reduce_sum
-      # end
+      def reduce_sum(input_tensor, axis: nil, keepdims: false)
+        input_tensor = TensorFlow.convert_to_tensor(input_tensor)
+        axis ||= reduction_dims(input_tensor)
+        RawOps.sum(input: input_tensor, reduction_indices: axis, keep_dims: keepdims)
+      end
 
-      # def reduce_variance
-      # end
+      def reduce_variance(input_tensor, axis: nil, keepdims: false)
+        means = reduce_mean(input_tensor, axis: axis, keepdims: true)
+        squared_deviations = RawOps.square(x: input_tensor - means)
+        reduce_mean(squared_deviations, axis: axis, keepdims: keepdims)
+      end
 
       def rint(x)
         RawOps.rint(x: x)
@@ -460,6 +488,13 @@ module TensorFlow
       def zeta(x, q)
         RawOps.zeta(x: x, q: q)
       end
+
+      private
+
+      def reduction_dims(input_tensor)
+        rank = RawOps.rank(input: input_tensor).value
+        (0...rank).to_a
+      end
     end
   end
 end

data/lib/tensorflow/nn.rb

@@ -0,0 +1,284 @@
+module TensorFlow
+  module NN
+    class << self
+      def all_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, seed: nil, seed2: nil)
+        RawOps.all_candidate_sampler(true_classes: true_classes, num_true: num_true, num_sampled: num_sampled, unique: unique, seed: seed, seed2: seed2)
+      end
+
+      # def atrous_conv2d
+      # end
+
+      # def atrous_conv2d_transpose
+      # end
+
+      def avg_pool(value, ksize: nil, strides: nil, padding: nil, data_format: nil)
+        RawOps.avg_pool(value: value, ksize: ksize, strides: strides, padding: padding, data_format: data_format)
+      end
+
+      # def avg_pool1d
+      # end
+
+      # def avg_pool2d
+      # end
+
+      def avg_pool3d(input, ksize: nil, strides: nil, padding: nil, data_format: nil)
+        RawOps.avg_pool3d(input: input, ksize: ksize, strides: strides, padding: padding, data_format: data_format)
+      end
+
+      def batch_norm_with_global_normalization(t, m, v, beta, gamma, variance_epsilon: nil, scale_after_normalization: nil)
+        RawOps.batch_norm_with_global_normalization(t: t, m: m, v: v, beta: beta, gamma: gamma, variance_epsilon: variance_epsilon, scale_after_normalization: scale_after_normalization)
+      end
+
+      # def batch_normalization
+      # end
+
+      def bias_add(value, bias, data_format: nil)
+        RawOps.bias_add(value: value, bias: bias, data_format: data_format)
+      end
+
+      # def collapse_repeated
+      # end
+
+      def compute_accidental_hits(true_classes, sampled_candidates, num_true: nil, seed: nil, seed2: nil)
+        RawOps.compute_accidental_hits(true_classes: true_classes, sampled_candidates: sampled_candidates, num_true: num_true, seed: seed, seed2: seed2)
+      end
+
+      # def compute_average_loss
+      # end
+
+      # def conv1d
+      # end
+
+      # def conv1d_transpose
+      # end
+
+      def conv2d(input, filter, strides: nil, use_cudnn_on_gpu: nil, padding: nil, explicit_paddings: nil, data_format: nil, dilations: nil)
+        RawOps.conv2d(input: input, filter: filter, strides: strides, use_cudnn_on_gpu: use_cudnn_on_gpu, padding: padding, explicit_paddings: explicit_paddings, data_format: data_format, dilations: dilations)
+      end
+
+      # def conv2d_transpose
+      # end
+
+      def conv3d(input, filter, strides: nil, padding: nil, data_format: nil, dilations: nil)
+        RawOps.conv3d(input: input, filter: filter, strides: strides, padding: padding, data_format: data_format, dilations: dilations)
+      end
+
+      # def conv3d_transpose
+      # end
+
+      # def conv_transpose
+      # end
+
+      # def convolution
+      # end
+
+      # def crelu
+      # end
+
+      def ctc_beam_search_decoder(inputs, sequence_length, beam_width: nil, top_paths: nil, merge_repeated: nil)
+        RawOps.ctc_beam_search_decoder(inputs: inputs, sequence_length: sequence_length, beam_width: beam_width, top_paths: top_paths, merge_repeated: merge_repeated)
+      end
+
+      def ctc_greedy_decoder(inputs, sequence_length, merge_repeated: nil)
+        RawOps.ctc_greedy_decoder(inputs: inputs, sequence_length: sequence_length, merge_repeated: merge_repeated)
+      end
+
+      def ctc_loss(inputs, labels_indices, labels_values, sequence_length, preprocess_collapse_repeated: nil, ctc_merge_repeated: nil, ignore_longer_outputs_than_inputs: nil)
+        RawOps.ctc_loss(inputs: inputs, labels_indices: labels_indices, labels_values: labels_values, sequence_length: sequence_length, preprocess_collapse_repeated: preprocess_collapse_repeated, ctc_merge_repeated: ctc_merge_repeated, ignore_longer_outputs_than_inputs: ignore_longer_outputs_than_inputs)
+      end
+
+      # def ctc_unique_labels
+      # end
+
+      def depth_to_space(input, block_size: nil, data_format: nil)
+        RawOps.depth_to_space(input: input, block_size: block_size, data_format: data_format)
+      end
+
+      # def depthwise_conv2d
+      # end
+
+      # def depthwise_conv2d_backprop_filter
+      # end
+
+      # def depthwise_conv2d_backprop_input
+      # end
+
+      def dilation2d(input, filter, strides: nil, rates: nil, padding: nil)
+        RawOps.dilation2d(input: input, filter: filter, strides: strides, rates: rates, padding: padding)
+      end
+
+      # def dropout
+      # end
+
+      def elu(features)
+        RawOps.elu(features: features)
+      end
+
+      # def embedding_lookup
+      # end
+
+      # def embedding_lookup_sparse
+      # end
+
+      # def erosion2d
+      # end
+
+      def fixed_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, vocab_file: nil, distortion: nil, num_reserved_ids: nil, num_shards: nil, shard: nil, unigrams: nil, seed: nil, seed2: nil)
+        RawOps.fixed_unigram_candidate_sampler(true_classes: true_classes, num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, vocab_file: vocab_file, distortion: distortion, num_reserved_ids: num_reserved_ids, num_shards: num_shards, shard: shard, unigrams: unigrams, seed: seed, seed2: seed2)
+      end
+
+      def fractional_avg_pool(value, pooling_ratio: nil, pseudo_random: nil, overlapping: nil, deterministic: nil, seed: nil, seed2: nil)
+        RawOps.fractional_avg_pool(value: value, pooling_ratio: pooling_ratio, pseudo_random: pseudo_random, overlapping: overlapping, deterministic: deterministic, seed: seed, seed2: seed2)
+      end
+
+      def fractional_max_pool(value, pooling_ratio: nil, pseudo_random: nil, overlapping: nil, deterministic: nil, seed: nil, seed2: nil)
+        RawOps.fractional_max_pool(value: value, pooling_ratio: pooling_ratio, pseudo_random: pseudo_random, overlapping: overlapping, deterministic: deterministic, seed: seed, seed2: seed2)
+      end
+
+      def in_top_k(predictions, targets, k: nil)
+        RawOps.in_top_k(predictions: predictions, targets: targets, k: k)
+      end
+
+      def l2_loss(t)
+        RawOps.l2_loss(t: t)
+      end
+
+      # def l2_normalize
+      # end
+
+      def leaky_relu(features, alpha: nil)
+        RawOps.leaky_relu(features: features, alpha: alpha)
+      end
+
+      def learned_unigram_candidate_sampler(true_classes, num_true: nil, num_sampled: nil, unique: nil, range_max: nil, seed: nil, seed2: nil)
+        RawOps.learned_unigram_candidate_sampler(true_classes: true_classes, num_true: num_true, num_sampled: num_sampled, unique: unique, range_max: range_max, seed: seed, seed2: seed2)
+      end
+
+      # def local_response_normalization
+      # end
+
+      # def log_poisson_loss
+      # end
+
+      def log_softmax(logits)
+        RawOps.log_softmax(logits: logits)
+      end
+
+      def lrn(input, depth_radius: nil, bias: nil, alpha: nil, beta: nil)
+        RawOps.lrn(input: input, depth_radius: depth_radius, bias: bias, alpha: alpha, beta: beta)
+      end
+
+      def max_pool(input, ksize: nil, strides: nil, padding: nil, data_format: nil)
+        RawOps.max_pool(input: input, ksize: ksize, strides: strides, padding: padding, data_format: data_format)
+      end
+
+      # def max_pool1d
+      # end
+
+      # def max_pool2d
+      # end
+
+      def max_pool3d(input, ksize: nil, strides: nil, padding: nil, data_format: nil)
+        RawOps.max_pool3d(input: input, ksize: ksize, strides: strides, padding: padding, data_format: data_format)
+      end
+
+      def max_pool_with_argmax(input, ksize: nil, strides: nil, padding: nil, include_batch_in_index: nil)
+        RawOps.max_pool_with_argmax(input: input, ksize: ksize, strides: strides, padding: padding, include_batch_in_index: include_batch_in_index)
+      end
+
+      # def moments
+      # end
+
+      # def nce_loss
+      # end
+
+      # def normalize_moments
+      # end
+
+      # def pool
+      # end
+
+      def relu(features)
+        RawOps.relu(features: features)
+      end
+
+      def relu6(features)
+        RawOps.relu6(features: features)
+      end
+
+      # def safe_embedding_lookup_sparse
+      # end
+
+      # def sampled_softmax_loss
+      # end
+
+      # def scale_regularization_loss
+      # end
+
+      def selu(features)
+        RawOps.selu(features: features)
+      end
+
+      # def separable_conv2d
+      # end
+
+      def sigmoid(x)
+        RawOps.sigmoid(x: x)
+      end
+
+      # def sigmoid_cross_entropy_with_logits
+      # end
+
+      def softmax(logits)
+        RawOps.softmax(logits: logits)
+      end
+
+      def softmax_cross_entropy_with_logits(features, labels)
+        RawOps.softmax_cross_entropy_with_logits(features: features, labels: labels)
+      end
+
+      def softplus(features)
+        RawOps.softplus(features: features)
+      end
+
+      def softsign(features)
+        RawOps.softsign(features: features)
+      end
+
+      def space_to_batch(input, paddings, block_size: nil)
+        RawOps.space_to_batch(input: input, paddings: paddings, block_size: block_size)
+      end
+
+      def space_to_depth(input, block_size: nil, data_format: nil)
+        RawOps.space_to_depth(input: input, block_size: block_size, data_format: data_format)
+      end
+
+      def sparse_softmax_cross_entropy_with_logits(features, labels)
+        RawOps.sparse_softmax_cross_entropy_with_logits(features: features, labels: labels)
+      end
+
+      # def sufficient_statistics
+      # end
+
+      def tanh(x)
+        RawOps.tanh(x: x)
+      end
+
+      def top_k(input, k: nil, sorted: nil)
+        RawOps.top_k(input: input, k: k, sorted: sorted)
+      end
+
+      # def weighted_cross_entropy_with_logits
+      # end
+
+      # def weighted_moments
+      # end
+
+      # def with_space_to_batch
+      # end
+
+      # def zero_fraction
+      # end
+    end
+  end
+end

data/lib/tensorflow/ops.rb

@@ -1,11 +1,12 @@
 # keep in alphabetical order
 module TensorFlow
   module Ops
-    def eye(num_rows,  num_columns: nil)
-      num_columns ||= num_rows
-      zeros = self.zeros([num_rows, num_columns])
-      ones = self.ones([num_rows])
-      RawOps.matrix_set_diag(input: zeros, diagonal: ones)
+    def cast(x, dtype)
+      Utils.execute("Cast", [x], DstT: FFI::DataType[dtype])
+    end
+
+    def expand_dims(input, axis)
+      RawOps.expand_dims(input: input, dim: axis)
     end
 
     def fill(dims, value)
@@ -16,10 +17,6 @@ module TensorFlow
       RawOps.identity(input: input)
     end
 
-    def matmul(a, b)
-      RawOps.mat_mul(a: a, b: b)
-    end
-
     def ones(dims)
       fill(dims, 1)
     end
@@ -32,6 +29,10 @@ module TensorFlow
       RawOps.range(start: start, limit: limit, delta: delta)
     end
 
+    def squeeze(input, axis: nil)
+      RawOps.squeeze(input: input, squeeze_dims: axis)
+    end
+
     def timestamp
       RawOps.timestamp
     end