int Classemes_get_descriptor(Classemes* obj, Matrix** f_out)
{
Matrix* temp_M = NULL;
Matrix* PsiX = NULL;
int res;
assert(obj);
assert(f_out);
/* if the feature has been already computed, we return it */
if (obj->desc) {
*f_out = obj->desc;
return 0;
}
res = ImageData_get_low_level_feature_concatenation_IK(obj->img_data, &PsiX);;
if (res) {
return res;
}
/* compute classemes */
/* the following line is temp_M = 1.0*Phi*PsiX + 1.0*Tau */
temp_M = matrix_clone(Tau);
matrix_times_matrix(temp_M, Phi, false, PsiX, false, 1.0, 1.0);
obj->desc = temp_M;
*f_out = obj->desc;
return 0;
}
int Classemes_get_descriptorBIN(Classemes* obj, Matrix** f_out)
{
Matrix* temp_M = NULL;
int res;
assert(obj);
assert(f_out);
/* if the feature has been already computed, we return it */
if (obj->desc_bin) {
*f_out = obj->desc_bin;
return 0;
}
res = Classemes_get_descriptor(obj, &temp_M);
if (res) {
return res;
}
obj->desc_bin = matrix_clone(temp_M);
matrix_op_binarize(obj->desc_bin, 0.0);
*f_out = obj->desc_bin;
return 0;
}
void glScale3f(float x, float y, float z)
{
matrix_t matrix_scale;
matrix_t matrix_res;
transform_scale(&matrix_scale, x, y, z);
matrix_mul(&matrix_main, &matrix_scale, &matrix_res);
matrix_clone(&matrix_main, &matrix_res);
}
void glTransform3f(float x, float y, float z)
{
matrix_t matrix_move;
matrix_t matrix_res;
transform_move(&matrix_move, x, y, z);
matrix_mul(&matrix_main, &matrix_move, &matrix_res);
matrix_clone(&matrix_main, &matrix_res);
}
Correction *
back_propagate(
NetworkState *network_state,
Activation *activity,
Matrix expected
) {
int32_t layers = network_state->layers;
int32_t last_layer = layers - 1;
Correction *correction = correction_new(layers - 1);
Matrix error, weight_correction, input_gradient, output_gradient;
error = network_state->error(
expected,
activity->output[last_layer],
activity->input[last_layer],
network_state->derivative[last_layer]
);
correction->biases[last_layer - 1] = error;
weight_correction = matrix_new(
network_state->weights[last_layer][0], network_state->weights[last_layer][1]
);
matrix_dot_tn(activity->output[last_layer - 1], error, weight_correction);
correction->weights[last_layer - 1] = weight_correction;
for (int32_t layer = layers - 2; layer > 0; layer -= 1) {
output_gradient = matrix_new(error[0], network_state->weights[layer + 1][0]);
matrix_dot_nt(error, network_state->weights[layer + 1], output_gradient);
input_gradient = matrix_new(activity->input[layer][0], activity->input[layer][1]);
matrix_clone(input_gradient, activity->input[layer]);
activation_closure_call(network_state->derivative[layer], input_gradient);
error = matrix_new(network_state->biases[layer][0], network_state->biases[layer][1]);
matrix_multiply(output_gradient, input_gradient, error);
if (activity->mask[layer] != NULL) {
matrix_multiply(error, activity->mask[layer], error);
}
correction->biases[layer - 1] = error;
weight_correction = matrix_new(
network_state->weights[layer][0], network_state->weights[layer][1]
);
matrix_dot_tn(activity->output[layer - 1], error, weight_correction);
correction->weights[layer - 1] = weight_correction;
}
return correction;
}
int main(int argc, char * argv[])
{
int n, n_threads = 0;
matrix_t * A,
* A_orig;
vector_t * b,
* b_orig,
* x,
* check_res_mat;
double t_start, t_end;
get_input_params(argc, argv, &n);
initialize_global_state();
/* initialize data */
A_orig = matrix_create_rand(n, n),
A = matrix_clone(A_orig),
b_orig = vector_create_rand(n),
b = vector_clone(b_orig),
x = vector_create(n),
check_res_mat = vector_create(n);
t_start = get_time_in_sec();
perform_gaussian_elimination_on_matrix(A, b);
perform_back_substitution(A, x, b);
t_end = get_time_in_sec();
/* calculate Ax - b and find it's l2norm to test for correctness */
matrix_mult_vector(A_orig, x, check_res_mat);
vector_subtract(check_res_mat, check_res_mat, b_orig); /* c = c - b */
printf("num-procs = %d\n", omp_get_num_procs());
#pragma omp parallel num_threads(num_threads)
#pragma omp single
n_threads = omp_get_num_threads();
printf("num-threads = %d\n", n_threads);
printf("Performed Gaussian Elimination in %.12lfs\n", t_end - t_start);
printf("Ax-b l2norm = %.6le\n", vector_l2norm(check_res_mat));
puts("done");
return 0;
}
void glRotate3f(float angle, float x, float y, float z)
{
matrix_t matrix_rot_x;
matrix_t matrix_rot_y;
matrix_t matrix_rot_z;
matrix_t matrix_res1;
matrix_t matrix_res2;
matrix_t matrix_res3;
transform_rotate_x(&matrix_rot_x, (2*M_PI/360)*(x*angle));
transform_rotate_y(&matrix_rot_y, (2*M_PI/360)*(y*angle));
transform_rotate_z(&matrix_rot_z, (2*M_PI/360)*(z*angle));
matrix_mul(&matrix_rot_x, &matrix_rot_y, &matrix_res1);
matrix_mul(&matrix_res1, &matrix_rot_z, &matrix_res2);
matrix_mul(&matrix_main, &matrix_res2, &matrix_res3);
matrix_clone(&matrix_main, &matrix_res3);
}
/*
* Cache the Local Likelihood distributions for Q
*/
void hll_cache(hll_t *hll, double **Q, int n)
{
int i;
// allocate space, build kdtree
double **X = new_matrix2(n, hll->dx);
double ***S;
safe_calloc(S, n, double**);
for (i = 0; i < n; i++)
S[i] = new_matrix2(hll->dx, hll->dx);
kdtree_t *Q_kdtree = kdtree(Q, n, hll->dq);
// precompute LL distributions
hll_sample(X, S, Q, hll, n);
// cache in hll
hll->cache.Q_kdtree = Q_kdtree;
hll->cache.Q = matrix_clone(Q, n, hll->dq);
hll->cache.X = X;
hll->cache.S = S;
hll->cache.n = n;
}
