Merge pull request #47 from velimir/matrix-ext

 add functions to cast binaries into matrix and tensors

Author: anshuman23

Makefile

@@ -1,6 +1,6 @@
 CFLAGS = -g -O3 -Wall -std=c99
 ERLANG_PATH = $(shell erl -eval 'io:format("~s", [lists:concat([code:root_dir(), "/erts-", erlang:system_info(version), "/include"])])' -s init stop -noshell)
-LIBTENSORFLOW_PATH = /usr/local/lib
+LIBTENSORFLOW_PATH ?= /usr/local/lib
 CFLAGS += -I$(ERLANG_PATH)
 CFLAGS += -Ic_src
 LDFLAGS += -L$(LIBTENSORFLOW_PATH)

c_src/Tensorflex.c

@@ -1160,6 +1160,69 @@ static ERL_NIF_TERM tensor_to_matrix(ErlNifEnv *env, int argc,
   return ret;
 }
 
+static ERL_NIF_TERM binary_to_matrix(ErlNifEnv *env, int argc,
+                                     const ERL_NIF_TERM argv[]) {
+  ErlNifBinary in_binary;
+  enif_inspect_binary(env, argv[0], &in_binary);
+
+  unsigned ncols, nrows;
+  enif_get_uint(env, argv[1], &nrows);
+  enif_get_uint(env, argv[2], &ncols);
+
+  Matrix * mx;
+  mx = alloc_matrix(env, nrows, ncols);
+  for (int i = 0; i < nrows; i++) {
+    for (int j = 0; j < ncols; j++) {
+      POS(mx, i, j) = in_binary.data[i * ncols + j];
+    }
+  }
+
+  ERL_NIF_TERM ret;
+  ret = enif_make_resource(env, mx);
+  enif_release_resource(mx);
+
+  return ret;
+}
+
+static ERL_NIF_TERM matrix_to_float32_tensor(ErlNifEnv *env, int argc,
+                                             const ERL_NIF_TERM argv[]) {
+  TF_Tensor *tensor;
+  TF_Tensor **tensor_resource_alloc =
+    enif_alloc_resource(tensor_resource, sizeof(TF_Tensor *));
+
+  mx_t mx;
+  if (!enif_get_resource(env, argv[0], resource_type, &mx.vp))
+    return enif_make_badarg(env);
+
+  const int size_alloc = mx.p->ncols * mx.p->nrows * sizeof(float);
+  float *data = enif_alloc(size_alloc);
+  for (int i = 0; i < mx.p->nrows; ++i) {
+    for (int j = 0; j < mx.p->ncols; ++j) {
+      data[i * mx.p->ncols + j] = (float)POS(mx.p, i, j);
+    }
+  }
+
+  int arity;
+  const ERL_NIF_TERM * array;
+  enif_get_tuple(env, argv[1], &arity, &array);
+
+  int64_t * dims = enif_alloc(arity);
+  for (int i = 0; i < arity; ++i) {
+    unsigned dim;
+    enif_get_uint(env, array[i], &dim);
+    dims[i] = dim;
+  }
+
+  tensor =
+    TF_NewTensor(TF_FLOAT, dims, arity, data, size_alloc, tensor_deallocator, 0);
+  memcpy((void *)tensor_resource_alloc, (void *)&tensor, sizeof(TF_Tensor *));
+  ERL_NIF_TERM new_tensor = enif_make_resource(env, tensor_resource_alloc);
+  enif_release_resource(tensor_resource_alloc);
+
+  enif_free(dims);
+  return enif_make_tuple2(env, enif_make_atom(env, "ok"), new_tensor);
+}
+
 static ErlNifFunc nif_funcs[] = {
     {"create_matrix", 3, create_matrix},
     {"matrix_pos", 3, matrix_pos},
@@ -1190,6 +1253,8 @@ static ErlNifFunc nif_funcs[] = {
     {"add_matrices", 2, add_matrices},
     {"subtract_matrices", 2, subtract_matrices},
     {"tensor_to_matrix", 1, tensor_to_matrix},
+    {"binary_to_matrix", 3, binary_to_matrix},
+    {"matrix_to_float32_tensor", 2, matrix_to_float32_tensor}
 };
 
 ERL_NIF_INIT(Elixir.Tensorflex.NIFs, nif_funcs, res_loader, NULL, NULL, NULL)

lib/nifs.ex

@@ -123,4 +123,12 @@ defmodule Tensorflex.NIFs do
     raise "NIF tensor_to_matrix/1 not implemented"
   end
 
+  def binary_to_matrix(_binary, _nrows, _ncols) do
+    raise "NIF binary_to_matrix/3 not implemented"
+  end
+
+  def matrix_to_float32_tensor(_matrix, _dims) do
+    raise "NIF matrix_to_float32_tensor/2 not implemented"
+  end
+
 end

lib/tensorflex.ex

@@ -1525,5 +1525,82 @@ defmodule Tensorflex do
     {nrows, ncols} = NIFs.size_of_matrix matrix_ref
     %Matrix{nrows: nrows, ncols: ncols, data: matrix_ref}
   end
-  
+
+  @doc """
+  Creates a 2-D Tensorflex matrix from a given binary by iterating through a consequently allocated bytes.
+
+  Takes three input arguments: binary data (`binary`), number of rows in matrix (`nrows`), number of columns in matrix (`ncols`).
+
+  Returns a `%Matrix` Tensorflex struct type.
+
+  ## Examples:
+
+  _Creating a new matrix_
+
+  ```elixir
+  iex(1)> mat = Tensorflex.binary_to_matrix(<<1, 2, 3, 4>>, 1, 4)
+  %Tensorflex.Matrix{
+    data: #Reference<0.2581978403.3326476294.49460>,
+    ncols: 4,
+    nrows: 1
+  }
+  ```
+
+  Useful when there's a binary (such as an image), that has to be loaded
+  into a matrix:
+
+  ```elixir
+  iex(1)> image = File.read!("/tmp/image.rgb")
+  <<19, 19, 18, 21, 18, 19, 17, 18, 22, 19, 21, 21, 21, 22, 18, ...>>
+  iex(2)> Tensorflex.binary_to_matrix(image, 100, 100 * 3)
+  %Tensorflex.Matrix{
+    data: #Reference<0.2581978403.3326476294.49326>,
+    ncols: 300,
+    nrows: 100
+  }
+  ```
+
+  """
+
+  def binary_to_matrix(binary, nrows, ncols) do
+    matrix_ref = NIFs.binary_to_matrix(binary, nrows, ncols)
+    %Matrix{nrows: nrows, ncols: ncols, data: matrix_ref}
+  end
+
+  @doc """
+  Creates a `TF_FLOAT` tensor from Tensorflex matrices with a given dimension.
+
+  Takes two arguments: a `%Matrix` matrix (`matrix1`) containing the values the
+  tensor should have a tuple with a desired dimension of a new tensor.
+
+  Returns a tuple `{:ok, %Tensor}` where `%Tensor` represents an internal
+  Tensorflex struct type that is used for holding tensor data and type.
+
+  ## Examples:
+
+  ```elixir
+  iex(1)> image = File.read!("/tmp/image.rgb")
+  <<19, 19, 18, 21, 18, 19, 17, 18, 22, 19, 21, 21, 21, 22, 18, ...>>
+
+  iex(2)> mat = Tensorflex.binary_to_matrix(image, 311, 162 * 3)
+  %Tensorflex.Matrix{
+    data: #Reference<0.2581978403.3326476294.49499>,
+    ncols: 486,
+    nrows: 311
+  }
+
+  iex(3)> Tensorflex.matrix_to_float32_tensor(mat, {1, 311, 162, 3})
+  {:ok,
+    %Tensorflex.Tensor{
+    datatype: :tf_float,
+    tensor: #Reference<0.2581978403.3326476294.49507>
+  }}
+  ```
+  """
+
+  def matrix_to_float32_tensor(%Matrix{data: matrix_ref}, dims) do
+    {:ok, ref} = NIFs.matrix_to_float32_tensor(matrix_ref, dims)
+    {:ok, %Tensor{datatype: :tf_float, tensor: ref}}
+  end
+
 end