tensorflow-ruby 0.2.0

data/lib/tensorflow/ops/image.rb

@@ -0,0 +1,218 @@
+module Tensorflow
+  module Image
+    class << self
+      # def adjust_brightness
+      # end
+
+      def adjust_contrast(images, contrast_factor, min_value, max_value)
+        RawOps.adjust_contrast(images, contrast_factor, min_value, max_value)
+      end
+
+      # def adjust_gamma
+      # end
+
+      def adjust_hue(images, delta)
+        RawOps.adjust_hue(images, delta)
+      end
+
+      # def adjust_jpeg_quality
+      # end
+
+      def adjust_saturation(images, scale)
+        RawOps.adjust_saturation(images, scale)
+      end
+
+      # def central_crop
+      # end
+
+      def combined_non_max_suppression(boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold, pad_per_class: nil, clip_boxes: nil)
+        RawOps.combined_non_max_suppression(boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold, pad_per_class: pad_per_class, clip_boxes: clip_boxes)
+      end
+
+      # def convert_image_dtype
+      # end
+
+      def crop_and_resize(image, boxes, box_ind, crop_size, method: nil, extrapolation_value: nil)
+        RawOps.crop_and_resize(image, boxes, box_ind, crop_size, method: method, extrapolation_value: extrapolation_value)
+      end
+
+      # def crop_to_bounding_box
+      # end
+
+      def decode_and_crop_jpeg(contents, crop_window, channels: nil, ratio: nil, fancy_upscaling: nil, try_recover_truncated: nil, acceptable_fraction: nil, dct_method: nil)
+        RawOps.decode_and_crop_jpeg(contents, crop_window, channels: channels, ratio: ratio, fancy_upscaling: fancy_upscaling, try_recover_truncated: try_recover_truncated, acceptable_fraction: acceptable_fraction, dct_method: dct_method)
+      end
+
+      def decode_bmp(contents, channels: nil)
+        RawOps.decode_bmp(contents: contents, channels: channels)
+      end
+
+      def decode_gif(contents)
+        RawOps.decode_gif(contents: contents)
+      end
+
+      # def decode_image
+      # end
+
+      def decode_jpeg(contents, channels: nil, ratio: nil, fancy_upscaling: nil, try_recover_truncated: nil, acceptable_fraction: nil, dct_method: nil)
+        RawOps.decode_jpeg(contents, channels: channels, ratio: ratio, fancy_upscaling: fancy_upscaling, try_recover_truncated: try_recover_truncated, acceptable_fraction: acceptable_fraction, dct_method: dct_method)
+      end
+
+      def decode_png(contents, channels: nil, dtype: nil)
+        RawOps.decode_png(contents, channels: channels, dtype: dtype)
+      end
+
+      def draw_bounding_boxes(images, boxes)
+        RawOps.draw_bounding_boxes(images, boxes)
+      end
+
+      def encode_jpeg(image, format: nil, quality: nil, progressive: nil, optimize_size: nil, chroma_downsampling: nil, density_unit: nil, x_density: nil, y_density: nil, xmp_metadata: nil)
+        RawOps.encode_jpeg(image, format: format, quality: quality, progressive: progressive, optimize_size: optimize_size, chroma_downsampling: chroma_downsampling, density_unit: density_unit, x_density: x_density, y_density: y_density, xmp_metadata: xmp_metadata)
+      end
+
+      def encode_png(image, compression: nil)
+        RawOps.encode_png(image, compression: compression)
+      end
+
+      def extract_glimpse(input, size, offsets, centered: nil, normalized: nil, uniform_noise: nil, noise: nil)
+        RawOps.extract_glimpse(input, size, offsets, centered: centered, normalized: normalized, uniform_noise: uniform_noise, noise: noise)
+      end
+
+      def extract_jpeg_shape(contents, output_type: nil)
+        RawOps.extract_jpeg_shape(contents: contents, output_type: output_type)
+      end
+
+      # def extract_patches
+      # end
+
+      # def flip_left_right
+      # end
+
+      # def flip_up_down
+      # end
+
+      # def grayscale_to_rgb
+      # end
+
+      def hsv_to_rgb(images)
+        RawOps.hsv_to_rgb(images: images)
+      end
+
+      # def image_gradients
+      # end
+
+      def is_jpeg(contents)
+        substr = Strings.substr(contents, 0, 3)
+        Math.equal(substr, "\xff\xd8\xff")
+      end
+
+      def non_max_suppression(boxes, scores, max_output_size, iou_threshold: nil)
+        RawOps.non_max_suppression(boxes, scores, max_output_size, iou_threshold: iou_threshold)
+      end
+
+      # def non_max_suppression_overlaps
+      # end
+
+      # def non_max_suppression_padded
+      # end
+
+      # def non_max_suppression_with_scores
+      # end
+
+      # def pad_to_bounding_box
+      # end
+
+      # def per_image_standardization
+      # end
+
+      # def psnr
+      # end
+
+      # def random_brightness
+      # end
+
+      # def random_contrast
+      # end
+
+      def random_crop(image, size, seed: nil, seed2: nil)
+        RawOps.random_crop(image, size, seed: seed, seed2: seed2)
+      end
+
+      # def random_flip_left_right
+      # end
+
+      # def random_flip_up_down
+      # end
+
+      # def random_hue
+      # end
+
+      # def random_jpeg_quality
+      # end
+
+      # def random_saturation
+      # end
+
+      def resize(images, size)
+        images = Tensor.from_value(images)
+
+        batch = images.shape.size != 3
+        images = Tensorflow.expand_dims(images, 0) unless batch
+
+        # TODO support more methods
+        images = RawOps.resize_bilinear(images, size)
+
+        images = Tensorflow.squeeze(images, axis: [0]) unless batch
+
+        images
+      end
+
+      # def resize_with_crop_or_pad
+      # end
+
+      # def resize_with_pad
+      # end
+
+      # def rgb_to_grayscale
+      # end
+
+      def rgb_to_hsv(images)
+        RawOps.rgb_to_hsv(images: images)
+      end
+
+      # def rgb_to_yiq
+      # end
+
+      # def rgb_to_yuv
+      # end
+
+      # def rot90
+      # end
+
+      def sample_distorted_bounding_box(image_size, bounding_boxes, seed: nil, seed2: nil, min_object_covered: nil, aspect_ratio_range: nil, area_range: nil, max_attempts: nil, use_image_if_no_bounding_boxes: nil)
+        RawOps.sample_distorted_bounding_box(image_size, bounding_boxes, seed: seed, seed2: seed2, min_object_covered: min_object_covered, aspect_ratio_range: aspect_ratio_range, area_range: area_range, max_attempts: max_attempts, use_image_if_no_bounding_boxes: use_image_if_no_bounding_boxes)
+      end
+
+      # def sobel_edges
+      # end
+
+      # def ssim
+      # end
+
+      # def ssim_multiscale
+      # end
+
+      # def total_variation
+      # end
+
+      # def transpose
+      # end
+
+      # def yiq_to_rgb
+      # end
+
+      # def yuv_to_rgb
+      # end
+    end
+  end
+end

