several improvements

src/fann_train.c

@@ -156,6 +156,55 @@ fann_type fann_update_MSE(struct fann *ann, struct fann_neuron* neuron, fann_typ
 	return neuron_diff;
 }
 
+fann_type fann_update_MSE_lw(struct fann *ann, struct fann_neuron* neuron, fann_type neuron_diff, fann_type label_weight)
+{
+	float neuron_diff2;
+
+	switch (neuron->activation_function)
+	{
+		case FANN_LINEAR_PIECE_SYMMETRIC:
+		case FANN_THRESHOLD_SYMMETRIC:
+		case FANN_SIGMOID_SYMMETRIC:
+		case FANN_SIGMOID_SYMMETRIC_STEPWISE:
+		case FANN_ELLIOT_SYMMETRIC:
+		case FANN_GAUSSIAN_SYMMETRIC:
+		case FANN_SIN_SYMMETRIC:
+		case FANN_COS_SYMMETRIC:
+			neuron_diff /= (fann_type)2.0;
+			break;
+		case FANN_THRESHOLD:
+		case FANN_LINEAR:
+		case FANN_SIGMOID:
+		case FANN_SIGMOID_STEPWISE:
+		case FANN_GAUSSIAN:
+		case FANN_GAUSSIAN_STEPWISE:
+		case FANN_ELLIOT:
+		case FANN_LINEAR_PIECE:
+		case FANN_SIN:
+		case FANN_COS:
+			break;
+	}
+
+#ifdef FIXEDFANN
+		neuron_diff2 =
+			(neuron_diff / (float) ann->multiplier) * (neuron_diff / (float) ann->multiplier);
+#else
+		neuron_diff2 = (float) (neuron_diff * neuron_diff);
+#endif
+
+	ann->MSE_value += neuron_diff2 * label_weight;
+
+	/*printf("neuron_diff %f = (%f - %f)[/2], neuron_diff2=%f, sum=%f, MSE_value=%f, num_MSE=%d\n", neuron_diff, *desired_output, neuron_value, neuron_diff2, last_layer_begin->sum, ann->MSE_value, ann->num_MSE); */
+	if(fann_abs(neuron_diff) >= ann->bit_fail_limit)
+	{
+		ann->num_bit_fail++;
+	}
+
+	return neuron_diff;
+}
+
+
+
 /* Tests the network.
  */
 FANN_EXTERNAL fann_type *FANN_API fann_test(struct fann *ann, fann_type * input,
@@ -284,6 +333,66 @@ void fann_compute_MSE(struct fann *ann, fann_type * desired_output)
 	}
 }
 
+void fann_compute_MSE_lw(struct fann *ann, fann_type * desired_output, fann_type label_weight)
+{
+	fann_type neuron_value, neuron_diff, *error_it = 0, *error_begin = 0;
+	struct fann_neuron *last_layer_begin = (ann->last_layer - 1)->first_neuron;
+	const struct fann_neuron *last_layer_end = last_layer_begin + ann->num_output;
+	const struct fann_neuron *first_neuron = ann->first_layer->first_neuron;
+
+	/* if no room allocated for the error variabels, allocate it now */
+	if(ann->train_errors == NULL)
+	{
+		ann->train_errors = (fann_type *) calloc(ann->total_neurons, sizeof(fann_type));
+		if(ann->train_errors == NULL)
+		{
+			fann_error((struct fann_error *) ann, FANN_E_CANT_ALLOCATE_MEM);
+			return;
+		}
+	}
+	else
+	{
+		/* clear the error variabels */
+		memset(ann->train_errors, 0, (ann->total_neurons) * sizeof(fann_type));
+	}
+	error_begin = ann->train_errors;
+
+#ifdef DEBUGTRAIN
+	printf("\ncalculate errors\n");
+#endif
+	/* calculate the error and place it in the output layer */
+	error_it = error_begin + (last_layer_begin - first_neuron);
+
+	for(; last_layer_begin != last_layer_end; last_layer_begin++)
+	{
+		neuron_value = last_layer_begin->value;
+		neuron_diff = *desired_output - neuron_value;
+
+		neuron_diff = fann_update_MSE_lw(ann, last_layer_begin, neuron_diff, label_weight);
+
+		if(ann->train_error_function)
+		{						/* TODO make switch when more functions */
+			if(neuron_diff < -.9999999)
+				neuron_diff = -17.0;
+			else if(neuron_diff > .9999999)
+				neuron_diff = 17.0;
+			else
+				neuron_diff = (fann_type) log((1.0 + neuron_diff) / (1.0 - 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 * label_weight;
+
+		desired_output++;
+		error_it++;
+
+		ann->num_MSE++;
+	}
+}
+
+
+
 /* INTERNAL FUNCTION
    Propagate the error backwards from the output layer.
 

src/fann_train_data.c

@@ -152,6 +152,32 @@ float fann_train_epoch_irpropm(struct fann *ann, struct fann_train_data *data)
 	return fann_get_MSE(ann);
 }
 
+float fann_train_epoch_irpropm_lw(struct fann *ann, struct fann_train_data *data, fann_type* label_weight)
+{
+	unsigned int i;
+
+	if(ann->prev_train_slopes == NULL)
+	{
+		fann_clear_train_arrays(ann);
+	}
+
+	fann_reset_MSE(ann);
+
+	for(i = 0; i < data->num_data; i++)
+	{
+		fann_run(ann, data->input[i]);
+		fann_compute_MSE_lw(ann, data->output[i], label_weight[i]);
+		fann_backpropagate_MSE(ann);
+		fann_update_slopes_batch(ann, ann->first_layer + 1, ann->last_layer - 1);
+	}
+
+	fann_update_weights_irpropm(ann, 0, ann->total_connections);
+
+	return fann_get_MSE(ann);
+}
+
+
+
 /*
  * Internal train function 
  */
@@ -244,6 +270,24 @@ FANN_EXTERNAL float FANN_API fann_train_epoch(struct fann *ann, struct fann_trai
 	return 0;
 }
 
+FANN_EXTERNAL float FANN_API fann_train_epoch_lw(struct fann *ann, struct fann_train_data *data, 
+fann_type* label_weight)
+{
+	if(fann_check_input_output_sizes(ann, data) == -1)
+		return 0;
+
+	switch (ann->training_algorithm)
+	{
+	case FANN_TRAIN_RPROP:
+		return fann_train_epoch_irpropm_lw(ann, data, label_weight);
+	default:
+	        printf("FANN : fann_train_epoch_lw not implemented with others algo\n");
+	}
+	return 0;
+}
+
+
+
 FANN_EXTERNAL void FANN_API fann_train_on_data(struct fann *ann, struct fann_train_data *data,
 											   unsigned int max_epochs,
 											   unsigned int epochs_between_reports,

src/include/fann_train.h

@@ -212,6 +212,7 @@ FANN_EXTERNAL void FANN_API fann_train_on_file(struct fann *ann, const char *fil
 	This function appears in FANN >= 1.2.0.
  */ 
 FANN_EXTERNAL float FANN_API fann_train_epoch(struct fann *ann, struct fann_train_data *data);
+FANN_EXTERNAL float FANN_API fann_train_epoch_lw(struct fann *ann, struct fann_train_data *data, fann_type* label_weight);
 #endif	/* NOT FIXEDFANN */
 
 /* Function: fann_test_data