tensor_stream 0.8.1 → 0.8.5

data/lib/tensor_stream/evaluator/opencl/kernels/min.cl

@@ -1,46 +0,0 @@
- // same dimension add floating point op
-% c_dtype = dtype_to_c_type(dtype)
- __kernel void min_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = A[globalRow * N + globalCol] <= B[globalRow * N + globalCol] ? A[globalRow * N + globalCol] : B[globalRow * N + globalCol];
-}
-
- // 1D + Scalar floating point add op
- __kernel void min_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = A[globalRow * N + globalCol] <= B[0] ? A[globalRow * N + globalCol] : B[0];
-    } else {
-      C[globalRow * N + globalCol] = B[0] <= A[globalRow * N + globalCol] ? B[0] : A[globalRow * N + globalCol];
-    }
-}
-
- // 1D + Scalar floating point add op broadcast
- __kernel void min_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    int b_m_index = globalRow;
-    int b_n_index = globalCol;
-
-    if ( b_m_index >= M2) {
-      b_m_index = b_m_index % M2;
-    };
-
-    if (b_n_index >= N2) {
-      b_n_index = b_n_index % N2;
-    }
-
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = A[globalRow * N + globalCol] <= B[b_m_index * N2 + b_n_index] ? A[globalRow * N + globalCol] : B[b_m_index * N2 + b_n_index];
-    } else {
-      C[globalRow * N + globalCol] = B[b_m_index * N2 + b_n_index] <= A[globalRow * N + globalCol] ? B[b_m_index * N2 + b_n_index] :  A[globalRow * N + globalCol];
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/mod.cl

@@ -1,3 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-% op = operator_to_c('mod')
-<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'mod', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/evaluator/opencl/kernels/mul.cl

@@ -1,3 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-% op = operator_to_c('mul')
-<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'mul', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/evaluator/opencl/kernels/negate.cl

@@ -1,8 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void negate_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = -A[globalRow * N + globalCol];
-}

data/lib/tensor_stream/evaluator/opencl/kernels/pack.cl

@@ -1,24 +0,0 @@
-% ctype = dtype_to_c_type(data_type)
-
-__kernel void pack(const int N, const int index, __global const <%= ctype %> *A, __global <%= ctype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalCol = get_global_id(0); // Col ID of C (0..N)
-
-    int start = index * <%= divisors[0] %>;
-    int ptr = start + globalCol;
-    int index_map[<%= divisors.size %>] = { <%= Array.new(divisors.size) { 0 }.join(', ') %> };
-
-    // compute effective coordinates
-<% divisors.each_with_index do |div, index| %>
-    index_map[<%= index %>] = (int)floor(ptr / (float)<%= div %>);<% if index < divisors.size - 1%>ptr = ptr % <%= div %>;<% end %><% end %>
-
-    // Apply axis translation if needed
-<% if axis > 0 %>
-    int first = index_map[0];
-<% axis.times do |i| %>
-    index_map[<%= i %>] = index_map[<%= (i + 1) %>];<% end %>
-    index_map[<%= axis %>] = first;
-<% end%>
-
-    C[<%= multipliers.each_with_index.map { |m, idx| "#{m}*index_map[#{idx}]" }.join(' + ') %>] = A[globalCol];
-}

data/lib/tensor_stream/evaluator/opencl/kernels/pow.cl

@@ -1,46 +0,0 @@
- // same dimension add floating point op
-% c_dtype = dtype_to_c_type(dtype)
- __kernel void pow_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = pow((float)A[globalRow * N + globalCol], (float)B[globalRow * N + globalCol]);
-}
-
- // 1D + Scalar floating point add op
- __kernel void pow_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-    
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = pow((float)A[globalRow * N + globalCol], (float)B[0]);
-    } else {
-      C[globalRow * N + globalCol] = pow((float)B[0], (float)A[globalRow * N + globalCol]);
-    }
-}
-
- // 1D + Scalar floating point add op broadcast
- __kernel void pow_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-    
-    int b_m_index = globalRow;
-    int b_n_index = globalCol;
-
-    if ( b_m_index >= M2) {
-      b_m_index = b_m_index % M2;
-    };
-
-    if (b_n_index >= N2) {
-      b_n_index = b_n_index % N2;
-    }
-
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = pow((float)A[globalRow * N + globalCol], (float)B[b_m_index * N2 + b_n_index]);
-    } else {
-      C[globalRow * N + globalCol] = pow((float)B[b_m_index * N2 + b_n_index], (float)A[globalRow * N + globalCol]);
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/real_div.cl

@@ -1,3 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-% op = operator_to_c('div')
-<%= render 'operand.cl', c_dtype: c_dtype, op: op, fname: 'real_div', dtype: "#{a}_#{b}", result_t: c_dtype %>

data/lib/tensor_stream/evaluator/opencl/kernels/reciprocal.cl

@@ -1,8 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void reciprocal_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = 1 / A[globalRow * N + globalCol];
-}