data/lib/tensorflow/ops/io.rb

@@ -0,0 +1,123 @@
+module Tensorflow
+  module IO
+    def self.decode_and_crop_jpeg(contents, crop_window, channels: nil, ratio: nil, fancy_upscaling: nil, try_recover_truncated: nil, acceptable_fraction: nil, dct_method: nil)
+      RawOps.decode_and_crop_jpeg(contents, crop_window, channels: channels, ratio: ratio, fancy_upscaling: fancy_upscaling, try_recover_truncated: try_recover_truncated, acceptable_fraction: acceptable_fraction, dct_method: dct_method)
+    end
+
+    def self.decode_base64(input)
+      RawOps.decode_base64(input)
+    end
+
+    def self.decode_bmp(contents, channels: nil)
+      RawOps.decode_bmp(contents, channels: channels)
+    end
+
+    def self.decode_compressed(bytes, compression_type: nil)
+      RawOps.decode_compressed(bytes, compression_type: compression_type)
+    end
+
+    def self.decode_csv(records, record_defaults, field_delim: nil, use_quote_delim: nil, na_value: nil, select_cols: nil)
+      RawOps.decode_csv(records, record_defaults, field_delim: field_delim, use_quote_delim: use_quote_delim, na_value: na_value, select_cols: select_cols)
+    end
+
+    def self.decode_gif(contents)
+      RawOps.decode_gif(contents: contents)
+    end
+
+    # def self.decode_image
+    # end
+
+    def self.decode_jpeg(contents, channels: nil, ratio: nil, fancy_upscaling: nil, try_recover_truncated: nil, acceptable_fraction: nil, dct_method: nil)
+      RawOps.decode_jpeg(contents: contents, channels: channels, ratio: ratio, fancy_upscaling: fancy_upscaling, try_recover_truncated: try_recover_truncated, acceptable_fraction: acceptable_fraction, dct_method: dct_method)
+    end
+
+    def self.decode_json_example(json_examples)
+      RawOps.decode_json_example(json_examples: json_examples)
+    end
+
+    def self.decode_png(contents, channels: nil, dtype: nil)
+      RawOps.decode_png(contents: contents, channels: channels, dtype: dtype)
+    end
+
+    # def self.decode_proto
+    # end
+
+    def self.decode_raw(bytes, out_type, little_endian: nil)
+      RawOps.decode_raw(bytes, out_type: out_type, little_endian: little_endian)
+    end
+
+    def self.deserialize_many_sparse(serialized_sparse, dtype: nil)
+      RawOps.deserialize_many_sparse(serialized_sparse: serialized_sparse, dtype: dtype)
+    end
+
+    def self.encode_base64(input, pad: nil)
+      RawOps.encode_base64(input: input, pad: pad)
+    end
+
+    def self.encode_jpeg(image, format: nil, quality: nil, progressive: nil, optimize_size: nil, chroma_downsampling: nil, density_unit: nil, x_density: nil, y_density: nil, xmp_metadata: nil)
+      RawOps.encode_jpeg(image: image, format: format, quality: quality, progressive: progressive, optimize_size: optimize_size, chroma_downsampling: chroma_downsampling, density_unit: density_unit, x_density: x_density, y_density: y_density, xmp_metadata: xmp_metadata)
+    end
+
+    def self.encode_proto(sizes, values, field_names: nil, message_type: nil, descriptor_source: nil)
+      RawOps.encode_proto(sizes, values, field_names: field_names, message_type: message_type, descriptor_source: descriptor_source)
+    end
+
+    def self.extract_jpeg_shape(contents, output_type: nil)
+      RawOps.extract_jpeg_shape(contents: contents, output_type: output_type)
+    end
+
+    def self.is_jpeg(contents)
+      Image.is_jpeg(contents)
+    end
+
+    # def self.match_filenames_once
+    # end
+
+    def self.matching_files(pattern)
+      RawOps.matching_files(pattern: pattern)
+    end
+
+    def self.parse_example(serialized, names, sparse_keys, dense_keys, dense_defaults, sparse_types: nil, dense_shapes: nil)
+      RawOps.parse_example(serialized, names, sparse_keys, dense_keys, dense_defaults, sparse_types: sparse_types, dense_shapes: dense_shapes)
+    end
+
+    def self.parse_sequence_example(serialized, debug_name, context_dense_defaults, feature_list_dense_missing_assumed_empty: nil, context_sparse_keys: nil, context_dense_keys: nil, feature_list_sparse_keys: nil, feature_list_dense_keys: nil, context_sparse_types: nil, feature_list_dense_types: nil, context_dense_shapes: nil, feature_list_sparse_types: nil, feature_list_dense_shapes: nil)
+      RawOps.parse_sequence_example(serialized, debug_name, context_dense_defaults, feature_list_dense_missing_assumed_empty: feature_list_dense_missing_assumed_empty, context_sparse_keys: context_sparse_keys, context_dense_keys: context_dense_keys, feature_list_sparse_keys: feature_list_sparse_keys, feature_list_dense_keys: feature_list_dense_keys, context_sparse_types: context_sparse_types, feature_list_dense_types: feature_list_dense_types, context_dense_shapes: context_dense_shapes, feature_list_sparse_types: feature_list_sparse_types, feature_list_dense_shapes: feature_list_dense_shapes)
+    end
+
+    def self.parse_single_example(serialized, dense_defaults, num_sparse: nil, sparse_keys: nil, dense_keys: nil, sparse_types: nil, dense_shapes: nil)
+      RawOps.parse_single_example(serialized, dense_defaults, num_sparse: num_sparse, sparse_keys: sparse_keys, dense_keys: dense_keys, sparse_types: sparse_types, dense_shapes: dense_shapes)
+    end
+
+    def self.parse_single_sequence_example(serialized, feature_list_dense_missing_assumed_empty, context_sparse_keys, context_dense_keys, feature_list_sparse_keys, feature_list_dense_keys, context_dense_defaults, debug_name, context_sparse_types: nil, feature_list_dense_types: nil, context_dense_shapes: nil, feature_list_sparse_types: nil, feature_list_dense_shapes: nil)
+      RawOps.parse_single_sequence_example(serialized, feature_list_dense_missing_assumed_empty, context_sparse_keys, context_dense_keys, feature_list_sparse_keys, feature_list_dense_keys, context_dense_defaults, debug_name)
+    end
+
+    def self.parse_tensor(serialized, out_type: nil)
+      RawOps.parse_tensor(serialized: serialized, out_type: out_type)
+    end
+
+    def self.read_file(filename)
+      RawOps.read_file(filename)
+    end
+
+    def self.serialize_many_sparse(sparse_indices, sparse_values, sparse_shape, out_type: nil)
+      RawOps.serialize_many_sparse(sparse_indices, sparse_values, sparse_shape, out_type: out_type)
+    end
+
+    def self.serialize_sparse(sparse_indices, sparse_values, sparse_shape, out_type: nil)
+      RawOps.serialize_sparse(sparse_indices, sparse_values, sparse_shape, out_type: out_type)
+    end
+
+    def self.serialize_tensor(tensor)
+      RawOps.serialize_tensor(tensor)
+    end
+
+    def self.write_file(filename, contents)
+      RawOps.write_file(filename, contents)
+    end
+
+    # def self.write_graph
+    # end
+  end
+end

