bool hash_search( void )
/*************************/
{
unsigned i,j;
bool ok;
hashsize = num_keywords;
for( hashmask = 1; hashmask < hashsize; hashmask <<= 1 ) {
// set hashmask to 2^n greater than or equal to hashsize
}
if( flags.mask_hash ) {
hashsize = hashmask;
}
do {
for( i = 0; i < max_len; ++i ) {
for( j = 0; j < max_len + 1; ++j ) {
ok = hash_func( j, i );
if( ok ) {
if( hashsize == num_keywords ) {
output( "Perfect hash function found!\n" );
} else {
output( "Hash function found.\n" );
}
if( flags.tiny_output ) {
dump_tiny( j, i );
} else {
dump_weights( j, i );
dump_hash();
}
return( true );
}
}
}
if( !flags.imperfect )
break;
++hashsize;
} while( hashsize <= hashmask );
return( false );
}
// ------------------- MAIN ----------------- //
// ------------------------------------------ //
int main(){
srand((unsigned int)time(NULL));
Vector* training_data[MAX_INPUT_LENGHT];
Vector* teaching_data[MAX_INPUT_LENGHT];
for (int i = 0; i < MAX_INPUT_LENGHT; i++) {
training_data[i] = new_vec(DIMENSION_INPUT+1);
teaching_data[i] = new_vec(DIMENSION_OUTPUT);
}
size_t TRAINING_SET_SIZE = 0;
TRAINING_SET_SIZE = read_input(training_data, teaching_data);
// in_layer, out_layer, hid_layer_count, hid_layers
Network* network = new_network(DIMENSION_INPUT, DIMENSION_OUTPUT, 2, 4, 4);
// print_network(network);
Vector*** best_weights = malloc((network->hidden_layers_count+1) * sizeof(Vector**));
for (size_t layer = 0; layer < network->hidden_layers_count; layer++) {
best_weights[layer] = malloc(network->hidden_layers[layer]->size * sizeof(Vector*));
for (size_t neuron_id = 0; neuron_id < network->hidden_layers[layer]->size; neuron_id++) {
best_weights[layer][neuron_id] = new_vec(network->hidden_layers[layer]->neurons[neuron_id]->weights->length);
}
}
best_weights[network->hidden_layers_count] = malloc(network->output_layer->size * sizeof(Vector*));
for (size_t neuron_id = 0; neuron_id < network->output_layer->size; neuron_id++) {
best_weights[network->hidden_layers_count][neuron_id] = new_vec(network->output_layer->neurons[neuron_id]->weights->length);
}
time_t time_at_beginning = time(0);
double total_error_old = FLOAT_MAX;
double total_error = 1.0;
double minimum_error_achieved = FLOAT_MAX;
double epsilon = 0.0001;
size_t epoch_count = 0;
while ((time(0) - time_at_beginning) < 30 && (total_error = error_total(network, training_data, teaching_data, TRAINING_SET_SIZE)) > epsilon) {
if (minimum_error_achieved > total_error) {
minimum_error_achieved = total_error;
dump_weights(network, best_weights);
// print_detailed_layer(network->hidden_layers[1]);
}
for (size_t i = 0; i < TRAINING_SET_SIZE; i++) {
train_network_with_backprop(network, training_data[i], teaching_data[i]);
}
if (epoch_count % 1000 == 0) {
// printf("Epochs count: %ld\n",epoch_count);
if (fabs(total_error - total_error_old) < 0.001) {
// printf("Shaking Weights!\n");
shake_weights(network);
}
total_error_old = total_error;
// printf("Total error: %.15lf\n", total_error);
}
update_learning_rate(network, ++epoch_count);
scramble_data(training_data, teaching_data, TRAINING_SET_SIZE);
}
// printf("Network training finished with a total error: %.15lf\n", total_error);
// printf("Network training achieved a minimum total error: %.15lf\n", minimum_error_achieved);
// print_detailed_layer(network->hidden_layers[1]);
load_weights(network, best_weights);
// print_detailed_layer(network->input_layer);
// print_detailed_layer(network->hidden_layers[0]);
// print_detailed_layer(network->hidden_layers[1]);
// print_detailed_layer(network->output_layer);
test_network(network);
for (size_t layer = 0; layer < network->hidden_layers_count; layer++) {
for (size_t neuron_id = 0; neuron_id < network->hidden_layers[layer]->size; neuron_id++) {
delete_vec(best_weights[layer][neuron_id]);
}
}
for (size_t neuron_id = 0; neuron_id < network->output_layer->size; neuron_id++) {
delete_vec(best_weights[network->hidden_layers_count][neuron_id]);
}
delete_network(network);
for (int i = 0; i < MAX_INPUT_LENGHT; i++) {
delete_vec(training_data[i]);
delete_vec(teaching_data[i]);
}
return EXIT_SUCCESS;
}
void lbann_callback_dump_weights::on_epoch_end(model *m) {
dump_weights(m);
}
void lspanssi_quantise(float *x, float *xq, int ndim, int mbest_entries)
{
int i, j, n1, n2, n3, n4;
float w[LPC_ORD];
const float *codebook1 = lsp_cbvqanssi[0].cb;
const float *codebook2 = lsp_cbvqanssi[1].cb;
const float *codebook3 = lsp_cbvqanssi[2].cb;
const float *codebook4 = lsp_cbvqanssi[3].cb;
struct MBEST *mbest_stage1, *mbest_stage2, *mbest_stage3, *mbest_stage4;
float target[LPC_ORD];
int index[MBEST_STAGES];
mbest_stage1 = mbest_create(mbest_entries);
mbest_stage2 = mbest_create(mbest_entries);
mbest_stage3 = mbest_create(mbest_entries);
mbest_stage4 = mbest_create(mbest_entries);
for(i=0; i<MBEST_STAGES; i++)
index[i] = 0;
compute_weights_anssi_mode2(x, w, ndim);
#ifdef DUMP
dump_weights(w, ndim);
#endif
/* Stage 1 */
mbest_search(codebook1, x, w, ndim, lsp_cbvqanssi[0].m, mbest_stage1, index);
mbest_print("Stage 1:", mbest_stage1);
/* Stage 2 */
for (j=0; j<mbest_entries; j++) {
index[1] = n1 = mbest_stage1->list[j].index[0];
for(i=0; i<ndim; i++)
target[i] = x[i] - codebook1[ndim*n1+i];
mbest_search(codebook2, target, w, ndim, lsp_cbvqanssi[1].m, mbest_stage2, index);
}
mbest_print("Stage 2:", mbest_stage2);
/* Stage 3 */
for (j=0; j<mbest_entries; j++) {
index[2] = n1 = mbest_stage2->list[j].index[1];
index[1] = n2 = mbest_stage2->list[j].index[0];
for(i=0; i<ndim; i++)
target[i] = x[i] - codebook1[ndim*n1+i] - codebook2[ndim*n2+i];
mbest_search(codebook3, target, w, ndim, lsp_cbvqanssi[2].m, mbest_stage3, index);
}
mbest_print("Stage 3:", mbest_stage3);
/* Stage 4 */
for (j=0; j<mbest_entries; j++) {
index[3] = n1 = mbest_stage3->list[j].index[2];
index[2] = n2 = mbest_stage3->list[j].index[1];
index[1] = n3 = mbest_stage3->list[j].index[0];
for(i=0; i<ndim; i++)
target[i] = x[i] - codebook1[ndim*n1+i] - codebook2[ndim*n2+i] - codebook3[ndim*n3+i];
mbest_search(codebook4, target, w, ndim, lsp_cbvqanssi[3].m, mbest_stage4, index);
}
mbest_print("Stage 4:", mbest_stage4);
n1 = mbest_stage4->list[0].index[3];
n2 = mbest_stage4->list[0].index[2];
n3 = mbest_stage4->list[0].index[1];
n4 = mbest_stage4->list[0].index[0];
for (i=0;i<ndim;i++)
xq[i] = codebook1[ndim*n1+i] + codebook2[ndim*n2+i] + codebook3[ndim*n3+i] + codebook4[ndim*n4+i];
mbest_destroy(mbest_stage1);
mbest_destroy(mbest_stage2);
mbest_destroy(mbest_stage3);
mbest_destroy(mbest_stage4);
}
void lbann_callback_dump_weights::on_train_begin(model *m) {
dump_weights(m, "initial");
}