data/lib/tensor_stream/evaluator/opencl/kernels/round.cl

@@ -1,8 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void round_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = round(A[globalRow * N + globalCol]);
-}

data/lib/tensor_stream/evaluator/opencl/kernels/sigmoid.cl

@@ -1,9 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-
-__kernel void sigmoid_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = 1.0f/(1.0f + exp(-A[globalRow * N + globalCol]));
-}

data/lib/tensor_stream/evaluator/opencl/kernels/sigmoid_grad.cl

@@ -1,55 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-
-float sigmoid(<%= c_dtype %> x) {
-  return 1.0f/(1.0f + exp(-x));
-}
-
-float sigmoid_grad(<%= c_dtype %> x, <%= c_dtype %> g) {
-  return g * sigmoid(x) * ( 1.0f - sigmoid(x));
-}
-
- // same dimension add floating point op
- __kernel void sigmoid_grad_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = sigmoid_grad(A[globalRow * N + globalCol], B[globalRow * N + globalCol]);
-}
-
- // 1D + Scalar floating point add op
- __kernel void sigmoid_grad_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-    
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = sigmoid_grad(A[globalRow * N + globalCol], B[0]);
-    } else {
-      C[globalRow * N + globalCol] = sigmoid_grad(B[0], A[globalRow * N + globalCol]);
-    }
-}
-
- // 1D + Scalar floating point add op broadcast
- __kernel void sigmoid_grad_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op, __global const <%= c_dtype %> *A, __global const <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-    
-    int b_m_index = globalRow;
-    int b_n_index = globalCol;
-
-    if ( b_m_index >= M2) {
-      b_m_index = b_m_index % M2;
-    };
-
-    if (b_n_index >= N2) {
-      b_n_index = b_n_index % N2;
-    }
-
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = sigmoid_grad(A[globalRow * N + globalCol], B[b_m_index * N2 + b_n_index]);
-    } else {
-      C[globalRow * N + globalCol] = sigmoid_grad(B[b_m_index * N2 + b_n_index], A[globalRow * N + globalCol]);
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/sign.cl

@@ -1,21 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-
-__kernel void sign_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-    <%= c_dtype %> value = A[globalRow * N + globalCol];
-% if floating_point?(dtype)
-    if (isnan(value) || value == 0.0f) {
-      C[globalRow * N + globalCol] = 0.0;
-    } else {
-      C[globalRow * N + globalCol] = value < 0 ? -1.0 : 1.0;
-    }
-% else
-  if (value == 0) {
-    C[globalRow * N + globalCol] = 0;
-  } else {
-    C[globalRow * N + globalCol] = value < 0 ? -1 : 1;
-  }
-% end
-}

data/lib/tensor_stream/evaluator/opencl/kernels/sin.cl

@@ -1,9 +0,0 @@
-
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void sin_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = sin(A[globalRow * N + globalCol]);
-}

data/lib/tensor_stream/evaluator/opencl/kernels/softmax.cl

