ruby-fann 1.2.5 → 1.2.6

data/ext/ruby_fann/fann_io.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_train.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
@@ -21,6 +21,7 @@
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
+#include <math.h>
 
 #include "config.h"
 #include "fann.h"
@@ -206,6 +207,7 @@ FANN_EXTERNAL unsigned int FANN_API fann_get_bit_fail(struct fann *ann)
  */
 FANN_EXTERNAL void FANN_API fann_reset_MSE(struct fann *ann)
 {
+/*printf("resetMSE %d %f\n", ann->num_MSE, ann->MSE_value);*/
 	ann->num_MSE = 0;
 	ann->MSE_value = 0;
 	ann->num_bit_fail = 0;
@@ -764,6 +766,85 @@ void fann_update_weights_irpropm(struct fann *ann, unsigned int first_weight, un
 	}
 }
 
+/* INTERNAL FUNCTION
+   The SARprop- algorithm
+*/
+void fann_update_weights_sarprop(struct fann *ann, unsigned int epoch, unsigned int first_weight, unsigned int past_end)
+{
+	fann_type *train_slopes = ann->train_slopes;
+	fann_type *weights = ann->weights;
+	fann_type *prev_steps = ann->prev_steps;
+	fann_type *prev_train_slopes = ann->prev_train_slopes;
+
+	fann_type prev_step, slope, prev_slope, next_step = 0, same_sign;
+
+	/* These should be set from variables */
+	float increase_factor = ann->rprop_increase_factor;	/*1.2; */
+	float decrease_factor = ann->rprop_decrease_factor;	/*0.5; */
+	/* TODO: why is delta_min 0.0 in iRprop? SARPROP uses 1x10^-6 (Braun and Riedmiller, 1993) */
+	float delta_min = 0.000001f;
+	float delta_max = ann->rprop_delta_max;	/*50.0; */
+	float weight_decay_shift = ann->sarprop_weight_decay_shift; /* ld 0.01 = -6.644 */
+	float step_error_threshold_factor = ann->sarprop_step_error_threshold_factor; /* 0.1 */
+	float step_error_shift = ann->sarprop_step_error_shift; /* ld 3 = 1.585 */
+	float T = ann->sarprop_temperature;
+	float MSE = fann_get_MSE(ann);
+	float RMSE = (float)sqrt(MSE);
+
+	unsigned int i = first_weight;
+
+
+	/* for all weights; TODO: are biases included? */
+	for(; i != past_end; i++)
+	{
+		/* TODO: confirm whether 1x10^-6 == delta_min is really better */
+		prev_step = fann_max(prev_steps[i], (fann_type) 0.000001);	/* prev_step may not be zero because then the training will stop */
+		/* calculate SARPROP slope; TODO: better as new error function? (see SARPROP paper)*/
+		slope = -train_slopes[i] - weights[i] * (fann_type)fann_exp2(-T * epoch + weight_decay_shift);
+
+		/* TODO: is prev_train_slopes[i] 0.0 in the beginning? */
+		prev_slope = prev_train_slopes[i];
+
+		same_sign = prev_slope * slope;
+
+		if(same_sign > 0.0)
+		{
+			next_step = fann_min(prev_step * increase_factor, delta_max);
+			/* TODO: are the signs inverted? see differences between SARPROP paper and iRprop */
+			if (slope < 0.0)
+				weights[i] += next_step;
+			else
+				weights[i] -= next_step;
+		}
+		else if(same_sign < 0.0)
+		{
+			if(prev_step < step_error_threshold_factor * MSE)
+				next_step = prev_step * decrease_factor + (float)rand() / RAND_MAX * RMSE * (fann_type)fann_exp2(-T * epoch + step_error_shift);
+			else
+				next_step = fann_max(prev_step * decrease_factor, delta_min);
+
+			slope = 0.0;
+		}
+		else
+		{
+			if(slope < 0.0)
+				weights[i] += prev_step;
+			else
+				weights[i] -= prev_step;
+		}
+
+
+		/*if(i == 2){
+		 * printf("weight=%f, slope=%f, next_step=%f, prev_step=%f\n", weights[i], slope, next_step, prev_step);
+		 * } */
+
+		/* update global data arrays */
+		prev_steps[i] = next_step;
+		prev_train_slopes[i] = slope;
+		train_slopes[i] = 0.0;
+	}
+}
+
 #endif
 
 FANN_GET_SET(enum fann_train_enum, training_algorithm)
