ruby-fann 1.2.5 → 1.2.6

data/ext/ruby_fann/fann.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -266,6 +266,16 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(unsigned int num_
 FANN_EXTERNAL void FANN_API fann_destroy(struct fann *ann);
 
 
+/* Function: fann_copy
+   Creates a copy of a fann structure. 
+   
+   Data in the user data <fann_set_user_data> is not copied, but the user data pointer is copied.
+
+	This function appears in FANN >= 2.2.0.
+*/ 
+FANN_EXTERNAL struct fann * FANN_API fann_copy(struct fann *ann);
+
+
 /* Function: fann_run
 	Will run input through the neural network, returning an array of outputs, the number of which being 
 	equal to the number of neurons in the output layer.

data/ext/ruby_fann/fann_activation.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public

data/ext/ruby_fann/fann_cascade.c

@@ -1,6 +1,6 @@
 /*
   Fast Artificial Neural Network Library (fann)
-  Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+  Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -76,7 +76,7 @@ FANN_EXTERNAL void FANN_API fann_cascadetrain_on_data(struct fann *ann, struct f
 			{
 				printf
 					("Neurons     %3d. Current error: %.6f. Total error:%8.4f. Epochs %5d. Bit fail %3d",
-					 i, error, ann->MSE_value, total_epochs, ann->num_bit_fail);
+					 i-1, error, ann->MSE_value, total_epochs, ann->num_bit_fail);
 				if((ann->last_layer-2) != ann->first_layer)
 				{
 					printf(". candidate steepness %.2f. function %s", 
@@ -147,6 +147,7 @@ int fann_train_outputs(struct fann *ann, struct fann_train_data *data, float des
 	float backslide_improvement = -1.0e20f;
 	unsigned int i;
 	unsigned int max_epochs = ann->cascade_max_out_epochs;
+	unsigned int min_epochs = ann->cascade_min_out_epochs;
 	unsigned int stagnation = max_epochs;
 
 	/* TODO should perhaps not clear all arrays */
@@ -177,7 +178,11 @@ int fann_train_outputs(struct fann *ann, struct fann_train_data *data, float des
 
 		/* After any significant change, set a new goal and
 		 * allow a new quota of epochs to reach it */
-		if((error_improvement > target_improvement) || (error_improvement < backslide_improvement))
+		
+		if((target_improvement >= 0 &&
+			(error_improvement > target_improvement || error_improvement < backslide_improvement)) ||
+		(target_improvement < 0 &&
+			(error_improvement < target_improvement || error_improvement > backslide_improvement)))
 		{
 			/*printf("error_improvement=%f, target_improvement=%f, backslide_improvement=%f, stagnation=%d\n", error_improvement, target_improvement, backslide_improvement, stagnation); */
 
@@ -187,7 +192,7 @@ int fann_train_outputs(struct fann *ann, struct fann_train_data *data, float des
 		}
 
 		/* No improvement in allotted period, so quit */
-		if(i >= stagnation)
+		if(i >= stagnation && i >= min_epochs)
 		{
 			return i + 1;
 		}
@@ -199,7 +204,7 @@ int fann_train_outputs(struct fann *ann, struct fann_train_data *data, float des
 float fann_train_outputs_epoch(struct fann *ann, struct fann_train_data *data)
 {
 	unsigned int i;
-
+	
 	fann_reset_MSE(ann);
 
 	for(i = 0; i < data->num_data; i++)
@@ -215,6 +220,11 @@ float fann_train_outputs_epoch(struct fann *ann, struct fann_train_data *data)
 			fann_update_weights_irpropm(ann, (ann->last_layer - 1)->first_neuron->first_con,
 										ann->total_connections);
 			break;
+		case FANN_TRAIN_SARPROP:
+			fann_update_weights_sarprop(ann, ann->sarprop_epoch, (ann->last_layer - 1)->first_neuron->first_con,
+										ann->total_connections);
+			++(ann->sarprop_epoch);
+			break;
 		case FANN_TRAIN_QUICKPROP:
 			fann_update_weights_quickprop(ann, data->num_data,
 										  (ann->last_layer - 1)->first_neuron->first_con,
@@ -414,9 +424,8 @@ int fann_initialize_candidates(struct fann *ann)
 		}
 	}
 
-	/* Some test code to do semi Widrow + Nguyen initialization */
-	scale_factor = (float) 2.0f*(pow((double) (0.7f * (double) num_hidden_neurons),
-				                (double) (1.0f / (double) ann->num_input)));
+	/* Some code to do semi Widrow + Nguyen initialization */
+	scale_factor = (float) (2.0 * pow(0.7f * (float)num_hidden_neurons, 1.0f / (float) ann->num_input));
 	if(scale_factor > 8)
 		scale_factor = 8;
 	else if(scale_factor < 0.5)
@@ -487,6 +496,7 @@ int fann_train_candidates(struct fann *ann, struct fann_train_data *data)
 	fann_type backslide_cand_score = -1.0e20f;
 	unsigned int i;
 	unsigned int max_epochs = ann->cascade_max_cand_epochs;
+	unsigned int min_epochs = ann->cascade_min_cand_epochs;
 	unsigned int stagnation = max_epochs;
 
 	if(ann->cascade_candidate_scores == NULL)
@@ -527,7 +537,7 @@ int fann_train_candidates(struct fann *ann, struct fann_train_data *data)
 		}
 
 		/* No improvement in allotted period, so quit */
-		if(i >= stagnation)
+		if(i >= stagnation && i >= min_epochs)
 		{
 #ifdef CASCADE_DEBUG
 			printf("Stagnation with %d epochs, best candidate score %f, real score: %f\n", i + 1,
@@ -661,6 +671,11 @@ void fann_update_candidate_weights(struct fann *ann, unsigned int num_data)
 			fann_update_weights_irpropm(ann, first_cand->first_con,
 										last_cand->last_con + ann->num_output);
 			break;
+		case FANN_TRAIN_SARPROP:
+			/* TODO: increase epoch? */
+			fann_update_weights_sarprop(ann, ann->sarprop_epoch, first_cand->first_con,
+										last_cand->last_con + ann->num_output);
+			break;
 		case FANN_TRAIN_QUICKPROP:
 			fann_update_weights_quickprop(ann, num_data, first_cand->first_con,
 										  last_cand->last_con + ann->num_output);
@@ -755,7 +770,7 @@ fann_type fann_train_candidates_epoch(struct fann *ann, struct fann_train_data *
 	}
 
 	ann->cascade_best_candidate = ann->total_neurons + best_candidate + 1;
-#ifdef CASCADE_DEBUG_FULL
+#ifdef CASCADE_DEBUG
 	printf("Best candidate[%d]: with score %f, real score: %f\n", best_candidate,
 		   ann->MSE_value - best_score, best_score);
 #endif
@@ -973,6 +988,8 @@ FANN_GET_SET(fann_type, cascade_weight_multiplier)
 FANN_GET_SET(fann_type, cascade_candidate_limit)
 FANN_GET_SET(unsigned int, cascade_max_out_epochs)
 FANN_GET_SET(unsigned int, cascade_max_cand_epochs)
+FANN_GET_SET(unsigned int, cascade_min_out_epochs)
+FANN_GET_SET(unsigned int, cascade_min_cand_epochs)
 
 FANN_GET(unsigned int, cascade_activation_functions_count)
 FANN_GET(enum fann_activationfunc_enum *, cascade_activation_functions)

data/ext/ruby_fann/fann_cascade.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -309,6 +309,33 @@ FANN_EXTERNAL void FANN_API fann_set_cascade_max_out_epochs(struct fann *ann,
 															 unsigned int cascade_max_out_epochs);
 
 
+/* Function: fann_get_cascade_min_out_epochs
+
+   The minimum out epochs determines the minimum number of epochs the output connections
+   must be trained after adding a new candidate neuron.
+   
+   The default min out epochs is 50
+
+   See also:
+   		<fann_set_cascade_min_out_epochs>
+
+	This function appears in FANN >= 2.2.0.
+ */
+FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_min_out_epochs(struct fann *ann);
+
+
+/* Function: fann_set_cascade_min_out_epochs
+
+   Sets the minimum out epochs.
+
+   See also:
+   		<fann_get_cascade_min_out_epochs>
+
+	This function appears in FANN >= 2.2.0.
+ */
+FANN_EXTERNAL void FANN_API fann_set_cascade_min_out_epochs(struct fann *ann, 
+															 unsigned int cascade_min_out_epochs);
+
 /* Function: fann_get_cascade_max_cand_epochs
 
    The maximum candidate epochs determines the maximum number of epochs the input 
@@ -337,6 +364,33 @@ FANN_EXTERNAL void FANN_API fann_set_cascade_max_cand_epochs(struct fann *ann,
 															 unsigned int cascade_max_cand_epochs);
 
 
+/* Function: fann_get_cascade_min_cand_epochs
+
+   The minimum candidate epochs determines the minimum number of epochs the input 
+   connections to the candidates may be trained before adding a new candidate neuron.
+   
+   The default min candidate epochs is 50
+
+   See also:
+   		<fann_set_cascade_min_cand_epochs>
+
+	This function appears in FANN >= 2.2.0.
+ */
+FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_min_cand_epochs(struct fann *ann);
+
+
+/* Function: fann_set_cascade_min_cand_epochs
+
+   Sets the min candidate epochs.
+  
+   See also:
+   		<fann_get_cascade_min_cand_epochs>
+
+	This function appears in FANN >= 2.2.0.
+ */
+FANN_EXTERNAL void FANN_API fann_set_cascade_min_cand_epochs(struct fann *ann, 
+															 unsigned int cascade_min_cand_epochs);
+
 /* Function: fann_get_cascade_num_candidates
 
    The number of candidates used during training (calculated by multiplying <fann_get_cascade_activation_functions_count>,

data/ext/ruby_fann/fann_data.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -77,7 +77,8 @@ enum fann_train_enum
 	FANN_TRAIN_INCREMENTAL = 0,
 	FANN_TRAIN_BATCH,
 	FANN_TRAIN_RPROP,
-	FANN_TRAIN_QUICKPROP
+	FANN_TRAIN_QUICKPROP,
+	FANN_TRAIN_SARPROP
 };
 
 /* Constant: FANN_TRAIN_NAMES
@@ -95,7 +96,8 @@ static char const *const FANN_TRAIN_NAMES[] = {
 	"FANN_TRAIN_INCREMENTAL",
 	"FANN_TRAIN_BATCH",
 	"FANN_TRAIN_RPROP",
-	"FANN_TRAIN_QUICKPROP"
+	"FANN_TRAIN_QUICKPROP",
+	"FANN_TRAIN_SARPROP"
 };
 
 /* Enums: fann_activationfunc_enum
@@ -649,6 +651,14 @@ struct fann
 	 */
 	unsigned int cascade_max_cand_epochs;	
 
+	/* Minimum epochs to train the output neurons during cascade training
+	 */
+	unsigned int cascade_min_out_epochs;
+	
+	/* Minimum epochs to train the candidate neurons during cascade training
+	 */
+	unsigned int cascade_min_cand_epochs;	
+
 	/* An array consisting of the activation functions used when doing
 	 * cascade training.
 	 */
@@ -716,6 +726,21 @@ struct fann
 	/* The initial stepsize */
 	float rprop_delta_zero;
         
+	/* Defines how much the weights are constrained to smaller values at the beginning */
+	float sarprop_weight_decay_shift;
+
+	/* Decides if the stepsize is too big with regard to the error */
+	float sarprop_step_error_threshold_factor;
+
+	/* Defines how much the stepsize is influenced by the error */
+	float sarprop_step_error_shift;
+
+	/* Defines how much the epoch influences weight decay and noise */
+	float sarprop_temperature;
+
+	/* Current training epoch */
+	unsigned int sarprop_epoch;
+
 	/* Used to contain the slope errors used during batch training
 	 * Is allocated during first training session,
 	 * which means that if we do not train, it is never allocated.

data/ext/ruby_fann/fann_error.c

@@ -1,6 +1,6 @@
 /*
   Fast Artificial Neural Network Library (fann)
-  Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+  Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -174,6 +174,12 @@ void fann_error(struct fann_error *errdat, const enum fann_errno_enum errno_f, .
 	case FANN_E_SCALE_NOT_PRESENT: 
 		sprintf(errstr, "Scaling parameters not present.\n");
 		break;
+    case FANN_E_INPUT_NO_MATCH:
+    	vsprintf(errstr, "The number of input neurons in the ann (%d) and data (%d) don't match\n", ap);
+    	break;
+    case FANN_E_OUTPUT_NO_MATCH:
+     	vsprintf(errstr, "The number of output neurons in the ann (%d) and data (%d) don't match\n", ap);
+     	break; 
 	}
 	va_end(ap);
 

data/ext/ruby_fann/fann_error.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -60,6 +60,8 @@ struct fann_error;
 	FANN_E_TRAIN_DATA_SUBSET - Trying to take subset which is not within the training set
 	FANN_E_INDEX_OUT_OF_BOUND - Index is out of bound
 	FANN_E_SCALE_NOT_PRESENT - Scaling parameters not present
+    FANN_E_INPUT_NO_MATCH - The number of input neurons in the ann and data don't match
+    FANN_E_OUTPUT_NO_MATCH - The number of output neurons in the ann and data don't match
 */
 enum fann_errno_enum
 {
@@ -81,7 +83,9 @@ enum fann_errno_enum
 	FANN_E_CANT_USE_TRAIN_ALG,
 	FANN_E_TRAIN_DATA_SUBSET,
 	FANN_E_INDEX_OUT_OF_BOUND,
-	FANN_E_SCALE_NOT_PRESENT
+	FANN_E_SCALE_NOT_PRESENT,
+	FANN_E_INPUT_NO_MATCH,
+	FANN_E_OUTPUT_NO_MATCH
 };
 
 /* Group: Error Handling */

data/ext/ruby_fann/fann_internal.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -90,11 +90,13 @@ void fann_update_weights_batch(struct fann *ann, unsigned int num_data, unsigned
 							   unsigned int past_end);
 void fann_update_weights_irpropm(struct fann *ann, unsigned int first_weight,
 								 unsigned int past_end);
+void fann_update_weights_sarprop(struct fann *ann, unsigned int epoch, unsigned int first_weight,
+								unsigned int past_end);
 
 void fann_clear_train_arrays(struct fann *ann);
 
-fann_type fann_activation(struct fann * ann, unsigned int activation_function, fann_type steepness,
-						  fann_type value);
+fann_type fann_activation(struct fann * ann, unsigned int activation_function, fann_type steepness,
+						  fann_type value);
 
 fann_type fann_activation_derived(unsigned int activation_function,
 								  fann_type steepness, fann_type value, fann_type sum);
@@ -111,6 +113,7 @@ int fann_train_candidates(struct fann *ann, struct fann_train_data *data);
 fann_type fann_train_candidates_epoch(struct fann *ann, struct fann_train_data *data);
 
 void fann_install_candidate(struct fann *ann);
+int fann_check_input_output_sizes(struct fann *ann, struct fann_train_data *data);
 
 int fann_initialize_candidates(struct fann *ann);
 
@@ -123,6 +126,7 @@ int fann_allocate_scale(struct fann *ann);
 #define fann_min(x, y) (((x) < (y)) ? (x) : (y))
 #define fann_safe_free(x) {if(x) { free(x); x = NULL; }}
 #define fann_clip(x, lo, hi) (((x) < (lo)) ? (lo) : (((x) > (hi)) ? (hi) : (x)))
+#define fann_exp2(x) exp(0.69314718055994530942*(x))
 /*#define fann_clip(x, lo, hi) (x)*/
 
 #define fann_rand(min_value, max_value) (((float)(min_value))+(((float)(max_value)-((float)(min_value)))*rand()/(RAND_MAX+1.0f)))

data/ext/ruby_fann/fann_io.c

@@ -1,6 +1,6 @@
 /*
   Fast Artificial Neural Network Library (fann)
-  Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+  Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -24,6 +24,7 @@
 
 #include "config.h"
 #include "fann.h"
+#include "fann_data.h"
 
 /* Create a network from a configuration file.
  */
@@ -174,7 +175,7 @@ int fann_save_internal_fd(struct fann *ann, FILE * conf, const char *configurati
 #endif
 
 	/* Save network parameters */
-	fprintf(conf, "num_layers=%u\n", ann->last_layer - ann->first_layer);
+	fprintf(conf, "num_layers=%d\n", (int)(ann->last_layer - ann->first_layer));
 	fprintf(conf, "learning_rate=%f\n", ann->learning_rate);
 	fprintf(conf, "connection_rate=%f\n", ann->connection_rate);
 	fprintf(conf, "network_type=%u\n", ann->network_type);
@@ -195,7 +196,9 @@ int fann_save_internal_fd(struct fann *ann, FILE * conf, const char *configurati
 	fprintf(conf, "cascade_candidate_change_fraction=%f\n", ann->cascade_candidate_change_fraction);
 	fprintf(conf, "cascade_candidate_stagnation_epochs=%u\n", ann->cascade_candidate_stagnation_epochs);
 	fprintf(conf, "cascade_max_out_epochs=%u\n", ann->cascade_max_out_epochs);
+	fprintf(conf, "cascade_min_out_epochs=%u\n", ann->cascade_min_out_epochs);
 	fprintf(conf, "cascade_max_cand_epochs=%u\n", ann->cascade_max_cand_epochs);	
+	fprintf(conf, "cascade_min_cand_epochs=%u\n", ann->cascade_min_cand_epochs);	
 	fprintf(conf, "cascade_num_candidate_groups=%u\n", ann->cascade_num_candidate_groups);
 
 #ifndef FIXEDFANN
@@ -236,7 +239,7 @@ int fann_save_internal_fd(struct fann *ann, FILE * conf, const char *configurati
 	for(layer_it = ann->first_layer; layer_it != ann->last_layer; layer_it++)
 	{
 		/* the number of neurons in the layers (in the last layer, there is always one too many neurons, because of an unused bias) */
-		fprintf(conf, "%u ", layer_it->last_neuron - layer_it->first_neuron);
+		fprintf(conf, "%d ", (int)(layer_it->last_neuron - layer_it->first_neuron));
 	}
 	fprintf(conf, "\n");
 
@@ -316,18 +319,18 @@ int fann_save_internal_fd(struct fann *ann, FILE * conf, const char *configurati
 		if(save_as_fixed)
 		{
 			/* save the connection "(source weight) " */
-			fprintf(conf, "(%u, %d) ",
-					connected_neurons[i] - first_neuron,
+			fprintf(conf, "(%d, %d) ",
+					(int)(connected_neurons[i] - first_neuron),
 					(int) floor((weights[i] * fixed_multiplier) + 0.5));
 		}
 		else
 		{
 			/* save the connection "(source weight) " */
-			fprintf(conf, "(%u, " FANNPRINTF ") ", connected_neurons[i] - first_neuron, weights[i]);
+			fprintf(conf, "(%d, " FANNPRINTF ") ", (int)(connected_neurons[i] - first_neuron), weights[i]);
 		}
 #else
 		/* save the connection "(source weight) " */
-		fprintf(conf, "(%u, " FANNPRINTF ") ", connected_neurons[i] - first_neuron, weights[i]);
+		fprintf(conf, "(%d, " FANNPRINTF ") ", (int)(connected_neurons[i] - first_neuron), weights[i]);
 #endif
 
 	}
@@ -348,12 +351,23 @@ struct fann *fann_create_from_fd_1_1(FILE * conf, const char *configuration_file
 	} \
 }
 
+#define fann_skip(name) \
+{ \
+	if(fscanf(conf, name) != 0) \
+	{ \
+		fann_error(NULL, FANN_E_CANT_READ_CONFIG, name, configuration_file); \
+		fann_destroy(ann); \
+		return NULL; \
+	} \
+}
+
 /* 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, input_neuron, i, num_connections;
+	unsigned int tmpVal;
 #ifdef FIXEDFANN
 	unsigned int decimal_point, multiplier;
 #else
@@ -373,7 +387,11 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 		return NULL;
 	}
 
-	fread(read_version, 1, strlen(FANN_CONF_VERSION "\n"), conf);	/* reads version */
+	if(fread(read_version, 1, strlen(FANN_CONF_VERSION "\n"), conf) == 1)
+	{
+	        fann_error(NULL, FANN_E_CANT_READ_CONFIG, "FANN_VERSION", configuration_file);
+		return NULL;
+	}
 
 	/* compares the version information */
 	if(strncmp(read_version, FANN_CONF_VERSION "\n", strlen(FANN_CONF_VERSION "\n")) != 0)
@@ -408,11 +426,11 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 	free(read_version);
 
 #ifdef FIXEDFANN
-    fann_scanf("%u", "decimal_point", &decimal_point);
+	fann_scanf("%u", "decimal_point", &decimal_point);
 	multiplier = 1 << decimal_point;
 #endif
 
-    fann_scanf("%u", "num_layers", &num_layers);
+	fann_scanf("%u", "num_layers", &num_layers);
 
 	ann = fann_allocate_structure(num_layers);
 	if(ann == NULL)
@@ -420,13 +438,17 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 		return NULL;
 	}
 
-    fann_scanf("%f", "learning_rate", &ann->learning_rate);
-    fann_scanf("%f", "connection_rate", &ann->connection_rate);
-    fann_scanf("%u", "network_type", (unsigned int *)&ann->network_type);
+	fann_scanf("%f", "learning_rate", &ann->learning_rate);
+	fann_scanf("%f", "connection_rate", &ann->connection_rate);
+	fann_scanf("%u", "network_type", &tmpVal);
+	ann->network_type = (enum fann_nettype_enum)tmpVal;
 	fann_scanf("%f", "learning_momentum", &ann->learning_momentum);
-	fann_scanf("%u", "training_algorithm", (unsigned int *)&ann->training_algorithm);
-	fann_scanf("%u", "train_error_function", (unsigned int *)&ann->train_error_function);
-	fann_scanf("%u", "train_stop_function", (unsigned int *)&ann->train_stop_function);
+	fann_scanf("%u", "training_algorithm", &tmpVal);
+	ann->training_algorithm = (enum fann_train_enum)tmpVal;
+	fann_scanf("%u", "train_error_function", &tmpVal);
+	ann->train_error_function = (enum fann_errorfunc_enum)tmpVal;
+	fann_scanf("%u", "train_stop_function", &tmpVal);
+	ann->train_stop_function = (enum fann_stopfunc_enum)tmpVal;
 	fann_scanf("%f", "cascade_output_change_fraction", &ann->cascade_output_change_fraction);
 	fann_scanf("%f", "quickprop_decay", &ann->quickprop_decay);
 	fann_scanf("%f", "quickprop_mu", &ann->quickprop_mu);
@@ -439,7 +461,9 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 	fann_scanf("%f", "cascade_candidate_change_fraction", &ann->cascade_candidate_change_fraction);
 	fann_scanf("%u", "cascade_candidate_stagnation_epochs", &ann->cascade_candidate_stagnation_epochs);
 	fann_scanf("%u", "cascade_max_out_epochs", &ann->cascade_max_out_epochs);
+	fann_scanf("%u", "cascade_min_out_epochs", &ann->cascade_min_out_epochs);
 	fann_scanf("%u", "cascade_max_cand_epochs", &ann->cascade_max_cand_epochs);	
+	fann_scanf("%u", "cascade_min_cand_epochs", &ann->cascade_min_cand_epochs);	
 	fann_scanf("%u", "cascade_num_candidate_groups", &ann->cascade_num_candidate_groups);
 
 	fann_scanf(FANNSCANF, "bit_fail_limit", &ann->bit_fail_limit);
@@ -460,10 +484,18 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 		return NULL;
 	}
 
-	fscanf(conf, "cascade_activation_functions=");
+
+	fann_skip("cascade_activation_functions=");
 	for(i = 0; i < ann->cascade_activation_functions_count; i++)
-		fscanf(conf, "%u ", (unsigned int *)&ann->cascade_activation_functions[i]);
-	
+	{
+		if(fscanf(conf, "%u ", (unsigned int *)&ann->cascade_activation_functions[i]) != 1)
+		{
+			fann_error(NULL, FANN_E_CANT_READ_CONFIG, "cascade_activation_functions", configuration_file);
+			fann_destroy(ann);
+			return NULL;
+		}
+	}
+
 	fann_scanf("%u", "cascade_activation_steepnesses_count", &ann->cascade_activation_steepnesses_count);
 
 	/* reallocate mem */
@@ -477,9 +509,16 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 		return NULL;
 	}
 
-	fscanf(conf, "cascade_activation_steepnesses=");
-	for(i = 0; i < ann->cascade_activation_steepnesses_count; i++)
-		fscanf(conf, FANNSCANF" ", &ann->cascade_activation_steepnesses[i]);
+	fann_skip("cascade_activation_steepnesses=");
+	for(i = 0; i < ann->cascade_activation_steepnesses_count; i++) 
+	{
+		if(fscanf(conf, FANNSCANF" ", &ann->cascade_activation_steepnesses[i]) != 1)
+		{
+			fann_error(NULL, FANN_E_CANT_READ_CONFIG, "cascade_activation_steepnesses", configuration_file);
+			fann_destroy(ann);
+			return NULL;
+		}
+	}
 
 #ifdef FIXEDFANN
 	ann->decimal_point = decimal_point;
@@ -495,7 +534,7 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 	printf("input\n");
 #endif
 
-	fscanf(conf, "layer_sizes=");
+	fann_skip("layer_sizes=");
 	/* determine how many neurons there should be in each layer */
 	for(layer_it = ann->first_layer; layer_it != ann->last_layer; layer_it++)
 	{
@@ -532,7 +571,7 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 
 #ifndef FIXEDFANN
 #define SCALE_LOAD( what, where )											\
-	fscanf( conf, #what "_" #where "=" );									\
+	fann_skip( #what "_" #where "=" );									\
 	for(i = 0; i < ann->num_##where##put; i++)								\
 	{																		\
 		if(fscanf( conf, "%f ", (float *)&ann->what##_##where[ i ] ) != 1)  \
@@ -568,17 +607,18 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 	}
 
 	last_neuron = (ann->last_layer - 1)->last_neuron;
-	fscanf(conf, "neurons (num_inputs, activation_function, activation_steepness)=");
+	fann_skip("neurons (num_inputs, activation_function, activation_steepness)=");
 	for(neuron_it = ann->first_layer->first_neuron; neuron_it != last_neuron; neuron_it++)
 	{
 		if(fscanf
-		   (conf, "(%u, %u, " FANNSCANF ") ", &num_connections, (unsigned int *)&neuron_it->activation_function,
+		   (conf, "(%u, %u, " FANNSCANF ") ", &num_connections, &tmpVal,
 			&neuron_it->activation_steepness) != 3)
 		{
 			fann_error((struct fann_error *) ann, FANN_E_CANT_READ_NEURON, configuration_file);
 			fann_destroy(ann);
 			return NULL;
 		}
+		neuron_it->activation_function = (enum fann_activationfunc_enum)tmpVal;
 		neuron_it->first_con = ann->total_connections;
 		ann->total_connections += num_connections;
 		neuron_it->last_con = ann->total_connections;
@@ -595,7 +635,7 @@ struct fann *fann_create_from_fd(FILE * conf, const char *configuration_file)
 	weights = ann->weights;
 	first_neuron = ann->first_layer->first_neuron;
 
-	fscanf(conf, "connections (connected_to_neuron, weight)=");
+	fann_skip("connections (connected_to_neuron, weight)=");
 	for(i = 0; i < ann->total_connections; i++)
 	{
 		if(fscanf(conf, "(%u, " FANNSCANF ") ", &input_neuron, &weights[i]) != 2)