data/lib/tensorflow/ops/linalg.rb

@@ -0,0 +1,131 @@
+module Tensorflow
+  module Linalg
+      # def self.adjoint
+      # end
+
+      # def self.band_part
+      # end
+
+      def self.cholesky(input)
+        RawOps.cholesky(input: input)
+      end
+
+      # def self.cholesky_solve
+      # end
+
+      def self.cross(a, b)
+        RawOps.cross(a, b)
+      end
+
+      # def self.det
+      # end
+
+      def self.diag(diagonal)
+        RawOps.diag(diagonal: diagonal)
+      end
+
+      def self.diag_part(input)
+        RawOps.diag_part(input: input)
+      end
+
+      # def self.eigh
+      # end
+
+      # def self.eigvalsh
+      # end
+
+      # def self.einsum
+      # end
+
+      # def self.expm
+      # end
+
+      def self.eye(num_rows, num_columns: nil)
+        num_columns ||= num_rows
+        zeros = Tensorflow.zeros([num_rows, num_columns])
+        ones = Tensorflow.ones([num_rows])
+        RawOps.matrix_set_diag(zeros, ones)
+      end
+
+      # def self.global_norm
+      # end
+
+      def self.inv(x)
+        RawOps.inv(x: x)
+      end
+
+      # def self.l2_normalize
+      # end
+
+      # def self.logdet
+      # end
+
+      # def self.logm
+      # end
+
+      # def self.lstsq
+      # end
+
+      def self.lu(input, output_idx_type: nil)
+        RawOps.lu(input: input, output_idx_type: output_idx_type)
+      end
+
+      def self.matmul(a, b, transpose_a: false, transpose_b: false)
+        RawOps.mat_mul(a, b, transpose_a: transpose_a, transpose_b: transpose_b)
+      end
+
+      # def self.matrix_transpose
+      # end
+
+      # def self.matvec
+      # end
+
+      # def self.norm
+      # end
+
+      # def self.normalize
+      # end
+
+      def self.qr(input, full_matrices: nil)
+        RawOps.qr(input: input, full_matrices: full_matrices)
+      end
+
+      # def self.set_diag
+      # end
+
+      # def self.slogdet
+      # end
+
+      # def self.solve
+      # end
+
+      # def self.sqrtm
+      # end
+
+      def self.svd(input, compute_uv: nil, full_matrices: nil)
+        RawOps.svd(input: input, compute_uv: compute_uv, full_matrices: full_matrices)
+      end
+
+      # def self.tensor_diag
+      # end
+
+      # def self.tensor_diag_part
+      # end
+
+      # def self.tensordot
+      # end
+
+      # def self.trace
+      # end
+
+      # def self.triangular_solve
+      # end
+
+      # def self.tridiagonal_matmul
+      # end
+
+      def self.tridiagonal_solve(diagonals, rhs, partial_pivoting: nil)
+        RawOps.tridiagonal_solve(diagonals, rhs, partial_pivoting: partial_pivoting)
+      end
+    end
+end