sbugrov

       X                  W0                  layer_1                    W1     pred    y
5.1 3.5 1.4 0.2    0.5 0.5 0.5 0.5    0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5    0.5    0.05    0
4.9 3.0 1.4 0.2    0.5 0.5 0.5 0.5    0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5    0.5    0.06    0
6.2 3.4 5.4 2.3    0.5 0.5 0.5 0.5    0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5    0.5    0.93    1
5.9 3.0 5.1 1.8    0.5 0.5 0.5 0.5    0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5    0.5    0.92    1
                                                                         0.5
                                                                         0.5
                                                                         0.5
                                                                         0.5

sbugrov

dSigmoid(dDot(X, W0, l1, X_h, X_w, l1_w), l1, X_h, l1_w);

sbugrov

__global__ void kDot(const float *m1, const float *m2, float *output, const int m1_rows , const int m1_columns, const int m2_columns ){
	/*  Computes the product of two matrices: m1 x m2.
	   	Inputs:
	    m1: array, left matrix of size m1_rows x m1_columns
	    m2: array, right matrix of size m1_columns x m2_columns (the number of rows in the right matrix
	    must be equal to the number of the columns in the left one)
	    output: array, the results of the computation are to be stored here:
	    		m1 * m2, product of two arrays m1 and m2, a matrix of size m1_rows x m2_columns
	    m1_rows: int, number of rows in the left matrix m1
	    m1_columns: int, number of columns in the left matrix m1

sbugrov

__global__ void kSigmoid(float const *input, float *output) {
    /*  Computes the value of the sigmoid function f(x) = 1/(1 + e^-x).
     Inputs:
     input: array
     output: array, the results of the computation are to be stored here
    */

    const int id = blockIdx.x * blockDim.x + threadIdx.x;

    output[id] = 1.0 / (1.0 + std::exp(-input[id]));

sbugrov

dSigmoid(dDot(l1, W1, pred, X_h, l1_w, y_w), pred, X_h, y_w);

sbugrov

dMartixByMatrixElementwise(dMartixSubstractMatrix(y, pred, pred_d, X_h, y_w), dSigmoid_d(pred, buffer, X_h, y_w), pred_d, X_h, y_w );

sbugrov

__global__ void kMartixSubstractMatrix(const float *m1, const float *m2, float *output) {
    /*  Computes the (elementwise) difference between two arrays
     Inputs:
     m1: array
     m2: array
     output: array,the results of the computation are to be stored here
     */

    const int id = blockIdx.x * blockDim.x + threadIdx.x;

sbugrov

__global__ void kMartixByMatrixElementwise(const float *m1, const float *m2, float *output) {
  /*  Computes the product of two arrays (elementwise multiplication).
   Inputs:
   m1: array
   m2: array
   output: array,the results of the multiplication are to be stored here
  */

  const int id = blockIdx.x * blockDim.x + threadIdx.x;

sbugrov

dMartixByMatrixElementwise(dDot_m1_m2T(pred_d, W1, l_1_d, X_h, y_w, l1_w), dSigmoid_d(l1, buffer, X_h, l1_w), l_1_d, X_h, l1_w);

sbugrov

__global__ void kDot_m1_m2T(const float *m1, const float *m2, float *output, const int m1_columns, const int m2_rows ){
	/*  Updates the output matrix with the product of two matrices: m1 and m2 transposed.
	   	Inputs:
	    m1: array, left matrix of size m1_rows x m1_columns
	    m2: array, right matrix of size m2_rows x m1_columns (m2 transposed will be of size m1_columns x m2_rows)
	    output: array, the results of the computation are to be stored here:
	    		m1 * m2, product of two arrays m1 and m2, a matrix of size m1_rows x m2_rows
	    m1_columns: int, number of columns in the left matrix m1
	    m2_rows: int, number of rows in the left matrix m2
	*/