@@ -957,6 +1038,10 @@ FANN_GET_SET(float, rprop_decrease_factor)
 FANN_GET_SET(float, rprop_delta_min)
 FANN_GET_SET(float, rprop_delta_max)
 FANN_GET_SET(float, rprop_delta_zero)
+FANN_GET_SET(float, sarprop_weight_decay_shift)
+FANN_GET_SET(float, sarprop_step_error_threshold_factor)
+FANN_GET_SET(float, sarprop_step_error_shift)
+FANN_GET_SET(float, sarprop_temperature)
 FANN_GET_SET(enum fann_stopfunc_enum, train_stop_function)
 FANN_GET_SET(fann_type, bit_fail_limit)
 FANN_GET_SET(float, learning_momentum)

data/ext/ruby_fann/fann_train.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
@@ -252,6 +252,17 @@ FANN_EXTERNAL float FANN_API fann_test_data(struct fann *ann, struct fann_train_
 FANN_EXTERNAL struct fann_train_data *FANN_API fann_read_train_from_file(const char *filename);
 
 
+/* Function: fann_create_train
+   Creates an empty training data struct.
+  
+   See also:
+     <fann_read_train_from_file>, <fann_train_on_data>, <fann_destroy_train>,
+     <fann_save_train>
+
+    This function appears in FANN >= 2.2.0
+*/ 
+FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train(unsigned int num_data, unsigned int num_input, unsigned int num_output);
+
 /* Function: fann_create_train_from_callback
    Creates the training data struct from a user supplied function.
    As the training data are numerable (data 1, data 2...), the user must write
@@ -1200,4 +1211,100 @@ FANN_EXTERNAL float FANN_API fann_get_rprop_delta_zero(struct fann *ann);
 */
 FANN_EXTERNAL void FANN_API fann_set_rprop_delta_zero(struct fann *ann, float rprop_delta_max);
 
+/* Method: fann_get_sarprop_weight_decay_shift
+
+   The sarprop weight decay shift.
+
+   The default delta max is -6.644.
+
+   See also:
+   <fann fann_set_sarprop_weight_decay_shift>
+
+   This function appears in FANN >= 2.1.0.
+   */ 
+FANN_EXTERNAL float FANN_API fann_get_sarprop_weight_decay_shift(struct fann *ann);
+
+/* Method: fann_set_sarprop_weight_decay_shift
+
+   Set the sarprop weight decay shift.
+
+   This function appears in FANN >= 2.1.0.
+
+   See also:
+   <fann_set_sarprop_weight_decay_shift>
+   */ 
+FANN_EXTERNAL void FANN_API fann_set_sarprop_weight_decay_shift(struct fann *ann, float sarprop_weight_decay_shift);
+
+/* Method: fann_get_sarprop_step_error_threshold_factor
+
+   The sarprop step error threshold factor.
+
+   The default delta max is 0.1.
+
+   See also:
+   <fann fann_get_sarprop_step_error_threshold_factor>
+
+   This function appears in FANN >= 2.1.0.
+   */ 
+FANN_EXTERNAL float FANN_API fann_get_sarprop_step_error_threshold_factor(struct fann *ann);
+
+/* Method: fann_set_sarprop_step_error_threshold_factor
+
+   Set the sarprop step error threshold factor.
+
+   This function appears in FANN >= 2.1.0.
+
+   See also:
+   <fann_get_sarprop_step_error_threshold_factor>
+   */ 
+FANN_EXTERNAL void FANN_API fann_set_sarprop_step_error_threshold_factor(struct fann *ann, float sarprop_step_error_threshold_factor);
+
+/* Method: fann_get_sarprop_step_error_shift
+
+   The get sarprop step error shift.
+
+   The default delta max is 1.385.
+
+   See also:
+   <fann_set_sarprop_step_error_shift>
+
+   This function appears in FANN >= 2.1.0.
+   */ 
+FANN_EXTERNAL float FANN_API fann_get_sarprop_step_error_shift(struct fann *ann);
+
+/* Method: fann_set_sarprop_step_error_shift
+
+   Set the sarprop step error shift.
+
+   This function appears in FANN >= 2.1.0.
+
+   See also:
+   <fann_get_sarprop_step_error_shift>
+   */ 
+FANN_EXTERNAL void FANN_API fann_set_sarprop_step_error_shift(struct fann *ann, float sarprop_step_error_shift);
+
+/* Method: fann_get_sarprop_temperature
+
+   The sarprop weight decay shift.
+
+   The default delta max is 0.015.
+
+   See also:
+   <fann_set_sarprop_temperature>
+
+   This function appears in FANN >= 2.1.0.
+   */ 
+FANN_EXTERNAL float FANN_API fann_get_sarprop_temperature(struct fann *ann);
+
+/* Method: fann_set_sarprop_temperature
+
+   Set the sarprop_temperature.
+
+   This function appears in FANN >= 2.1.0.
+
+   See also:
+   <fann_get_sarprop_temperature>
+   */ 
+FANN_EXTERNAL void FANN_API fann_set_sarprop_temperature(struct fann *ann, float sarprop_temperature);
+
 #endif

data/ext/ruby_fann/fann_train_data.c

@@ -1,21 +1,21 @@
 /*
- * Fast Artificial Neural Network Library (fann) Copyright (C) 2003
- * Steffen Nissen (lukesky@diku.dk)
- * 
- * This library is free software; you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2.1 of the License, or
- * (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
- */
+  Fast Artificial Neural Network Library (fann)
+  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
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -84,7 +84,9 @@ FANN_EXTERNAL void FANN_API fann_destroy_train(struct fann_train_data *data)
 FANN_EXTERNAL float FANN_API fann_test_data(struct fann *ann, struct fann_train_data *data)
 {
 	unsigned int i;
-
+	if(fann_check_input_output_sizes(ann, data) == -1)
+		return 0;
+	
 	fann_reset_MSE(ann);
 
 	for(i = 0; i != data->num_data; i++)
@@ -95,86 +97,38 @@ FANN_EXTERNAL float FANN_API fann_test_data(struct fann *ann, struct fann_train_
 	return fann_get_MSE(ann);
 }
 
+#ifndef FIXEDFANN
+
 /*
- * Creates training data from a callback function.
+ * Internal train function 
  */
-FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train_from_callback(unsigned int num_data,
-                                          unsigned int num_input,
-                                          unsigned int num_output,
-                                          void (FANN_API *user_function)( unsigned int,
-                                                                 unsigned int,
-                                                                 unsigned int,
-                                                                 fann_type * ,
-                                                                 fann_type * ))
+float fann_train_epoch_quickprop(struct fann *ann, struct fann_train_data *data)
 {
-    unsigned int i;
-    fann_type *data_input, *data_output;
-    struct fann_train_data *data = (struct fann_train_data *)
-                                                                                 malloc(sizeof(struct fann_train_data));
-
-    if(data == NULL){
-        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
-        return NULL;
-    }
-
-    fann_init_error_data((struct fann_error *) data);
-
-    data->num_data     = num_data;
-    data->num_input    = num_input;
-    data->num_output = num_output;
-
-    data->input = (fann_type **) calloc(num_data, sizeof(fann_type *));
-    if(data->input == NULL)
-    {
-        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
-        fann_destroy_train(data);
-        return NULL;
-    }
-
-    data->output = (fann_type **) calloc(num_data, sizeof(fann_type *));
-    if(data->output == NULL)
-    {
-        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
-        fann_destroy_train(data);
-        return NULL;
-    }
-
-    data_input = (fann_type *) calloc(num_input * num_data, sizeof(fann_type));
-    if(data_input == NULL)
-    {
-        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
-        fann_destroy_train(data);
-        return NULL;
-    }
-
-    data_output = (fann_type *) calloc(num_output * num_data, sizeof(fann_type));
-    if(data_output == NULL)
-    {
-        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
-        fann_destroy_train(data);
-        return NULL;
-    }
-
-    for( i = 0; i != num_data; i++)
-    {
-        data->input[i] = data_input;
-        data_input += num_input;
+	unsigned int i;
 
-        data->output[i] = data_output;
-        data_output += num_output;
+	if(ann->prev_train_slopes == NULL)
+	{
+		fann_clear_train_arrays(ann);
+	}
 
-        (*user_function)(i, num_input, num_output, data->input[i],data->output[i] );
-    }
+	fann_reset_MSE(ann);
 
-    return data;
-} 
+	for(i = 0; i < data->num_data; i++)
+	{
+		fann_run(ann, data->input[i]);
+		fann_compute_MSE(ann, data->output[i]);
+		fann_backpropagate_MSE(ann);
+		fann_update_slopes_batch(ann, ann->first_layer + 1, ann->last_layer - 1);
+	}
+	fann_update_weights_quickprop(ann, data->num_data, 0, ann->total_connections);
 
-#ifndef FIXEDFANN
+	return fann_get_MSE(ann);
+}
 
 /*
  * Internal train function 
  */
-float fann_train_epoch_quickprop(struct fann *ann, struct fann_train_data *data)
+float fann_train_epoch_irpropm(struct fann *ann, struct fann_train_data *data)
 {
 	unsigned int i;
 
@@ -192,7 +146,8 @@ float fann_train_epoch_quickprop(struct fann *ann, struct fann_train_data *data)
 		fann_backpropagate_MSE(ann);
 		fann_update_slopes_batch(ann, ann->first_layer + 1, ann->last_layer - 1);
 	}
-	fann_update_weights_quickprop(ann, data->num_data, 0, ann->total_connections);
+
+	fann_update_weights_irpropm(ann, 0, ann->total_connections);
 
 	return fann_get_MSE(ann);
 }
