int main(){
tnn_param p, io;
tnn_state in, out, *s;
tnn_module m;
int i;
printf("Initializing state in: %s\n", TEST_FUNC(tnn_state_init(&in, A)));
printf("Initializing state out: %s\n", TEST_FUNC(tnn_state_init(&out, B)));
printf("Initializing paramter p: %s\n", TEST_FUNC(tnn_param_init(&p)));
printf("Initializing paramter io: %s\n", TEST_FUNC(tnn_param_init(&io)));
printf("Allocating state in: %s\n", TEST_FUNC(tnn_param_state_alloc(&io, &in)));
printf("Allocating state out: %s\n", TEST_FUNC(tnn_param_state_alloc(&io, &out)));
printf("Initializing module m: %s\n", TEST_FUNC(tnn_module_init_sum(&m, &in, &out, &io)));
printf("Debugging module m: %s\n", TEST_FUNC(tnn_module_debug(&m)));
printf("Setting input\n");
for(i = 0; i < in.size; i = i + 1){
gsl_vector_set(&in.x, i, (double)(C+i));
}
printf("Setting output\n");
for(i = 0; i < out.size; i = i + 1){
gsl_vector_set(&out.dx, i, 2.0*(double)(D+i));
}
printf("Radomizing weights using polymorphic call: %s\n", TEST_FUNC(tnn_module_randomize(&m, 1.0)));
printf("Debugging module m: %s\n", TEST_FUNC(tnn_module_debug(&m)));
printf("Executing fprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_fprop(&m)));
printf("Debugging module m: %s\n", TEST_FUNC(tnn_module_debug(&m)));
printf("Executing bprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_bprop(&m)));
printf("Debugging module m: %s\n", TEST_FUNC(tnn_module_debug(&m)));
for(i = 0; i < A/B; i = i + 1){
printf("Executing get: %s\n", TEST_FUNC(tnn_module_sum_get(&m, &s, i)));
printf("Debugging s: %s\n", TEST_FUNC(tnn_state_debug(s)));
}
printf("Debugging parameter p: %s\n", TEST_FUNC(tnn_param_debug(&p)));
printf("Debugging parameter io: %s\n", TEST_FUNC(tnn_param_debug(&io)));
printf("Destroying paramter p: %s\n", TEST_FUNC(tnn_param_destroy(&p)));
printf("Destroying paramter io: %s\n", TEST_FUNC(tnn_param_destroy(&io)));
printf("Destroy module m using polymorphic call: %s\n", TEST_FUNC(tnn_module_destroy(&m)));
printf("Debugging module m: %s\n", TEST_FUNC(tnn_module_debug(&m)));
return 0;
}
tnn_error tnn_module_init_bias(tnn_module *m, tnn_state *input, tnn_state *output, tnn_param *p){
tnn_error ret;
//Check whether the output state has the same size with the input
if(input->size != output->size){
return TNN_ERROR_STATE_INCOMP;
}
//Define type
m->t = TNN_MODULE_TYPE_BIAS;
//No consant parameters
m->c = NULL;
//Allocate the paramter states
tnn_state_init(&m->w, input->size);
TNN_MACRO_ERRORTEST(tnn_param_state_alloc(p, &m->w), ret);
//Link the inputs and outputs
m->input = input;
m->output = output;
//Store the functions
m->bprop = &tnn_module_bprop_bias;
m->fprop = &tnn_module_fprop_bias;
m->randomize = &tnn_module_randomize_bias;
m->destroy = &tnn_module_destroy_bias;
m->clone = &tnn_module_clone_bias;
m->debug = &tnn_module_debug_bias;
return TNN_ERROR_SUCCESS;
}
tnn_error tnn_module_init_linear(tnn_module *m, tnn_state *input, tnn_state *output, tnn_param *p){
tnn_error ret;
//Defined type
m->t = TNN_MODULE_TYPE_LINEAR;
//No constant paramters
m->c = NULL;
//Allocate the parameter states
tnn_state_init(&m->w, input->size*output->size);
TNN_MACRO_ERRORTEST(tnn_param_state_alloc(p,&m->w), ret);
//Link the inputs and outputs
m->input = input;
m->output = output;
//Store the functions
m->bprop = &tnn_module_bprop_linear;
m->fprop = &tnn_module_fprop_linear;
m->randomize = &tnn_module_randomize_linear;
m->destroy = &tnn_module_destroy_linear;
m->debug = &tnn_module_debug_linear;
m->clone = &tnn_module_clone_linear;
return TNN_ERROR_SUCCESS;
}
tnn_error tnn_module_clone_bias(tnn_module *m1, tnn_module *m2, tnn_param *p, tnn_pstable *t){
tnn_error ret;
//Routine check
if(m1->t != TNN_MODULE_TYPE_BIAS){
return TNN_ERROR_MODULE_MISTYPE;
}
//Retrieve input and output
TNN_MACRO_ERRORTEST(tnn_pstable_find(t, m1->input, &m2->input), ret);
TNN_MACRO_ERRORTEST(tnn_pstable_find(t, m1->output, &m2->output), ret);
if(m1->input->size != m2->input->size || m1->output->size != m2->output->size){
return TNN_ERROR_STATE_INCOMP;
}
//Defined type
m2->t = TNN_MODULE_TYPE_BIAS;
//No constant paramters
m2->c = NULL;
//Allocate the parameter states
tnn_state_init(&m2->w, m2->input->size);
TNN_MACRO_ERRORTEST(tnn_param_state_alloc(p,&m2->w), ret);
//Store the functions
m2->bprop = &tnn_module_bprop_bias;
m2->fprop = &tnn_module_fprop_bias;
m2->randomize = &tnn_module_randomize_bias;
m2->destroy = &tnn_module_destroy_bias;
m2->debug = &tnn_module_debug_bias;
m2->clone = &tnn_module_clone_bias;
//Copy the state
TNN_MACRO_ERRORTEST(tnn_state_copy(&m1->w, &m2->w), ret);
return TNN_ERROR_SUCCESS;
}
int main(){
tnn_state s[N];
tnn_state t, u, v;
tnn_param p;
tnn_state *sp;
int i,j;
//Initialize all the states
for(i = 0; i < N; i = i + 1){
printf("Initializing state %d: %s\n", i, TEST_FUNC(tnn_state_init(&s[i], i + M)));
printf("Initialized state %d to be size %d, valid %d.\n", i, s[i].size, s[i].valid);
}
//Initialize the parameter
printf("Initializing parameter: %s\n", TEST_FUNC(tnn_param_init(&p)));
tnn_param_debug(&p);
//Allocate states in the paramter
for(i = 0; i < N; i = i + 1){
printf("Allocating state %d: %s\n", i, TEST_FUNC(tnn_param_state_alloc(&p, &s[i])));
printf("Allocated state %d to be valid %d, vector owner %d.\n", i, s[i].valid, s[i].x.owner);
tnn_param_debug(&p);
}
//Initialize the values in the vector
for(i = 0; i < p.x->size; i = i + 1){
gsl_vector_set(p.x, i, i + A);
gsl_vector_set(p.dx, i, i + B);
}
tnn_param_debug(&p);
//Initialize values for t using calloc
printf("Initializing state t: %s\n", TEST_FUNC(tnn_state_init(&t, I)));
printf("Initialized state t to be size %d, valid %d.\n", t.size, t.valid);
printf("Allocating state t: %s\n", TEST_FUNC(tnn_param_state_calloc(&p, &t)));
printf("Allocated state t to be valid %d, vector owner %d.\n", t.valid, t.x.owner);
tnn_param_debug(&p);
printf("Initializing state u: %s\n", TEST_FUNC(tnn_state_init(&u, J)));
printf("Getting subvector u: %s\n", TEST_FUNC(tnn_param_state_sub(&p, &s[N-1], &u, 1)));
tnn_param_debug(&p);
printf("Initializing state v: %s\n", TEST_FUNC(tnn_state_init(&v, s[N-1].size)));
tnn_state_debug(&v);
printf("Allocating state v: %s\n", TEST_FUNC(tnn_param_state_calloc(&p, &v)));
printf("Copying s to v: %s\n", TEST_FUNC(tnn_state_copy(&s[N-1],&v)));
tnn_state_debug(&v);
tnn_param_debug(&p);
//Destroy the parameter
printf("Destroying the paramter: %s.\n", TEST_FUNC(tnn_param_destroy(&p)));
printf("Destroyed paramter x = %d, dx = %d, states = %d, size = %d.\n", p.x, p.dx, p.states, p.size);
for(i = 0; i < N; i = i + 1){
printf("Destroyed state %d, valid: %d\n", i, s[i].valid);
}
printf("Destroyed state t, valid: %d\n", t.valid);
printf("Destroyed state u, valid: %d\n", u.valid);
tnn_param_debug(&p);
//Delete paramter experiment
printf("Initializing paramter: %s\n", TEST_FUNC(tnn_param_init(&p)));
for(i = 0; i < N; i = i + 1){
sp = (tnn_state *) malloc(sizeof(tnn_state));
printf("Initializing sp %p: %s\n", sp, TEST_FUNC(tnn_state_init(sp,A+i)));
printf("Allocating sp %p: %s\n", sp, TEST_FUNC(tnn_param_state_calloc(&p, sp)));
}
printf("Debugging paramter: %s\n", TEST_FUNC(tnn_param_debug(&p)));
printf("Free paramter: %s\n", TEST_FUNC(tnn_param_free(&p)));
printf("Debugging paramter: %s\n", TEST_FUNC(tnn_param_debug(&p)));
}
int main(){
tnn_param p, q, io, oi;
tnn_state in, out;
tnn_module m, l;
int i;
tnn_pstable t;
srand(time(NULL));
printf("Initializing state in: %s\n", TEST_FUNC(tnn_state_init(&in, A)));
printf("Initializing state out: %s\n", TEST_FUNC(tnn_state_init(&out, B)));
printf("Initializing paramter p: %s\n", TEST_FUNC(tnn_param_init(&p)));
printf("Initializing paramter io: %s\n", TEST_FUNC(tnn_param_init(&io)));
printf("Allocating state in: %s\n", TEST_FUNC(tnn_param_state_alloc(&io, &in)));
printf("Allocating state out: %s\n", TEST_FUNC(tnn_param_state_alloc(&io, &out)));
printf("Allocating state out again: %s\n", TEST_FUNC(tnn_param_state_alloc(&io, &out)));
printf("Initializing module m: %s\n", TEST_FUNC(tnn_module_init_linear(&m, &in, &out, &p)));
printf("Initialized module t = %ld, c = %ld, w.size = %d, input = %ld, output = %ld, bprop = %ld, fprop = %ld, randomize = %ld, destroy = %ld\n",
(long)m.t, (long)m.c, (int)m.w.size, (long)m.input, (long)m.output, (long)m.bprop, (long)m.fprop, (long)m.randomize, (long)m.destroy);
printf("Setting input\n");
for(i = 0; i < in.size; i = i + 1){
gsl_vector_set(&in.x, i, (double)(C+i));
}
printf("Debugging using polymorphic call: %s\n", TEST_FUNC(tnn_module_debug(&m)));
printf("Setting output\n");
for(i = 0; i < out.size; i = i + 1){
gsl_vector_set(&out.dx, i, E + (double)i/10.0);
}
printf("Debugging using polymorphic call: %s\n", TEST_FUNC(tnn_module_debug(&m)));
printf("Radomizing weights using polymorphic call: %s\n", TEST_FUNC(tnn_module_randomize(&m, 1.0)));
printState(&m.w);
printf("Executing fprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_fprop(&m)));
printState(&out);
printf("Executing bprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_bprop(&m)));
printf("Debugging using polymorphic call: %s\n", TEST_FUNC(tnn_module_debug(&m)));
//Cloning test
printf("Initializing parameter q: %s\n", TEST_FUNC(tnn_param_init(&q)));
printf("Initializing parameter oi: %s\n", TEST_FUNC(tnn_param_init(&oi)));
printf("Initializing pstable t: %s\n", TEST_FUNC(tnn_pstable_init(&t)));
printf("Constructing t with oi from io: %s\n", TEST_FUNC(tnn_pstable_param_alloc(&t, &io, &oi)));
printf("Debugging pstable t: %s\n", TEST_FUNC(tnn_pstable_debug(&t)));
printf("Debugging paramter oi: %s\n", TEST_FUNC(tnn_param_debug(&oi)));
printf("Cloning m to l: %s\n", TEST_FUNC(tnn_module_clone(&m,&l,&q, &t)));
printf("Debugging l: %s\n", TEST_FUNC(tnn_module_debug(&l)));
printf("Radomizing weights using polymorphic call: %s\n", TEST_FUNC(tnn_module_randomize(&l, 1.0)));
printf("Executing fprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_fprop(&l)));
printf("Executing bprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_bprop(&l)));
printf("Debugging l: %s\n", TEST_FUNC(tnn_module_debug(&l)));
printf("Freeing paramter oi: %s\n", TEST_FUNC(tnn_param_free(&oi)));
printf("Destroying paramter q: %s\n", TEST_FUNC(tnn_param_destroy(&q)));
printf("Destroying pstable t: %s\n", TEST_FUNC(tnn_pstable_destroy(&t)));
printf("Destroying paramter p: %s\n", TEST_FUNC(tnn_param_destroy(&p)));
printf("Destroying paramter io: %s\n", TEST_FUNC(tnn_param_destroy(&io)));
printf("Radomizing weights using polymorphic call: %s\n", TEST_FUNC(tnn_module_randomize(&m, 1.0)));
printf("Executing fprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_fprop(&m)));
printf("Executing bprop using polymorphic call: %s\n", TEST_FUNC(tnn_module_bprop(&m)));
printf("Destroy module m using polymorphic call: %s\n", TEST_FUNC(tnn_module_destroy(&m)));
return 0;
}
