[libfann] 185/242: moved activation and steepness to neuron
Christian Kastner
chrisk-guest at moszumanska.debian.org
Sat Oct 4 21:10:41 UTC 2014
This is an automated email from the git hooks/post-receive script.
chrisk-guest pushed a commit to tag Version2_0_0
in repository libfann.
commit b2956b94e7b434fcd8fd4c23e5b4f937759d5aad
Author: Steffen Nissen <lukesky at diku.dk>
Date: Mon Jul 18 22:35:42 2005 +0000
moved activation and steepness to neuron
---
examples/xor_train.c | 1 -
src/fann.c | 237 ++++++++++++++++----------------------------
src/fann_cascade.c | 18 ++--
src/fann_io.c | 191 ++++++++++++++++++++++++++++++++---
src/fann_options.c | 205 ++++++++++++++------------------------
src/fann_train.c | 38 ++++---
src/include/fann_data.h | 18 ++--
src/include/fann_internal.h | 7 +-
8 files changed, 382 insertions(+), 333 deletions(-)
diff --git a/examples/xor_train.c b/examples/xor_train.c
index 63f6318..d98db4f 100644
--- a/examples/xor_train.c
+++ b/examples/xor_train.c
@@ -56,7 +56,6 @@ int main()
data = fann_read_train_from_file("xor.data");
-
fann_set_activation_steepness_hidden(ann, 1);
fann_set_activation_steepness_output(ann, 1);
fann_set_rprop_delta_max(ann, 50);
diff --git a/src/fann.c b/src/fann.c
index 8d813c0..71d5fba 100644
--- a/src/fann.c
+++ b/src/fann.c
@@ -95,8 +95,7 @@ FANN_EXTERNAL struct fann * FANN_API fann_create_array(float connection_rate, fl
#ifdef FIXEDFANN
decimal_point = ann->decimal_point;
multiplier = ann->multiplier;
- fann_update_stepwise_hidden(ann);
- fann_update_stepwise_output(ann);
+ fann_update_stepwise(ann);
#endif
/* determine how many neurons there should be in each layer */
@@ -144,6 +143,13 @@ FANN_EXTERNAL struct fann * FANN_API fann_create_array(float connection_rate, fl
layer_it->first_neuron[i].first_con = ann->total_connections + allocated_connections;
allocated_connections += connections_per_neuron;
layer_it->first_neuron[i].last_con = ann->total_connections + allocated_connections;
+
+ layer_it->first_neuron[i].activation_function = FANN_SIGMOID_STEPWISE;
+#ifdef FIXEDFANN
+ layer_it->first_neuron[i].activation_steepness = ann->multiplier/2;
+#else
+ layer_it->first_neuron[i].activation_steepness = 0.5;
+#endif
if(allocated_connections < (num_connections*(i+1))/num_neurons_out){
layer_it->first_neuron[i].last_con++;
@@ -354,8 +360,7 @@ FANN_EXTERNAL struct fann * FANN_API fann_create_shortcut_array(float learning_r
#ifdef FIXEDFANN
decimal_point = ann->decimal_point;
multiplier = ann->multiplier;
- fann_update_stepwise_hidden(ann);
- fann_update_stepwise_output(ann);
+ fann_update_stepwise(ann);
#endif
/* determine how many neurons there should be in each layer */
@@ -399,6 +404,13 @@ FANN_EXTERNAL struct fann * FANN_API fann_create_shortcut_array(float learning_r
layer_it->first_neuron[i].first_con = ann->total_connections;
ann->total_connections += num_neurons_in+1;
layer_it->first_neuron[i].last_con = ann->total_connections;
+
+ layer_it->first_neuron[i].activation_function = FANN_SIGMOID_STEPWISE;
+#ifdef FIXEDFANN
+ layer_it->first_neuron[i].activation_steepness = ann->multiplier/2;
+#else
+ layer_it->first_neuron[i].activation_steepness = 0.5;
+#endif
}
#ifdef DEBUG
@@ -445,19 +457,14 @@ FANN_EXTERNAL struct fann * FANN_API fann_create_shortcut_array(float learning_r
FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type *input)
{
struct fann_neuron *neuron_it, *last_neuron, *neurons, **neuron_pointers;
- unsigned int activation_function, i, num_connections, num_input, num_output;
+ unsigned int i, num_connections, num_input, num_output;
fann_type neuron_sum, *output;
fann_type *weights;
struct fann_layer *layer_it, *last_layer;
-
-
- /* store some variabels local for fast access */
+ unsigned int activation_function;
fann_type steepness;
- const fann_type activation_steepness_output = ann->activation_steepness_output;
- const fann_type activation_steepness_hidden = ann->activation_steepness_hidden;
- unsigned int activation_function_output = ann->activation_function_output;
- unsigned int activation_function_hidden = ann->activation_function_hidden;
+ /* store some variabels local for fast access */
struct fann_neuron *first_neuron = ann->first_layer->first_neuron;
#ifdef FIXEDFANN
@@ -465,34 +472,11 @@ FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type *input)
unsigned int decimal_point = ann->decimal_point;
/* values used for the stepwise linear sigmoid function */
- fann_type rh1 = 0, rh2 = 0, rh3 = 0, rh4 = 0, rh5 = 0, rh6 = 0;
- fann_type h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0;
+ fann_type r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0;
+ fann_type v1 = 0, v2 = 0, v3 = 0, v4 = 0, v5 = 0, v6 = 0;
- switch(ann->activation_function_hidden)
- {
- case FANN_SIGMOID:
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_STEPWISE:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- /* the hidden results */
- rh1 = ann->activation_results_hidden[0];
- rh2 = ann->activation_results_hidden[1];
- rh3 = ann->activation_results_hidden[2];
- rh4 = ann->activation_results_hidden[3];
- rh5 = ann->activation_results_hidden[4];
- rh6 = ann->activation_results_hidden[5];
-
- /* the hidden parameters */
- h1 = ann->activation_values_hidden[0];
- h2 = ann->activation_values_hidden[1];
- h3 = ann->activation_values_hidden[2];
- h4 = ann->activation_values_hidden[3];
- h5 = ann->activation_values_hidden[4];
- h6 = ann->activation_values_hidden[5];
- break;
- default:
- break;
- }
+ fann_type last_steepness = 0;
+ unsigned int last_activation_function = 0;
#endif
/* first set the input */
@@ -515,46 +499,9 @@ FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type *input)
last_layer = ann->last_layer;
for(layer_it = ann->first_layer+1; layer_it != last_layer; layer_it++)
{
- steepness = (layer_it == last_layer-1) ?
- activation_steepness_output : activation_steepness_hidden;
-
- activation_function = (layer_it == last_layer-1) ?
- activation_function_output : activation_function_hidden;
-
-#ifdef FIXEDFANN
- if(layer_it == layer_it-1 &&
- ann->activation_function_output != ann->activation_function_hidden)
- {
- switch(ann->activation_function_output)
- {
- case FANN_SIGMOID:
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_STEPWISE:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- /* the output results */
- rh1 = ann->activation_results_output[0];
- rh2 = ann->activation_results_output[1];
- rh3 = ann->activation_results_output[2];
- rh4 = ann->activation_results_output[3];
- rh5 = ann->activation_results_output[4];
- rh6 = ann->activation_results_output[5];
-
- /* the output parameters */
- h1 = ann->activation_values_output[0];
- h2 = ann->activation_values_output[1];
- h3 = ann->activation_values_output[2];
- h4 = ann->activation_values_output[3];
- h5 = ann->activation_values_output[4];
- h6 = ann->activation_values_output[5];
- break;
- default:
- break;
- }
- }
-#endif
-
last_neuron = layer_it->last_neuron;
- for(neuron_it = layer_it->first_neuron; neuron_it != last_neuron; neuron_it++){
+ for(neuron_it = layer_it->first_neuron; neuron_it != last_neuron; neuron_it++)
+ {
if(neuron_it->first_con == neuron_it->last_con){
/* bias neurons */
#ifdef FIXEDFANN
@@ -565,6 +512,20 @@ FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type *input)
continue;
}
+ activation_function = neuron_it->activation_function;
+ steepness = neuron_it->activation_steepness;
+ /* TODO REMOVE BEGIN
+ if(layer_it == last_layer-1)
+ activation_function = FANN_SIGMOID_SYMMETRIC;
+ else
+ activation_function = FANN_SIGMOID;
+#ifdef FIXEDFANN
+ steepness = multiplier/2.0;
+#else
+ steepness = 0.5;
+#endif
+ TODO REMOVE END */
+
neuron_sum = 0;
num_connections = neuron_it->last_con - neuron_it->first_con;
weights = ann->weights + neuron_it->first_con;
@@ -629,19 +590,58 @@ FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type *input)
}
}
- neuron_sum = fann_mult(steepness, neuron_sum);
- neuron_it->sum = neuron_sum;
-
#ifdef FIXEDFANN
+ neuron_it->sum = fann_mult(steepness, neuron_sum);
+
+ if(activation_function != last_activation_function ||
+ steepness != last_steepness)
+ {
+ switch(activation_function)
+ {
+ case FANN_SIGMOID:
+ case FANN_SIGMOID_STEPWISE:
+ r1 = ann->sigmoid_results[0];
+ r2 = ann->sigmoid_results[1];
+ r3 = ann->sigmoid_results[2];
+ r4 = ann->sigmoid_results[3];
+ r5 = ann->sigmoid_results[4];
+ r6 = ann->sigmoid_results[5];
+ v1 = ann->sigmoid_values[0]/steepness;
+ v2 = ann->sigmoid_values[1]/steepness;
+ v3 = ann->sigmoid_values[2]/steepness;
+ v4 = ann->sigmoid_values[3]/steepness;
+ v5 = ann->sigmoid_values[4]/steepness;
+ v6 = ann->sigmoid_values[5]/steepness;
+ break;
+ case FANN_SIGMOID_SYMMETRIC:
+ case FANN_SIGMOID_SYMMETRIC_STEPWISE:
+ r1 = ann->sigmoid_symmetric_results[0];
+ r2 = ann->sigmoid_symmetric_results[1];
+ r3 = ann->sigmoid_symmetric_results[2];
+ r4 = ann->sigmoid_symmetric_results[3];
+ r5 = ann->sigmoid_symmetric_results[4];
+ r6 = ann->sigmoid_symmetric_results[5];
+ v1 = ann->sigmoid_symmetric_values[0]/steepness;
+ v2 = ann->sigmoid_symmetric_values[1]/steepness;
+ v3 = ann->sigmoid_symmetric_values[2]/steepness;
+ v4 = ann->sigmoid_symmetric_values[3]/steepness;
+ v5 = ann->sigmoid_symmetric_values[4]/steepness;
+ v6 = ann->sigmoid_symmetric_values[5]/steepness;
+ break;
+ default:
+ break;
+ }
+ }
+
switch(activation_function)
{
case FANN_SIGMOID:
case FANN_SIGMOID_STEPWISE:
- neuron_it->value = (fann_type)fann_stepwise(h1, h2, h3, h4, h5, h6, rh1, rh2, rh3, rh4, rh5, rh6, 0, multiplier, neuron_sum);
+ neuron_it->value = (fann_type)fann_stepwise(v1, v2, v3, v4, v5, v6, r1, r2, r3, r4, r5, r6, 0, multiplier, neuron_sum);
break;
case FANN_SIGMOID_SYMMETRIC:
case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- neuron_it->value = (fann_type)fann_stepwise(h1, h2, h3, h4, h5, h6, rh1, rh2, rh3, rh4, rh5, rh6, -multiplier, multiplier, neuron_sum);
+ neuron_it->value = (fann_type)fann_stepwise(v1, v2, v3, v4, v5, v6, r1, r2, r3, r4, r5, r6, -multiplier, multiplier, neuron_sum);
break;
case FANN_THRESHOLD:
neuron_it->value = (fann_type)((neuron_sum < 0) ? 0 : 1);
@@ -652,65 +652,14 @@ FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type *input)
default:
fann_error((struct fann_error *)ann, FANN_E_CANT_USE_ACTIVATION);
}
+ last_steepness = steepness;
+ last_activation_function = activation_function;
#else
+ neuron_sum = fann_mult(steepness, neuron_sum);
+ neuron_it->sum = neuron_sum;
+
fann_activation_switch(ann, activation_function, neuron_sum, neuron_it->value);
#endif
- /*
- printf(" sum=%f, value=%f\n", neuron_it->sum, neuron_it->value);
- switch(activation_function){
-#ifdef FIXEDFANN
- case FANN_SIGMOID:
- case FANN_SIGMOID_STEPWISE:
- neuron_it->value = (fann_type)fann_stepwise(h1, h2, h3, h4, h5, h6, rh1, rh2, rh3, rh4, rh5, rh6, 0, multiplier, neuron_sum);
- break;
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- neuron_it->value = (fann_type)fann_stepwise(h1, h2, h3, h4, h5, h6, rh1, rh2, rh3, rh4, rh5, rh6, -multiplier, multiplier, neuron_sum);
- break;
-#else
- case FANN_LINEAR:
- neuron_it->value = (fann_type)fann_linear(steepness, neuron_sum);
- break;
-
- case FANN_SIGMOID:
- neuron_it->value = (fann_type)fann_sigmoid(steepness, neuron_sum);
- break;
-
- case FANN_SIGMOID_SYMMETRIC:
- neuron_it->value = (fann_type)fann_sigmoid_symmetric(steepness, neuron_sum);
- break;
-
- case FANN_SIGMOID_STEPWISE:
- neuron_it->value = (fann_type)fann_stepwise(h1, h2, h3, h4, h5, h6, rh1, rh2, rh3, rh4, rh5, rh6, 0, 1, neuron_sum);
- break;
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- neuron_it->value = (fann_type)fann_stepwise(h1, h2, h3, h4, h5, h6, rh1, rh2, rh3, rh4, rh5, rh6, -1, 1, neuron_sum);
- break;
-#endif
- case FANN_THRESHOLD:
- neuron_it->value = (fann_type)((neuron_sum < 0) ? 0 : 1);
- break;
- case FANN_THRESHOLD_SYMMETRIC:
- neuron_it->value = (fann_type)((neuron_sum < 0) ? -1 : 1);
- break;
- case FANN_GAUSSIAN:
- neuron_it->value = (fann_type)fann_gaussian(steepness, neuron_sum);
- break;
- case FANN_GAUSSIAN_SYMMETRIC:
- neuron_it->value = (fann_type)fann_gaussian_symmetric(steepness, neuron_sum);
- break;
- case FANN_ELLIOT:
- neuron_it->value = (fann_type)fann_elliot(steepness, neuron_sum);
- break;
- case FANN_ELLIOT_SYMMETRIC:
- neuron_it->value = (fann_type)fann_elliot_symmetric(steepness, neuron_sum);
- break;
- default:
- fann_error((struct fann_error *)ann, FANN_E_CANT_USE_ACTIVATION);
- }
- */
- /*if((int)(neuron_it->value*1000.0) != (int)(fann_activation_new(ann, activation_function, steepness, neuron_sum)*1000.0))
- printf("Wrong activation calculated %f != %f\n", neuron_it->value, fann_activation_new(ann, activation_function, steepness, neuron_sum));*/
}
}
@@ -942,16 +891,6 @@ struct fann * fann_allocate_structure(float learning_rate, unsigned int num_laye
ann->multiplier = 256;
#endif
- ann->activation_function_hidden = FANN_SIGMOID_STEPWISE;
- ann->activation_function_output = FANN_SIGMOID_STEPWISE;
-#ifdef FIXEDFANN
- ann->activation_steepness_hidden = ann->multiplier/2;
- ann->activation_steepness_output = ann->multiplier/2;
-#else
- ann->activation_steepness_hidden = 0.5;
- ann->activation_steepness_output = 0.5;
-#endif
-
/* allocate room for the layers */
ann->first_layer = (struct fann_layer *)calloc(num_layers, sizeof(struct fann_layer));
if(ann->first_layer == NULL){
diff --git a/src/fann_cascade.c b/src/fann_cascade.c
index 4397433..c0454d8 100644
--- a/src/fann_cascade.c
+++ b/src/fann_cascade.c
@@ -574,14 +574,14 @@ void fann_update_candidate_slopes(struct fann *ann)
*/
/* unrolled loop end */
- activation = fann_activation(ann, ann->activation_function_hidden, ann->activation_steepness_hidden, cand_sum);
+ activation = fann_activation(ann, cand_it->activation_function, cand_it->activation_steepness, cand_sum);
/* printf("%f = sigmoid(%f);\n", activation, cand_sum);*/
cand_it->sum = cand_sum;
cand_it->value = activation;
- derived = fann_activation_derived(ann->activation_function_hidden,
- ann->activation_steepness_hidden, activation, cand_sum);
+ derived = fann_activation_derived(cand_it->activation_function,
+ cand_it->activation_steepness, activation, cand_sum);
/* The output weights is located right after the input weights in
the weight array.
@@ -637,6 +637,7 @@ float fann_train_candidates_epoch(struct fann *ann, struct fann_train_data *data
fann_type best_score;
unsigned int num_cand = ann->cascade_num_candidates;
fann_type *output_train_errors = ann->train_errors + (ann->total_neurons - ann->num_output);
+ struct fann_neuron *output_neurons = (ann->last_layer-1)->first_neuron;
for(i = 0; i < num_cand; i++){
/* The ann->MSE_value is actually the sum squared error */
@@ -660,9 +661,14 @@ float fann_train_candidates_epoch(struct fann *ann, struct fann_train_data *data
output_train_errors[j] = (data->output[i][j] - ann->output[j]);
- if(ann->activation_function_output == FANN_SIGMOID_SYMMETRIC ||
- ann->activation_function_output == FANN_SIGMOID_SYMMETRIC_STEPWISE){
- output_train_errors[j] /= 2.0;
+ switch(output_neurons[j].activation_function)
+ {
+ case FANN_SIGMOID_SYMMETRIC:
+ case FANN_SIGMOID_SYMMETRIC_STEPWISE:
+ case FANN_ELLIOT_SYMMETRIC:
+ case FANN_GAUSSIAN_SYMMETRIC:
+ output_train_errors[j] /= 2.0;
+ break;
}
}
diff --git a/src/fann_io.c b/src/fann_io.c
index eab1049..d4c265a 100644
--- a/src/fann_io.c
+++ b/src/fann_io.c
@@ -149,18 +149,28 @@ int fann_save_internal_fd(struct fann *ann, FILE *conf, const char *configuratio
/* save the decimal_point on a seperate line */
fprintf(conf, "%u\n", decimal_point);
- /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output" */
+ /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output"
fprintf(conf, "%u %f %f %u %u %u %d %d\n", ann->last_layer - ann->first_layer, ann->learning_rate, ann->connection_rate, ann->shortcut_connections, ann->activation_function_hidden, ann->activation_function_output, (int)(ann->activation_steepness_hidden * fixed_multiplier), (int)(ann->activation_steepness_output * fixed_multiplier));
+ */
+ /* save the number layers "num_layers learning_rate connection_rate shortcut_connections" */
+ fprintf(conf, "%u %f %f %u\n", ann->last_layer - ann->first_layer, ann->learning_rate, ann->connection_rate, ann->shortcut_connections);
}else{
- /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output" */
+ /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output"
fprintf(conf, "%u %f %f %u %u %u "FANNPRINTF" "FANNPRINTF"\n", ann->last_layer - ann->first_layer, ann->learning_rate, ann->connection_rate, ann->shortcut_connections, ann->activation_function_hidden, ann->activation_function_output, ann->activation_steepness_hidden, ann->activation_steepness_output);
+ */
+ /* save the number layers "num_layers learning_rate connection_rate shortcut_connections" */
+ fprintf(conf, "%u %f %f %u\n", ann->last_layer - ann->first_layer, ann->learning_rate, ann->connection_rate, ann->shortcut_connections);
}
#else
/* save the decimal_point on a seperate line */
fprintf(conf, "%u\n", ann->decimal_point);
- /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output" */
+ /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output"
fprintf(conf, "%u %f %f %u %u %u "FANNPRINTF" "FANNPRINTF"\n", ann->last_layer - ann->first_layer, ann->learning_rate, ann->connection_rate, ann->shortcut_connections, ann->activation_function_hidden, ann->activation_function_output, ann->activation_steepness_hidden, ann->activation_steepness_output);
+ */
+
+ /* save the number layers "num_layers learning_rate connection_rate shortcut_connections activation_function_hidden activation_function_output activation_steepness_hidden activation_steepness_output" */
+ fprintf(conf, "%u %f %f %u\n", ann->last_layer - ann->first_layer, ann->learning_rate, ann->connection_rate, ann->shortcut_connections);
#endif
for(layer_it = ann->first_layer; layer_it != ann->last_layer; layer_it++){
@@ -173,7 +183,18 @@ int fann_save_internal_fd(struct fann *ann, FILE *conf, const char *configuratio
for(layer_it = ann->first_layer; layer_it != ann->last_layer; layer_it++){
/* the number of connections to each neuron */
for(neuron_it = layer_it->first_neuron; neuron_it != layer_it->last_neuron; neuron_it++){
- fprintf(conf, "%u ", neuron_it->last_con - neuron_it->first_con);
+#ifndef FIXEDFANN
+ if(save_as_fixed){
+ fprintf(conf, "%u %u %u ", neuron_it->last_con - neuron_it->first_con,
+ neuron_it->activation_function, (int)floor((neuron_it->activation_steepness*fixed_multiplier) + 0.5));
+ } else {
+ fprintf(conf, "%u %u "FANNPRINTF" ", neuron_it->last_con - neuron_it->first_con,
+ neuron_it->activation_function, neuron_it->activation_steepness);
+ }
+#else
+ fprintf(conf, "%u %u "FANNPRINTF" ", neuron_it->last_con - neuron_it->first_con,
+ neuron_it->activation_function, neuron_it->activation_steepness);
+#endif
}
fprintf(conf, "\n");
}
@@ -284,15 +305,142 @@ void fann_save_train_internal_fd(struct fann_train_data* data, FILE *file, char
}
/* INTERNAL FUNCTION
+ Create a network from a configuration file descriptor. (backward compatible read of version 1.1 files)
+ */
+struct fann * fann_create_from_fd_1_1(FILE *conf, const char *configuration_file)
+{
+ unsigned int num_layers, layer_size, activation_function_hidden, activation_function_output, input_neuron, i, shortcut_connections, num_connections;
+#ifdef FIXEDFANN
+ unsigned int decimal_point, multiplier;
+#endif
+ fann_type activation_steepness_hidden, activation_steepness_output;
+ float learning_rate, connection_rate;
+ struct fann_neuron *first_neuron, *neuron_it, *last_neuron, **connected_neurons;
+ fann_type *weights;
+ struct fann_layer *layer_it;
+ struct fann *ann;
+
+#ifdef FIXEDFANN
+ if(fscanf(conf, "%u\n", &decimal_point) != 1){
+ fann_error(NULL, FANN_E_CANT_READ_CONFIG, configuration_file);
+ return NULL;
+ }
+ multiplier = 1 << decimal_point;
+#endif
+
+ if(fscanf(conf, "%u %f %f %u %u %u "FANNSCANF" "FANNSCANF"\n", &num_layers, &learning_rate, &connection_rate, &shortcut_connections, &activation_function_hidden, &activation_function_output, &activation_steepness_hidden, &activation_steepness_output) != 8){
+ fann_error(NULL, FANN_E_CANT_READ_CONFIG, configuration_file);
+ return NULL;
+ }
+
+ ann = fann_allocate_structure(learning_rate, num_layers);
+ if(ann == NULL){
+ return NULL;
+ }
+ ann->connection_rate = connection_rate;
+ ann->shortcut_connections = shortcut_connections;
+
+#ifdef FIXEDFANN
+ ann->decimal_point = decimal_point;
+ ann->multiplier = multiplier;
+#endif
+
+#ifdef FIXEDFANN
+ fann_update_stepwise(ann);
+#endif
+
+#ifdef DEBUG
+ printf("creating network with learning rate %f\n", learning_rate);
+ printf("input\n");
+#endif
+
+ /* determine how many neurons there should be in each layer */
+ for(layer_it = ann->first_layer; layer_it != ann->last_layer; layer_it++){
+ if(fscanf(conf, "%u ", &layer_size) != 1){
+ fann_error((struct fann_error *)ann, FANN_E_CANT_READ_NEURON, configuration_file);
+ fann_destroy(ann);
+ return NULL;
+ }
+ /* we do not allocate room here, but we make sure that
+ last_neuron - first_neuron is the number of neurons */
+ layer_it->first_neuron = NULL;
+ layer_it->last_neuron = layer_it->first_neuron + layer_size;
+ ann->total_neurons += layer_size;
+#ifdef DEBUG
+ if(ann->shortcut_connections && layer_it != ann->first_layer){
+ printf(" layer : %d neurons, 0 bias\n", layer_size);
+ } else {
+ printf(" layer : %d neurons, 1 bias\n", layer_size-1);
+ }
+#endif
+ }
+
+ ann->num_input = ann->first_layer->last_neuron - ann->first_layer->first_neuron - 1;
+ ann->num_output = ((ann->last_layer-1)->last_neuron - (ann->last_layer-1)->first_neuron);
+ if(!ann->shortcut_connections){
+ /* one too many (bias) in the output layer */
+ ann->num_output--;
+ }
+
+ /* allocate room for the actual neurons */
+ fann_allocate_neurons(ann);
+ if(ann->errno_f == FANN_E_CANT_ALLOCATE_MEM){
+ fann_destroy(ann);
+ return NULL;
+ }
+
+ last_neuron = (ann->last_layer-1)->last_neuron;
+ for(neuron_it = ann->first_layer->first_neuron;
+ neuron_it != last_neuron; neuron_it++){
+ if(fscanf(conf, "%u ", &num_connections) != 1){
+ fann_error((struct fann_error *)ann, FANN_E_CANT_READ_NEURON, configuration_file);
+ fann_destroy(ann);
+ return NULL;
+ }
+ neuron_it->first_con = ann->total_connections;
+ ann->total_connections += num_connections;
+ neuron_it->last_con = ann->total_connections;
+ }
+
+ fann_allocate_connections(ann);
+ if(ann->errno_f == FANN_E_CANT_ALLOCATE_MEM){
+ fann_destroy(ann);
+ return NULL;
+ }
+
+ connected_neurons = ann->connections;
+ weights = ann->weights;
+ first_neuron = ann->first_layer->first_neuron;
+
+ for(i = 0; i < ann->total_connections; i++){
+ if(fscanf(conf, "(%u "FANNSCANF") ", &input_neuron, &weights[i]) != 2){
+ fann_error((struct fann_error *)ann, FANN_E_CANT_READ_CONNECTIONS, configuration_file);
+ fann_destroy(ann);
+ return NULL;
+ }
+ connected_neurons[i] = first_neuron+input_neuron;
+ }
+
+ fann_set_activation_steepness_hidden(ann, activation_steepness_hidden);
+ fann_set_activation_steepness_output(ann, activation_steepness_output);
+ fann_set_activation_function_hidden(ann, activation_function_hidden);
+ fann_set_activation_function_output(ann, activation_function_output);
+
+#ifdef DEBUG
+ printf("output\n");
+#endif
+ return ann;
+}
+
+/* INTERNAL FUNCTION
Create a network from a configuration file descriptor.
*/
struct fann * fann_create_from_fd(FILE *conf, const char *configuration_file)
{
- unsigned int num_layers, layer_size, activation_function_hidden, activation_function_output, input_neuron, i, shortcut_connections, num_connections;
+ unsigned int num_layers, layer_size, input_neuron, i, shortcut_connections, num_connections;
#ifdef FIXEDFANN
unsigned int decimal_point, multiplier;
#endif
- fann_type activation_steepness_hidden, activation_steepness_output;
float learning_rate, connection_rate;
struct fann_neuron *first_neuron, *neuron_it, *last_neuron, **connected_neurons;
fann_type *weights;
@@ -311,8 +459,18 @@ struct fann * fann_create_from_fd(FILE *conf, const char *configuration_file)
/* compares the version information */
if(strncmp(read_version, FANN_CONF_VERSION"\n", strlen(FANN_CONF_VERSION"\n")) != 0){
- fann_error(NULL, FANN_E_WRONG_CONFIG_VERSION, configuration_file);
+#ifdef FIXEDFANN
+ if(strncmp(read_version, "FANN_FIX_1.1\n", strlen("FANN_FIX_1.1\n")) == 0){
+#else
+ if(strncmp(read_version, "FANN_FLO_1.1\n", strlen("FANN_FLO_1.1\n")) == 0){
+#endif
+ free(read_version);
+ return fann_create_from_fd_1_1(conf, configuration_file);
+ }
+
free(read_version);
+ fann_error(NULL, FANN_E_WRONG_CONFIG_VERSION, configuration_file);
+
return NULL;
}
@@ -326,7 +484,7 @@ struct fann * fann_create_from_fd(FILE *conf, const char *configuration_file)
multiplier = 1 << decimal_point;
#endif
- if(fscanf(conf, "%u %f %f %u %u %u "FANNSCANF" "FANNSCANF"\n", &num_layers, &learning_rate, &connection_rate, &shortcut_connections, &activation_function_hidden, &activation_function_output, &activation_steepness_hidden, &activation_steepness_output) != 8){
+ if(fscanf(conf, "%u %f %f %u\n", &num_layers, &learning_rate, &connection_rate, &shortcut_connections) != 4){
fann_error(NULL, FANN_E_CANT_READ_CONFIG, configuration_file);
return NULL;
}
@@ -343,13 +501,8 @@ struct fann * fann_create_from_fd(FILE *conf, const char *configuration_file)
ann->multiplier = multiplier;
#endif
- ann->activation_steepness_hidden = activation_steepness_hidden;
- ann->activation_steepness_output = activation_steepness_output;
- ann->activation_function_hidden = activation_function_hidden;
- ann->activation_function_output = activation_function_output;
#ifdef FIXEDFANN
- fann_update_stepwise_hidden(ann);
- fann_update_stepwise_output(ann);
+ fann_update_stepwise(ann);
#endif
#ifdef DEBUG
@@ -395,7 +548,7 @@ struct fann * fann_create_from_fd(FILE *conf, const char *configuration_file)
last_neuron = (ann->last_layer-1)->last_neuron;
for(neuron_it = ann->first_layer->first_neuron;
neuron_it != last_neuron; neuron_it++){
- if(fscanf(conf, "%u ", &num_connections) != 1){
+ if(fscanf(conf, "%u %u "FANNSCANF" ", &num_connections, &neuron_it->activation_function, &neuron_it->activation_steepness) != 3){
fann_error((struct fann_error *)ann, FANN_E_CANT_READ_NEURON, configuration_file);
fann_destroy(ann);
return NULL;
@@ -424,9 +577,15 @@ struct fann * fann_create_from_fd(FILE *conf, const char *configuration_file)
connected_neurons[i] = first_neuron+input_neuron;
}
+ /*
+ fann_set_activation_steepness_hidden(ann, activation_steepness_hidden);
+ fann_set_activation_steepness_output(ann, activation_steepness_output);
+ fann_set_activation_function_hidden(ann, activation_function_hidden);
+ fann_set_activation_function_output(ann, activation_function_output);
+ */
+
#ifdef DEBUG
printf("output\n");
#endif
return ann;
}
-
diff --git a/src/fann_options.c b/src/fann_options.c
index df81093..5fe46d5 100644
--- a/src/fann_options.c
+++ b/src/fann_options.c
@@ -48,14 +48,19 @@ FANN_EXTERNAL void FANN_API fann_print_parameters(struct fann *ann)
printf("Shortcut connections :%4d\n", ann->shortcut_connections);
printf("Training algorithm : %s\n", FANN_TRAIN_NAMES[ann->training_algorithm]);
printf("Learning rate : %5.2f\n", ann->learning_rate);
- printf("Activation function hidden : %s\n", FANN_ACTIVATION_NAMES[ann->activation_function_hidden]);
+/* printf("Activation function hidden : %s\n", FANN_ACTIVATION_NAMES[ann->activation_function_hidden]);
printf("Activation function output : %s\n", FANN_ACTIVATION_NAMES[ann->activation_function_output]);
+*/
#ifndef FIXEDFANN
+/*
printf("Activation steepness hidden: %5.2f\n", ann->activation_steepness_hidden);
printf("Activation steepness output: %5.2f\n", ann->activation_steepness_output);
+*/
#else
+/*
printf("Activation steepness hidden: %d\n", ann->activation_steepness_hidden);
printf("Activation steepness output: %d\n", ann->activation_steepness_output);
+*/
printf("Decimal point :%4d\n", ann->decimal_point);
printf("Multiplier :%4d\n", ann->multiplier);
#endif
@@ -88,34 +93,56 @@ FANN_EXTERNAL void FANN_API fann_set_learning_rate(struct fann *ann, float learn
FANN_EXTERNAL void FANN_API fann_set_activation_function_hidden(struct fann *ann, unsigned int activation_function)
{
- ann->activation_function_hidden = activation_function;
-#ifdef FIXEDFANN
- fann_update_stepwise_hidden(ann);
-#endif
+ struct fann_neuron *last_neuron, *neuron_it;
+ struct fann_layer *layer_it;
+ struct fann_layer *last_layer = ann->last_layer-1; /* -1 to not update the output layer */
+ for(layer_it = ann->first_layer+1; layer_it != last_layer; layer_it++)
+ {
+ last_neuron = layer_it->last_neuron;
+ for(neuron_it = layer_it->first_neuron; neuron_it != last_neuron; neuron_it++)
+ {
+ neuron_it->activation_function = activation_function;
+ }
+ }
}
FANN_EXTERNAL void FANN_API fann_set_activation_function_output(struct fann *ann, unsigned int activation_function)
{
- ann->activation_function_output = activation_function;
-#ifdef FIXEDFANN
- fann_update_stepwise_output(ann);
-#endif
+ struct fann_neuron *last_neuron, *neuron_it;
+ struct fann_layer *last_layer = ann->last_layer-1;
+
+ last_neuron = last_layer->last_neuron;
+ for(neuron_it = last_layer->first_neuron; neuron_it != last_neuron; neuron_it++)
+ {
+ neuron_it->activation_function = activation_function;
+ }
}
FANN_EXTERNAL void FANN_API fann_set_activation_steepness_hidden(struct fann *ann, fann_type steepness)
{
- ann->activation_steepness_hidden = steepness;
-#ifdef FIXEDFANN
- fann_update_stepwise_hidden(ann);
-#endif
+ struct fann_neuron *last_neuron, *neuron_it;
+ struct fann_layer *layer_it;
+ struct fann_layer *last_layer = ann->last_layer-1; /* -1 to not update the output layer */
+ for(layer_it = ann->first_layer+1; layer_it != last_layer; layer_it++)
+ {
+ last_neuron = layer_it->last_neuron;
+ for(neuron_it = layer_it->first_neuron; neuron_it != last_neuron; neuron_it++)
+ {
+ neuron_it->activation_steepness = steepness;
+ }
+ }
}
FANN_EXTERNAL void FANN_API fann_set_activation_steepness_output(struct fann *ann, fann_type steepness)
{
- ann->activation_steepness_output = steepness;
-#ifdef FIXEDFANN
- fann_update_stepwise_output(ann);
-#endif
+ struct fann_neuron *last_neuron, *neuron_it;
+ struct fann_layer *last_layer = ann->last_layer-1;
+
+ last_neuron = last_layer->last_neuron;
+ for(neuron_it = last_layer->first_neuron; neuron_it != last_neuron; neuron_it++)
+ {
+ neuron_it->activation_steepness = steepness;
+ }
}
FANN_EXTERNAL void FANN_API fann_set_activation_hidden_steepness(struct fann *ann, fann_type steepness)
@@ -143,6 +170,7 @@ FANN_EXTERNAL unsigned int FANN_API fann_get_num_output(struct fann *ann)
return ann->num_output;
}
+/*
FANN_EXTERNAL unsigned int FANN_API fann_get_activation_function_hidden(struct fann *ann)
{
return ann->activation_function_hidden;
@@ -172,6 +200,7 @@ FANN_EXTERNAL fann_type FANN_API fann_get_activation_steepness_output(struct fan
{
return ann->activation_steepness_output;
}
+*/
FANN_EXTERNAL unsigned int FANN_API fann_get_total_neurons(struct fann *ann)
{
@@ -293,140 +322,50 @@ FANN_EXTERNAL unsigned int FANN_API fann_get_multiplier(struct fann *ann)
return ann->multiplier;
}
-#endif
-
-#ifdef FIXEDFANN
/* INTERNAL FUNCTION
Adjust the steepwise functions (if used)
*/
-/*
-void fann_update_stepwise_hidden(struct fann *ann)
+void fann_update_stepwise(struct fann *ann)
{
- unsigned int i = 0;*/
+ unsigned int i = 0;
/* Calculate the parameters for the stepwise linear
sigmoid function fixed point.
Using a rewritten sigmoid function.
results 0.005, 0.05, 0.25, 0.75, 0.95, 0.995
*/
-/*
- ann->sigmoid_results[0] = fann_max((fann_type)((ann->multiplier/100.0) - ann->multiplier-0.5), 1-ann->multiplier);
- ann->sigmoid_results[1] = (fann_type)((ann->multiplier/10.0) - ann->multiplier-0.5);
- ann->sigmoid_results[2] = (fann_type)((ann->multiplier/2.0) - ann->multiplier-0.5);
- ann->sigmoid_results[3] = ann->multiplier - (fann_type)(ann->multiplier/2.0+0.5);
- ann->sigmoid_results[4] = ann->multiplier - (fann_type)(ann->multiplier/10.0+0.5);
- ann->sigmoid_results[5] = fann_min(ann->multiplier - (fann_type)(ann->multiplier/100.0+1.0), ann->multiplier-1);
-
- ann->sigmoid_symmetric_results[0] = fann_max((fann_type)((ann->multiplier/100.0) - ann->multiplier-0.5), 1-ann->multiplier);
+ ann->sigmoid_results[0] = fann_max((fann_type)(ann->multiplier/200.0+0.5), 1);
+ ann->sigmoid_results[1] = (fann_type)(ann->multiplier/20.0+0.5);
+ ann->sigmoid_results[2] = (fann_type)(ann->multiplier/4.0+0.5);
+ ann->sigmoid_results[3] = ann->multiplier - (fann_type)(ann->multiplier/4.0+0.5);
+ ann->sigmoid_results[4] = ann->multiplier - (fann_type)(ann->multiplier/20.0+0.5);
+ ann->sigmoid_results[5] = fann_min(ann->multiplier - (fann_type)(ann->multiplier/200.0+0.5), ann->multiplier-1);
+
+ ann->sigmoid_symmetric_results[0] = fann_max((fann_type)((ann->multiplier/100.0) - ann->multiplier-0.5), (fann_type)(1-(fann_type)ann->multiplier));
ann->sigmoid_symmetric_results[1] = (fann_type)((ann->multiplier/10.0) - ann->multiplier-0.5);
ann->sigmoid_symmetric_results[2] = (fann_type)((ann->multiplier/2.0) - ann->multiplier-0.5);
ann->sigmoid_symmetric_results[3] = ann->multiplier - (fann_type)(ann->multiplier/2.0+0.5);
ann->sigmoid_symmetric_results[4] = ann->multiplier - (fann_type)(ann->multiplier/10.0+0.5);
ann->sigmoid_symmetric_results[5] = fann_min(ann->multiplier - (fann_type)(ann->multiplier/100.0+1.0), ann->multiplier-1);
+ /*DEBUG
+ ann->sigmoid_results[0] = (fann_type)(ann->multiplier/200.0+0.5);
+ ann->sigmoid_results[1] = (fann_type)(ann->multiplier/20.0+0.5);
+ ann->sigmoid_results[2] = (fann_type)(ann->multiplier/4.0+0.5);
+ ann->sigmoid_results[3] = ann->multiplier - (fann_type)(ann->multiplier/4.0+0.5);
+ ann->sigmoid_results[4] = ann->multiplier - (fann_type)(ann->multiplier/20.0+0.5);
+ ann->sigmoid_results[5] = ann->multiplier - (fann_type)(ann->multiplier/200.0+0.5);
+
+ ann->sigmoid_symmetric_results[0] = (fann_type)((ann->multiplier/100.0) - ann->multiplier + 0.5);
+ ann->sigmoid_symmetric_results[1] = (fann_type)((ann->multiplier/10.0) - ann->multiplier + 0.5);
+ ann->sigmoid_symmetric_results[2] = (fann_type)((ann->multiplier/2.0) - ann->multiplier + 0.5);
+ ann->sigmoid_symmetric_results[3] = ann->multiplier - (fann_type)(ann->multiplier/2.0+0.5);
+ ann->sigmoid_symmetric_results[4] = ann->multiplier - (fann_type)(ann->multiplier/10.0+0.5);
+ ann->sigmoid_symmetric_results[5] = ann->multiplier - (fann_type)(ann->multiplier/100.0+0.5);
+ */
+
for(i = 0; i < 6; i++){
ann->sigmoid_values[i] = (fann_type)(((log(ann->multiplier/(float)ann->sigmoid_results[i] -1)*(float)ann->multiplier) / -2.0)*(float)ann->multiplier);
ann->sigmoid_symmetric_values[i] = (fann_type)(((log((ann->multiplier - (float)ann->sigmoid_symmetric_results[i])/((float)ann->sigmoid_symmetric_results[i] + ann->multiplier))*(float)ann->multiplier) / -2.0)*(float)ann->multiplier);
}
}
-*/
-
-/* INTERNAL FUNCTION
- Adjust the steepwise functions (if used)
-*/
-void fann_update_stepwise_hidden(struct fann *ann)
-{
- unsigned int i = 0;
- /* Calculate the parameters for the stepwise linear
- sigmoid function fixed point.
- Using a rewritten sigmoid function.
- results 0.005, 0.05, 0.25, 0.75, 0.95, 0.995
- */
- switch(ann->activation_function_hidden){
- case FANN_SIGMOID:
- case FANN_SIGMOID_STEPWISE:
- ann->activation_results_hidden[0] = (fann_type)(ann->multiplier/200.0+0.5);
- ann->activation_results_hidden[1] = (fann_type)(ann->multiplier/20.0+0.5);
- ann->activation_results_hidden[2] = (fann_type)(ann->multiplier/4.0+0.5);
- ann->activation_results_hidden[3] = ann->multiplier - (fann_type)(ann->multiplier/4.0+0.5);
- ann->activation_results_hidden[4] = ann->multiplier - (fann_type)(ann->multiplier/20.0+0.5);
- ann->activation_results_hidden[5] = ann->multiplier - (fann_type)(ann->multiplier/200.0+0.5);
- break;
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- ann->activation_results_hidden[0] = (fann_type)((ann->multiplier/100.0) - ann->multiplier-0.5);
- ann->activation_results_hidden[1] = (fann_type)((ann->multiplier/10.0) - ann->multiplier-0.5);
- ann->activation_results_hidden[2] = (fann_type)((ann->multiplier/2.0) - ann->multiplier-0.5);
- ann->activation_results_hidden[3] = ann->multiplier - (fann_type)(ann->multiplier/2.0+0.5);
- ann->activation_results_hidden[4] = ann->multiplier - (fann_type)(ann->multiplier/10.0+0.5);
- ann->activation_results_hidden[5] = ann->multiplier - (fann_type)(ann->multiplier/100.0+0.5);
- break;
- default:
- /* the actiavation functions which do not have a stepwise function
- should not have it calculated */
- return;
- }
-
- for(i = 0; i < 6; i++){
- switch(ann->activation_function_hidden){
- case FANN_SIGMOID:
- case FANN_SIGMOID_STEPWISE:
- ann->activation_values_hidden[i] = (fann_type)((((log(ann->multiplier/(float)ann->activation_results_hidden[i] -1)*(float)ann->multiplier) / -2.0)*(float)ann->multiplier) / ann->activation_steepness_hidden);
- break;
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- ann->activation_values_hidden[i] = (fann_type)((((log((ann->multiplier - (float)ann->activation_results_hidden[i])/((float)ann->activation_results_hidden[i] + ann->multiplier))*(float)ann->multiplier) / -2.0)*(float)ann->multiplier) / ann->activation_steepness_hidden);
- break;
- }
- }
-}
-
-/* INTERNAL FUNCTION
- Adjust the steepwise functions (if used)
-*/
-void fann_update_stepwise_output(struct fann *ann)
-{
- unsigned int i = 0;
- /* Calculate the parameters for the stepwise linear
- sigmoid function fixed point.
- Using a rewritten sigmoid function.
- results 0.005, 0.05, 0.25, 0.75, 0.95, 0.995
- */
- switch(ann->activation_function_output){
- case FANN_SIGMOID:
- case FANN_SIGMOID_STEPWISE:
- ann->activation_results_output[0] = (fann_type)(ann->multiplier/200.0+0.5);
- ann->activation_results_output[1] = (fann_type)(ann->multiplier/20.0+0.5);
- ann->activation_results_output[2] = (fann_type)(ann->multiplier/4.0+0.5);
- ann->activation_results_output[3] = ann->multiplier - (fann_type)(ann->multiplier/4.0+0.5);
- ann->activation_results_output[4] = ann->multiplier - (fann_type)(ann->multiplier/20.0+0.5);
- ann->activation_results_output[5] = ann->multiplier - (fann_type)(ann->multiplier/200.0+0.5);
- break;
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- ann->activation_results_output[0] = (fann_type)((ann->multiplier/100.0) - ann->multiplier-0.5);
- ann->activation_results_output[1] = (fann_type)((ann->multiplier/10.0) - ann->multiplier-0.5);
- ann->activation_results_output[2] = (fann_type)((ann->multiplier/2.0) - ann->multiplier-0.5);
- ann->activation_results_output[3] = ann->multiplier - (fann_type)(ann->multiplier/2.0+0.5);
- ann->activation_results_output[4] = ann->multiplier - (fann_type)(ann->multiplier/10.0+0.5);
- ann->activation_results_output[5] = ann->multiplier - (fann_type)(ann->multiplier/100.0+0.5);
- break;
- default:
- /* the actiavation functions which do not have a stepwise function
- should not have it calculated */
- return;
- }
-
- for(i = 0; i < 6; i++){
- switch(ann->activation_function_output){
- case FANN_SIGMOID:
- case FANN_SIGMOID_STEPWISE:
- ann->activation_values_output[i] = (fann_type)((((log(ann->multiplier/(float)ann->activation_results_output[i] -1)*(float)ann->multiplier) / -2.0)*(float)ann->multiplier) / ann->activation_steepness_output);
- break;
- case FANN_SIGMOID_SYMMETRIC:
- case FANN_SIGMOID_SYMMETRIC_STEPWISE:
- ann->activation_values_output[i] = (fann_type)((((log((ann->multiplier - (float)ann->activation_results_output[i])/((float)ann->activation_results_output[i] + ann->multiplier))*(float)ann->multiplier) / -2.0)*(float)ann->multiplier) / ann->activation_steepness_output);
- break;
- }
- }
-}
#endif
diff --git a/src/fann_train.c b/src/fann_train.c
index e1abaaa..993137c 100644
--- a/src/fann_train.c
+++ b/src/fann_train.c
@@ -128,6 +128,7 @@ FANN_EXTERNAL fann_type * FANN_API fann_test(struct fann *ann, fann_type *input,
fann_type *output_it;
const fann_type *output_end = output_begin + ann->num_output;
fann_type neuron_diff, neuron_diff2;
+ struct fann_neuron *output_neurons = (ann->last_layer-1)->first_neuron;
/* calculate the error */
for(output_it = output_begin;
@@ -136,11 +137,16 @@ FANN_EXTERNAL fann_type * FANN_API fann_test(struct fann *ann, fann_type *input,
neuron_diff = (*desired_output - neuron_value);
- if(ann->activation_function_output == FANN_SIGMOID_SYMMETRIC ||
- ann->activation_function_output == FANN_SIGMOID_SYMMETRIC_STEPWISE ||
- ann->activation_function_output == FANN_ELLIOT_SYMMETRIC ||
- ann->activation_function_output == FANN_GAUSSIAN_SYMMETRIC){
- neuron_diff /= (fann_type)2;
+ switch(output_neurons[output_it - output_begin].activation_function)
+ {
+ case FANN_SIGMOID_SYMMETRIC:
+ case FANN_SIGMOID_SYMMETRIC_STEPWISE:
+ case FANN_ELLIOT_SYMMETRIC:
+ case FANN_GAUSSIAN_SYMMETRIC:
+ neuron_diff /= (fann_type)2;
+ break;
+ default:
+ break;
}
#ifdef FIXEDFANN
@@ -236,11 +242,14 @@ void fann_compute_MSE(struct fann *ann, fann_type *desired_output)
neuron_value = last_layer_begin->value;
neuron_diff = *desired_output - neuron_value;
- if(ann->activation_function_output == FANN_SIGMOID_SYMMETRIC ||
- ann->activation_function_output == FANN_SIGMOID_SYMMETRIC_STEPWISE ||
- ann->activation_function_output == FANN_ELLIOT_SYMMETRIC ||
- ann->activation_function_output == FANN_GAUSSIAN_SYMMETRIC){
- neuron_diff /= 2.0;
+ switch(last_layer_begin->activation_function)
+ {
+ case FANN_SIGMOID_SYMMETRIC:
+ case FANN_SIGMOID_SYMMETRIC_STEPWISE:
+ case FANN_ELLIOT_SYMMETRIC:
+ case FANN_GAUSSIAN_SYMMETRIC:
+ neuron_diff /= 2.0;
+ break;
}
neuron_diff2 = (float)(neuron_diff * neuron_diff);
@@ -260,8 +269,8 @@ void fann_compute_MSE(struct fann *ann, fann_type *desired_output)
neuron_diff = (fann_type)log ( (1.0+neuron_diff) / (1.0-neuron_diff) );
}
- *error_it = fann_activation_derived(ann->activation_function_output,
- ann->activation_steepness_output, neuron_value, last_layer_begin->sum) * neuron_diff;
+ *error_it = fann_activation_derived(last_layer_begin->activation_function,
+ last_layer_begin->activation_steepness, neuron_value, last_layer_begin->sum) * neuron_diff;
desired_output++;
error_it++;
@@ -286,7 +295,6 @@ void fann_backpropagate_MSE(struct fann *ann)
fann_type *error_begin = ann->train_errors;
fann_type *error_prev_layer;
fann_type *weights;
- const fann_type activation_steepness_hidden = ann->activation_steepness_hidden;
const struct fann_neuron *first_neuron = ann->first_layer->first_neuron;
const struct fann_layer *second_layer = ann->first_layer + 1;
struct fann_layer *last_layer = ann->last_layer;
@@ -337,7 +345,7 @@ void fann_backpropagate_MSE(struct fann *ann)
neuron_it != last_neuron; neuron_it++){
neuron_value = neuron_it->value;
/* *error_prev_layer *= fann_activation(ann, 0, neuron_value); */
- *error_prev_layer *= fann_activation(ann, ann->activation_function_hidden, activation_steepness_hidden, neuron_value);
+ *error_prev_layer *= fann_activation(ann, neuron_it->activation_function, neuron_it->activation_steepness, neuron_value);
}
/*
@@ -425,7 +433,7 @@ void fann_update_weights(struct fann *ann)
weights = ann->weights + neuron_it->first_con;
connections = ann->connections + neuron_it->first_con;
for(i = 0; i != num_connections; i++){
- weights[i] += tmp_error * connections[i]->value;
+ weights[i] += tmp_error * connections[i]->value;
}
}
}
diff --git a/src/include/fann_data.h b/src/include/fann_data.h
index 4076c96..c625e17 100644
--- a/src/include/fann_data.h
+++ b/src/include/fann_data.h
@@ -38,9 +38,9 @@ struct fann_neuron
/* The value of the activation function applied to the sum */
fann_type value;
/* The steepness of the activation function */
- /*fann_type steepness;*/
+ fann_type activation_steepness;
/* Used to choose which activation function to use */
- /*unsigned int activation_function;*/
+ unsigned int activation_function;
#ifdef __GNUC__
}__attribute__((packed));
#else
@@ -130,12 +130,12 @@ struct fann
to FANN_THRESHOLD and the activation function for the output neurons to FANN_SIGMOID,
in this way you get a very fast network, that is still cabable of
producing real valued output.
- */
- unsigned int activation_function_hidden, activation_function_output;
+ unsigned int activation_function_hidden, activation_function_output; */
- /* Parameters for the activation function */
+ /* Parameters for the activation function
fann_type activation_steepness_hidden;
fann_type activation_steepness_output;
+ */
/* Training algorithm used when calling fann_train_on_..
*/
@@ -158,10 +158,10 @@ struct fann
activation_results array, the result is saved, and in the
two values arrays, the values that gives the results are saved.
*/
- fann_type activation_results_hidden[6];
- fann_type activation_values_hidden[6];
- fann_type activation_results_output[6];
- fann_type activation_values_output[6];
+ fann_type sigmoid_results[6];
+ fann_type sigmoid_values[6];
+ fann_type sigmoid_symmetric_results[6];
+ fann_type sigmoid_symmetric_values[6];
#endif
/* Total number of connections.
diff --git a/src/include/fann_internal.h b/src/include/fann_internal.h
index 69258da..8836741 100644
--- a/src/include/fann_internal.h
+++ b/src/include/fann_internal.h
@@ -27,8 +27,8 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include <stdlib.h>
#include "fann_data.h"
-#define FANN_FIX_VERSION "FANN_FIX_1.1"
-#define FANN_FLO_VERSION "FANN_FLO_1.1"
+#define FANN_FIX_VERSION "FANN_FIX_1.3"
+#define FANN_FLO_VERSION "FANN_FLO_1.3"
#ifdef FIXEDFANN
#define FANN_CONF_VERSION FANN_FIX_VERSION
@@ -48,8 +48,7 @@ void fann_save_train_internal_fd(struct fann_train_data* data, FILE *file, char
void fann_seed_rand();
-void fann_update_stepwise_hidden(struct fann *ann);
-void fann_update_stepwise_output(struct fann *ann);
+void fann_update_stepwise(struct fann *ann);
void fann_error(struct fann_error *errdat, const unsigned int errno_f, ...);
void fann_init_error_data(struct fann_error *errdat);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/libfann.git
More information about the debian-science-commits
mailing list