@@ -1,26 +0,0 @@
-// First naive implementation
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void softmax_<%= dtype %>(const int N,
-                      const __global <%= c_dtype %>* A,
-                      __global <%= c_dtype %>* C) {
-
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-
-    // Compute a single element (loop over K)
-    <%= c_dtype %> acc = 0.0f;
-    <%= c_dtype %> max = <%= min_value_for(dtype) %>;
-
-    for (int k=0; k<N; k++) {
-      max = A[globalRow*N + k] > max ? A[globalRow*N + k] : max;
-    }
-
-    for (int k=0; k<N; k++) {
-      acc += exp(A[globalRow*N + k] - max);
-    }
-
-    // Store the result
-    for (int k=0; k < N; k++) {
-      C[globalRow*N + k] = exp(A[globalRow*N + k] - max) / acc;
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/softmax_cross.cl

@@ -1,32 +0,0 @@
-
-// First naive implementation
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void softmax_cross_<%= dtype %>(const int N,
-                      const __global <%= c_dtype %>* A,
-                      const __global <%= c_dtype %>* L,
-                      __global <%= c_dtype %>* C, __global <%= c_dtype %>* P) {
-
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-
-    // Compute a single element (loop over K)
-    <%= c_dtype %> acc = 0.0f;
-    <%= c_dtype %> max = <%= min_value_for(dtype) %>;
-
-    for (int k=0; k<N; k++) {
-      max = A[globalRow*N + k] > max ? A[globalRow*N + k] : max;
-    }
-
-    for (int k=0; k<N; k++) {
-      acc += exp(A[globalRow*N + k] - max);
-    }
-
-    // Store the result
-    for (int k=0; k < N; k++) {
-      C[globalRow*N + k] = (log(acc) - (A[globalRow*N + k] - max)) * L[globalRow*N + k];
-    }
-
-    for (int k=0; k < N; k++) {
-      P[globalRow*N + k] = (exp(A[globalRow*N + k] - max) / acc) - L[globalRow*N + k];
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/softmax_cross_grad.cl

@@ -1,28 +0,0 @@
-// First naive implementation
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void softmax_cross_grad_<%= dtype %>(const int N,
-                      const __global <%= c_dtype %>* A,
-                      const __global <%= c_dtype %>* L,
-                      const __global <%= c_dtype %>* G,
-                      __global <%= c_dtype %>* C) {
-
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-
-    // Compute a single element (loop over K)
-    <%= c_dtype %> acc = 0.0f;
-    <%= c_dtype %> max = <%= min_value_for(dtype) %>;
-
-    for (int k=0; k<N; k++) {
-      max = A[globalRow*N + k] > max ? A[globalRow*N + k] : max;
-    }
-
-    for (int k=0; k<N; k++) {
-      acc += exp(A[globalRow*N + k] - max);
-    }
-
-    // Store the result
-    for (int k=0; k < N; k++) {
-      C[globalRow*N + k] = ((exp(A[globalRow*N + k] - max)/acc)  *  G[globalRow*N + k] - L[globalRow*N + k]);
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/softmax_grad.cl

@@ -1,46 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-__kernel void softmax_grad_<%= dtype %>(const int N,
-                      const __global <%= c_dtype %>* A,
-                      const __global <%= c_dtype %>* G,
-                      __global <%= c_dtype %>* C) {
-
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-
-    // Compute a single element (loop over K)
-    float acc = 0.0f;
-    float max = FLT_MIN;
-    float row[<%= size %>];
-    float grads[<%= size %>][<%= size %>];
-
-    for (int k=0; k<N; k++) {
-      max = A[globalRow*N + k] > max ? A[globalRow*N + k] : max;
-    }
-
-    for (int k=0; k<N; k++) {
-      acc += exp(A[globalRow*N + k] - max);
-    }
-
-    // Store the result
-    for (int k=0; k < N; k++) {
-      row[k] = exp(A[globalRow*N + k] - max) / acc;
-    }
-
-    for (int a=0; a < N; a++) {
-      for(int b=0; b < N; b++) {
-        if (a != b) {
-          grads[a][b] = -row[a] * row[b];
-        } else {
-          grads[a][b] = row[a] * (1.0f - row[a]);
-        }
-      }
-    }
-
-    for (int k=0; k < N; k++) {
-      float total_grad = 0.0f;
-      for (int a = 0; a < N; a++) {
-        total_grad += grads[a][k] * G[globalRow*N + a];
-      }
-      C[globalRow*N + k] = total_grad;
-    }
-}

data/lib/tensor_stream/evaluator/opencl/kernels/sqrt.cl

@@ -1,9 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-
-__kernel void sqrt_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = sqrt(A[globalRow * N + globalCol]);
-}

data/lib/tensor_stream/evaluator/opencl/kernels/square.cl

@@ -1,9 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
-
-__kernel void square_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    C[globalRow * N + globalCol] = A[globalRow * N + globalCol] * A[globalRow * N + globalCol];
-}

data/lib/tensor_stream/evaluator/opencl/kernels/squared_difference.cl

@@ -1,53 +0,0 @@
-% c_dtype = dtype_to_c_type(dtype)
- // same dimension add floating point op
- __kernel void squared_difference_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-    <%= c_dtype %> x = A[globalRow * N + globalCol];
-    <%= c_dtype %> y = B[globalRow * N + globalCol];
-    C[globalRow * N + globalCol] = (x - y) * (x - y);
-}
-
- // 1D + Scalar floating point add op
- __kernel void squared_difference_c_<%= dtype %>_<%= dtype %>(const int M, const int N, const int switch_op, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    <%= c_dtype %> x = A[globalRow * N + globalCol];
-    <%= c_dtype %> y = B[0];
-
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = (x - y) * (x - y);
-    } else {
-      C[globalRow * N + globalCol] = (y - x) * (y - x);
-    }
-}
-
- // 1D + Scalar floating point add op broadcast
- __kernel void squared_difference_b_<%= dtype %>_<%= dtype %>(const int M, const int N, const int M2, const int N2, const int switch_op,__global const <%= c_dtype %> *A, __global <%= c_dtype %> *B, __global <%= c_dtype %> *C) {
-    // Get the index of the current element to be processed
-    const int globalRow = get_global_id(0); // Row ID of C (0..M)
-    const int globalCol = get_global_id(1); // Col ID of C (0..N)
-
-    int b_m_index = globalRow;
-    int b_n_index = globalCol;
-
-    if ( b_m_index >= M2) {
-      b_m_index = b_m_index % M2;
-    };
-
-    if (b_n_index >= N2) {
-      b_n_index = b_n_index % N2;
-    }
-
-    <%= c_dtype %> x = A[globalRow * N + globalCol];
-    <%= c_dtype %> y = B[b_m_index * N2 + b_n_index];
-
-    if (switch_op == 0) {
-      C[globalRow * N + globalCol] = (x - y) * (x - y);
-    } else {
-      C[globalRow * N + globalCol] = (y - x) * (y - x);
-    }
-}