@@ -200,7 +155,7 @@ float fann_train_epoch_quickprop(struct fann *ann, struct fann_train_data *data)
 /*
  * Internal train function 
  */
-float fann_train_epoch_irpropm(struct fann *ann, struct fann_train_data *data)
+float fann_train_epoch_sarprop(struct fann *ann, struct fann_train_data *data)
 {
 	unsigned int i;
 
@@ -219,7 +174,9 @@ float fann_train_epoch_irpropm(struct fann *ann, struct fann_train_data *data)
 		fann_update_slopes_batch(ann, ann->first_layer + 1, ann->last_layer - 1);
 	}
 
-	fann_update_weights_irpropm(ann, 0, ann->total_connections);
+	fann_update_weights_sarprop(ann, ann->sarprop_epoch, 0, ann->total_connections);
+
+	++(ann->sarprop_epoch);
 
 	return fann_get_MSE(ann);
 }
@@ -268,12 +225,17 @@ float fann_train_epoch_incremental(struct fann *ann, struct fann_train_data *dat
  */
 FANN_EXTERNAL float FANN_API fann_train_epoch(struct fann *ann, struct fann_train_data *data)
 {
+	if(fann_check_input_output_sizes(ann, data) == -1)
+		return 0;
+	
 	switch (ann->training_algorithm)
 	{
 	case FANN_TRAIN_QUICKPROP:
 		return fann_train_epoch_quickprop(ann, data);
 	case FANN_TRAIN_RPROP:
 		return fann_train_epoch_irpropm(ann, data);
+	case FANN_TRAIN_SARPROP:
+		return fann_train_epoch_sarprop(ann, data);
 	case FANN_TRAIN_BATCH:
 		return fann_train_epoch_batch(ann, data);
 	case FANN_TRAIN_INCREMENTAL:
@@ -795,15 +757,13 @@ int fann_save_train_internal_fd(struct fann_train_data *data, FILE * file, const
 	return retval;
 }
 
-
 /*
- * INTERNAL FUNCTION Reads training data from a file descriptor. 
+ * Creates an empty set of training data
  */
-struct fann_train_data *fann_read_train_from_fd(FILE * file, const char *filename)
+FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train(unsigned int num_data, unsigned int num_input, unsigned int num_output)
 {
-	unsigned int num_input, num_output, num_data, i, j;
-	unsigned int line = 1;
 	fann_type *data_input, *data_output;
+	unsigned int i;
 	struct fann_train_data *data =
 		(struct fann_train_data *) malloc(sizeof(struct fann_train_data));
 
@@ -812,15 +772,7 @@ struct fann_train_data *fann_read_train_from_fd(FILE * file, const char *filenam
 		fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
 		return NULL;
 	}
-
-	if(fscanf(file, "%u %u %u\n", &num_data, &num_input, &num_output) != 3)
-	{
-		fann_error(NULL, FANN_E_CANT_READ_TD, filename, line);
-		fann_destroy_train(data);
-		return NULL;
-	}
-	line++;
-
+	
 	fann_init_error_data((struct fann_error *) data);
 
 	data->num_data = num_data;
@@ -862,7 +814,63 @@ struct fann_train_data *fann_read_train_from_fd(FILE * file, const char *filenam
 	{
 		data->input[i] = data_input;
 		data_input += num_input;
+		data->output[i] = data_output;
+		data_output += num_output;
+	}
+	return data;
+}
+
+/*
+ * Creates training data from a callback function.
+ */
+FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train_from_callback(unsigned int num_data,
+                                          unsigned int num_input,
+                                          unsigned int num_output,
+                                          void (FANN_API *user_function)( unsigned int,
+                                                                 unsigned int,
+                                                                 unsigned int,
+                                                                 fann_type * ,
+                                                                 fann_type * ))
+{
+    unsigned int i;
+	struct fann_train_data *data = fann_create_train(num_data, num_input, num_output);
+	if(data == NULL)
+	{
+		return NULL;
+	}
+
+    for( i = 0; i != num_data; i++)
+    {
+        (*user_function)(i, num_input, num_output, data->input[i], data->output[i]);
+    }
+
+    return data;
+} 
 
+/*
+ * INTERNAL FUNCTION Reads training data from a file descriptor. 
+ */
+struct fann_train_data *fann_read_train_from_fd(FILE * file, const char *filename)
+{
+	unsigned int num_input, num_output, num_data, i, j;
+	unsigned int line = 1;
+	struct fann_train_data *data;
+
+	if(fscanf(file, "%u %u %u\n", &num_data, &num_input, &num_output) != 3)
+	{
+		fann_error(NULL, FANN_E_CANT_READ_TD, filename, line);
+		return NULL;
+	}
+	line++;
+
+	data = fann_create_train(num_data, num_input, num_output);
+	if(data == NULL)
+	{
+		return NULL;
+	}
+
+	for(i = 0; i != num_data; i++)
+	{
 		for(j = 0; j != num_input; j++)
 		{
 			if(fscanf(file, FANNSCANF " ", &data->input[i][j]) != 1)
@@ -874,9 +882,6 @@ struct fann_train_data *fann_read_train_from_fd(FILE * file, const char *filenam
 		}
 		line++;
 
-		data->output[i] = data_output;
-		data_output += num_output;
-
 		for(j = 0; j != num_output; j++)
 		{
 			if(fscanf(file, FANNSCANF " ", &data->output[i][j]) != 1)
@@ -928,7 +933,7 @@ FANN_EXTERNAL void FANN_API fann_scale_input( struct fann *ann, fann_type *input
 			(
 				( input_vector[ cur_neuron ] - ann->scale_mean_in[ cur_neuron ] )
 				/ ann->scale_deviation_in[ cur_neuron ]
-				- ( -1.0 ) /* This is old_min */
+				- ( (fann_type)-1.0 ) /* This is old_min */
 			)
 			* ann->scale_factor_in[ cur_neuron ]
 			+ ann->scale_new_min_in[ cur_neuron ];
@@ -951,7 +956,7 @@ FANN_EXTERNAL void FANN_API fann_scale_output( struct fann *ann, fann_type *outp
 			(
 				( output_vector[ cur_neuron ] - ann->scale_mean_out[ cur_neuron ] )
 				/ ann->scale_deviation_out[ cur_neuron ]
-				- ( -1.0 ) /* This is old_min */
+				- ( (fann_type)-1.0 ) /* This is old_min */
 			)
 			* ann->scale_factor_out[ cur_neuron ]
 			+ ann->scale_new_min_out[ cur_neuron ];
@@ -977,7 +982,7 @@ FANN_EXTERNAL void FANN_API fann_descale_input( struct fann *ann, fann_type *inp
 					- ann->scale_new_min_in[ cur_neuron ]
 				)
 				/ ann->scale_factor_in[ cur_neuron ]
-				+ ( -1.0 ) /* This is old_min */
+				+ ( (fann_type)-1.0 ) /* This is old_min */
 			)
 			* ann->scale_deviation_in[ cur_neuron ]
 			+ ann->scale_mean_in[ cur_neuron ];
@@ -1003,7 +1008,7 @@ FANN_EXTERNAL void FANN_API fann_descale_output( struct fann *ann, fann_type *ou
 					- ann->scale_new_min_out[ cur_neuron ]
 				)
 				/ ann->scale_factor_out[ cur_neuron ]
-				+ ( -1.0 ) /* This is old_min */
+				+ ( (fann_type)-1.0 ) /* This is old_min */
 			)
 			* ann->scale_deviation_out[ cur_neuron ]
 			+ ann->scale_mean_out[ cur_neuron ];
@@ -1021,14 +1026,8 @@ FANN_EXTERNAL void FANN_API fann_scale_train( struct fann *ann, struct fann_trai
 		return;
 	}
 	/* Check that we have good training data. */
-	/* No need for if( !params || !ann ) */
-	if(    data->num_input != ann->num_input
-		|| data->num_output != ann->num_output
-		)
-	{
-		fann_error( (struct fann_error *) ann, FANN_E_TRAIN_DATA_MISMATCH );
+	if(fann_check_input_output_sizes(ann, data) == -1)
 		return;
-	}
 
 	for( cur_sample = 0; cur_sample < data->num_data; cur_sample++ )
 	{
@@ -1049,14 +1048,8 @@ FANN_EXTERNAL void FANN_API fann_descale_train( struct fann *ann, struct fann_tr
 		return;
 	}
 	/* Check that we have good training data. */
-	/* No need for if( !params || !ann ) */
-	if(    data->num_input != ann->num_input
-		|| data->num_output != ann->num_output
-		)
-	{
-		fann_error( (struct fann_error *) ann, FANN_E_TRAIN_DATA_MISMATCH );
+	if(fann_check_input_output_sizes(ann, data) == -1)
 		return;
-	}
 
 	for( cur_sample = 0; cur_sample < data->num_data; cur_sample++ )
 	{
@@ -1072,38 +1065,38 @@ FANN_EXTERNAL void FANN_API fann_descale_train( struct fann *ann, struct fann_tr
 #define SCALE_SET_PARAM( where )																		\
 	/* Calculate mean: sum(x)/length */																	\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
-		ann->scale_mean_##where[ cur_neuron ] = 0.0;													\
+		ann->scale_mean_##where[ cur_neuron ] = 0.0f;													\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
 		for( cur_sample = 0; cur_sample < data->num_data; cur_sample++ )								\
-			ann->scale_mean_##where[ cur_neuron ] += data->where##put[ cur_sample ][ cur_neuron ];		\
+			ann->scale_mean_##where[ cur_neuron ] += (float)data->where##put[ cur_sample ][ cur_neuron ];\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
 		ann->scale_mean_##where[ cur_neuron ] /= (float)data->num_data;									\
 	/* Calculate deviation: sqrt(sum((x-mean)^2)/length) */												\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
-		ann->scale_deviation_##where[ cur_neuron ] = 0.0; 												\
+		ann->scale_deviation_##where[ cur_neuron ] = 0.0f; 												\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
 		for( cur_sample = 0; cur_sample < data->num_data; cur_sample++ )								\
 			ann->scale_deviation_##where[ cur_neuron ] += 												\
 				/* Another local variable in macro? Oh no! */											\
 				( 																						\
-					data->where##put[ cur_sample ][ cur_neuron ] 										\
+					(float)data->where##put[ cur_sample ][ cur_neuron ] 								\
 					- ann->scale_mean_##where[ cur_neuron ] 											\
 				) 																						\
 				*																						\
 				( 																						\
-					data->where##put[ cur_sample ][ cur_neuron ] 										\
+					(float)data->where##put[ cur_sample ][ cur_neuron ] 								\
 					- ann->scale_mean_##where[ cur_neuron ] 											\
 				); 																						\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
 		ann->scale_deviation_##where[ cur_neuron ] =													\
-			sqrt( ann->scale_deviation_##where[ cur_neuron ] / (float)data->num_data ); 				\
+			(float)sqrt( ann->scale_deviation_##where[ cur_neuron ] / (float)data->num_data ); 			\
 	/* Calculate factor: (new_max-new_min)/(old_max(1)-old_min(-1)) */									\
 	/* Looks like we dont need whole array of factors? */												\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
 		ann->scale_factor_##where[ cur_neuron ] =														\
 			( new_##where##put_max - new_##where##put_min )												\
 			/																							\
-			( 1.0 - ( -1.0 ) );																			\
+			( 1.0f - ( -1.0f ) );																		\
 	/* Copy new minimum. */																				\
 	/* Looks like we dont need whole array of new minimums? */											\
 	for( cur_neuron = 0; cur_neuron < ann->num_##where##put; cur_neuron++ )								\
@@ -1229,3 +1222,22 @@ FANN_EXTERNAL int FANN_API fann_clear_scaling_params(struct fann *ann)
 }
 
 #endif
+
+int fann_check_input_output_sizes(struct fann *ann, struct fann_train_data *data)
+{
+	if(ann->num_input != data->num_input)
+    {
+    	fann_error((struct fann_error *) ann, FANN_E_INPUT_NO_MATCH,
+        	ann->num_input, data->num_input);
+        return -1;
+    }
+        
+	if(ann->num_output != data->num_output)
+	{
+		fann_error((struct fann_error *) ann, FANN_E_OUTPUT_NO_MATCH,
+					ann->num_output, data->num_output);
+		return -1;
+	}
+	
+	return 0;
+}