view release on metacpan or  search on metacpan

C/nn.c  view on Meta::CPAN

Matrix *matrix_sigmoid(Matrix *m){
	return element_wise(m, sigmoid, NULL);
}

Matrix *matrix_ReLU(Matrix *m){
	return element_wise(m, ReLU, NULL);
}

Matrix *matrix_d_ReLU(Matrix *m){
	return element_wise(m, d_ReLU, NULL);
}

Matrix *matrix_LReLU(Matrix *m, REAL v){
	return element_wise(m, LReLU, &v);
}

Matrix *matrix_d_LReLU(Matrix *m, REAL v){
	return element_wise(m, d_LReLU, &v);
}

REAL ReLU(REAL a, void* v){
	if(a >= 0) return a;
	return 0;
}

REAL d_ReLU(REAL a, void *v){
    if(a < 0) return 0;
    return 1;
}

REAL LReLU(REAL a, void *v){
	if(a >= 0) return a;
	return a * * ((REAL*)v);
}

REAL d_LReLU(REAL a, void *v){
	if(a >= 0) return 1;
	return *((REAL*)v);
}

Matrix *matrix_softmax(Matrix *m){
	Matrix *sm = matrix_sum(m, -get_max(m));
	Matrix *em = matrix_exp(sm);
	Matrix *vm;
	if(m->rows == 1 && m->columns > 1){
			vm = sum(em, HORIZONTAL);
	}
	else if(m->columns == 1 && m->rows > 1){
			vm = sum(em, VERTICAL);
	}
	Matrix *sf = div_matrices(em, vm);
	destroy(sm);
	destroy(vm);
	destroy(em);
	return sf;
}

Matrix *matrix_d_softmax(Matrix *m){
    Matrix *exp = matrix_exp(m);
    Matrix *s = sum(exp, VERTICAL);
    return div_matrices( mul_matrices(exp, sub_matrices(s, exp)) ,s);
} 
    

Matrix *matrix_d_sigmoid(Matrix *m){
    return element_wise(m, d_sigmoid, NULL);
}

Matrix *matrix_tanh(Matrix *m){
	return element_wise(m, hyperbolic_tan, NULL);
}

Matrix *matrix_d_tanh(Matrix *m){
	return element_wise(m, d_hyperbolic_tan, NULL);
}

Matrix *matrix_exp(Matrix *m){
	return element_wise(m, exponential, NULL);
}

REAL sigmoid_cost(Matrix *X, Matrix *Y, Matrix *weights){
	Matrix *h;
	int m, i, size;
	m = Y->rows;
	h = matrix_sigmoid(dot(X,weights,0,0));
	
	//class1 = matrix_mul(mul_matrices(transpose(Y), matrix_log(h)),-1);
	//class2 = mul_matrices(matrix_sum(matrix_mul(Y, -1), 1), matrix_sum(matrix_mul(h, -1), 1));
	
	size = Y->rows * Y->columns;

# ifdef USE_REAL
	double cost = 0;
	for(i = 0; i < size; i++){
		cost += -Y->values[i]*log(h->values[i]) - ( 1 - Y->values[i]) * log(1 - h->values[i]); 
	}
# else
	float cost = 0;
	for(i = 0; i < size; i++){
		cost += -Y->values[i]*logf(h->values[i]) - ( 1 - Y->values[i]) * logf(1 - h->values[i]); 
	}
	
# endif
	return cost/m;
}

Matrix *mini_batch(Matrix *m, int start, int size, int axis){
    Matrix *r;
    int end;
    if(start < 0){
        fprintf(stderr, "start index need to be bigger or equal index 0\n");
        exit(1);
    }
    end = start + size - 1;
    if(axis == 0) // every training example is a column
    {
        if(end >= m->columns){
            fprintf(stderr, "Out of index of columns\n");
            exit(1);
        }
        r = slice(m, -1, -1, start, end);