Class: RubyFann::Shortcut

new(hash) → new ruby-fann neural network object

Initialization routine for both standard, shortcut & filename forms of FANN:

Standard Initialization:

  RubyFann::Standard.new(:num_inputs=>1, :hidden_neurons=>[3, 4, 3, 4], :num_outputs=>1)

Shortcut Initialization (e.g., for use in cascade training):

  RubyFann::Shortcut.new(:num_inputs=>5, :num_outputs=>1)

File Initialization

  RubyFann::Standard.new(:filename=>'xor_float.net')

cascadetrain_on_data(train_data, max_neurons, neurons_between_reports, desired_error)

Perform cascade training with training data created with RubyFann::TrainData.new

            max_epochs - The maximum number of neurons in trained network
            neurons_between_reports - The number of neurons between printing a status report to stdout.
            desired_error - The desired <get_MSE> or <get_bit_fail>, depending on which stop function
            is chosen by <set_train_stop_function>.

get_MSE()

Reads the mean square error from the network.

get_activation_steepness(layer, neuron) → return value

Get the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0.

get_bias_array()

Return array of bias(es)

get_bit_fail()

    The number of fail bits; means the number of output neurons which differ more

than the bit fail limit (see <fann_get_bit_fail_limit>, <fann_set_bit_fail_limit>). The bits are counted in all of the training data, so this number can be higher than the number of training data.

get_bit_fail_limit()

Returns the bit fail limit used during training.

get_cascade_activation_functions()

The cascade activation functions is an array of the different activation functions used by

            the candidates.  The default is [:sigmoid, :sigmoid_symmetric, :gaussian, :gaussian_symmetric, :elliot, :elliot_symmetric]

get_cascade_activation_functions_count()

The number of activation functions in the <get_cascade_activation_functions> array

get_cascade_activation_steepnesses()

The cascade activation steepnesses array is an array of the different activation functions used by

            the candidates.

get_cascade_activation_steepnesses_count()

The number of activation steepnesses in the <get_cascade_activation_functions> array.

get_cascade_candidate_change_fraction()

The cascade candidate change fraction is a number between 0 and 1

get_cascade_candidate_limit()

The candidate limit is a limit for how much the candidate neuron may be trained.

            The limit is a limit on the proportion between the MSE and candidate score.

get_cascade_candidate_stagnation_epochs()

The number of cascade candidate stagnation epochs determines the number of epochs training is allowed to

            continue without changing the MSE by a fraction of <get_cascade_candidate_change_fraction>.

get_cascade_max_cand_epochs()

The maximum candidate epochs determines the maximum number of epochs the input

            connections to the candidates may be trained before adding a new candidate neuron.

get_cascade_max_out_epochs()

The maximum out epochs determines the maximum number of epochs the output connections

            may be trained after adding a new candidate neuron.

get_cascade_num_candidate_groups()

The number of candidate groups is the number of groups of identical candidates which will be used

            during training.

get_cascade_num_candidates()

The number of candidates used during training (calculated by multiplying <get_cascade_activation_functions_count>,

            <get_cascade_activation_steepnesses_count> and <get_cascade_num_candidate_groups>).

get_cascade_output_change_fraction()

The cascade output change fraction is a number between 0 and 1

get_cascade_output_stagnation_epochs()

The number of cascade output stagnation epochs determines the number of epochs training is allowed to

            continue without changing the MSE by a fraction of <get_cascade_output_change_fraction>.

get_cascade_weight_multiplier()

The weight multiplier is a parameter which is used to multiply the weights from the candidate neuron

            before adding the neuron to the neural network. This parameter is usually between 0 and 1, and is used
            to make the training a bit less aggressive.

get_connection_rate()

Get the connection rate used when the network was created.

get_layer_array()

Get list of layers in array format where each element contains number of neurons in that layer

get_learning_momentum()

Get the learning momentum.

get_learning_rate()

The learning rate is used to determine how aggressive training should be for some of the

            training algorithms (:incremental, :batch, :quickprop).
            Do however note that it is not used in :rprop.
            The default learning rate is 0.7.

get_network_type()

Get the type of network. Returns as ruby symbol (one of :shortcut, :layer)

get_neurons(layer) → return value

Return array<hash> where each array element is a hash representing a neuron. It contains the following keys:

            :activation_function, symbol -- the activation function
            :activation_steepness=float -- The steepness of the activation function
            :sum=float -- The sum of the inputs multiplied with the weights
            :value=float -- The value of the activation fuction applied to the sum
            :connections=array<int> -- indices of connected neurons(inputs)

      This could be done more elegantly (e.g., defining more ruby ext classes).
            This method does not directly correlate to anything in FANN, and accesses
            structs that are not guaranteed to not change.

get_num_input()

Get the number of input neurons.

get_num_layers()

Get the number of layers in the network.

get_num_output()

Get the number of output neurons.

get_quickprop_decay()

The decay is a small negative valued number which is the factor that the weights should become smaller in each iteration during quickprop training. This is used to make sure that the weights do not become too high during training.

get_quickprop_mu()

The mu factor is used to increase and decrease the step-size during quickprop training. The mu factor should always be above 1, since it would otherwise decrease the step-size when it was suppose to increase it.

get_rprop_decrease_factor()

The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training.

get_rprop_delta_max()

The maximum step-size is a positive number determining how large the maximum step-size may be.

get_rprop_delta_min()

The minimum step-size is a small positive number determining how small the minimum step-size may be.

get_rprop_delta_zero()

The initial step-size is a positive number determining the initial step size.

get_rprop_increase_factor()

The increase factor is a value larger than 1, which is used to increase the step-size during RPROP training.

get_total_connections()

Get the total number of connections in the entire network.

get_total_neurons()

Get the total number of neurons in the entire network.

get_train_error_function()

Returns the error function used during training. One of the following symbols:

                    :linear, :tanh

get_train_error_function()

Returns the error function used during training. One of the following symbols:

                    :linear, :tanh

get_train_stop_function()

Returns the training stop function. One of the following symbols:

                    :mse, :bit

get_training_algorithm()

Returns the training algorithm. One of the following symbols:

                    :incremental, :batch, :rprop, :quickprop

init_weights(train_data) → return value

Initialize the weights using Widrow + Nguyen‘s algorithm.

print_connections()

Will print the connections of the ann in a compact matrix,

            for easy viewing of the internals of the ann.

print_parameters()

Print current NN parameters to stdout

randomize_weights(min_weight, max_weight)

Give each connection a random weight between min_weight and max_weight

reset_MSE()

Resets the mean square error from the network.

    This function also resets the number of bits that fail.

run(inputs) → return value

Run neural net on array<Float> of inputs with current parameters. Returns array<Float> as output

save(filename) → return status

Save the entire network to configuration file with given name

set_activation_function(activation_func, layer, neuron)

Set the activation function for neuron number neuron in layer number layer,

            counting the input layer as layer 0.  activation_func must be one of the following symbols:
                    :linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric,
                    :sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot,
                    :elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric,
                    :sin, :cos

set_activation_function_hidden(activation_func)

Set the activation function for all of the hidden layers. activation_func must be one of the following symbols:

                    :linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric,
                    :sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot,
                    :elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric,
                    :sin, :cos

set_activation_function_layer(activation_func, layer)

Set the activation function for all the neurons in the layer number layer,

            counting the input layer as layer 0.  activation_func must be one of the following symbols:
                    :linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric,
                    :sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot,
                    :elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric,
                    :sin, :cos

  It is not possible to set activation functions for the neurons in the input layer.

set_activation_function_output(activation_func)

Set the activation function for the output layer. activation_func must be one of the following symbols:

              :linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric,
              :sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot,
              :elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric,
              :sin, :cos

set_activation_steepness(steepness, layer, neuron)

Set the activation steepness for neuron number {neuron} in layer number {layer}, counting the input layer as layer 0.

set_activation_steepness_hidden(arg) → return value

Set the activation steepness in all of the hidden layers.

set_activation_steepness_layer(steepness, layer)

Set the activation steepness all of the neurons in layer number layer, counting the input layer as layer 0.

set_activation_steepness_output(steepness)

Set the activation steepness in the output layer.

set_bit_fail_limit(bit_fail_limit)

Sets the bit fail limit used during training.

set_cascade_activation_functions(cascade_activation_functions)

The cascade activation functions is an array of the different activation functions used by

            the candidates.  The default is [:sigmoid, :sigmoid_symmetric, :gaussian, :gaussian_symmetric, :elliot, :elliot_symmetric]

set_cascade_activation_steepnesses(p1)

The cascade activation steepnesses array is an array of the different activation functions used by

            the candidates.

set_cascade_candidate_change_fraction(cascade_candidate_change_fraction)

The cascade candidate change fraction is a number between 0 and 1

set_cascade_candidate_limit(cascade_candidate_limit)

The candidate limit is a limit for how much the candidate neuron may be trained.

            The limit is a limit on the proportion between the MSE and candidate score.

set_cascade_candidate_stagnation_epochs(cascade_candidate_stagnation_epochs)

The number of cascade candidate stagnation epochs determines the number of epochs training is allowed to

            continue without changing the MSE by a fraction of <get_cascade_candidate_change_fraction>.

set_cascade_max_cand_epochs(cascade_max_cand_epochs)

The maximum candidate epochs determines the maximum number of epochs the input

            connections to the candidates may be trained before adding a new candidate neuron.

set_cascade_max_out_epochs(cascade_max_out_epochs)

The maximum out epochs determines the maximum number of epochs the output connections

            may be trained after adding a new candidate neuron.

set_cascade_num_candidate_groups(cascade_num_candidate_groups)

The number of candidate groups is the number of groups of identical candidates which will be used

            during training.

set_cascade_output_change_fraction(cascade_output_change_fraction)

The cascade output change fraction is a number between 0 and 1

set_cascade_output_stagnation_epochs(cascade_output_stagnation_epochs)

The number of cascade output stagnation epochs determines the number of epochs training is allowed to

            continue without changing the MSE by a fraction of <get_cascade_output_change_fraction>.

set_cascade_weight_multiplier(cascade_weight_multiplier)

The weight multiplier is a parameter which is used to multiply the weights from the candidate neuron

            before adding the neuron to the neural network. This parameter is usually between 0 and 1, and is used
            to make the training a bit less aggressive.

set_learning_momentum(learning_momentum) → return value

Set the learning momentum.

set_learning_rate(learning_rate) → return value

The learning rate is used to determine how aggressive training should be for some of the

            training algorithms (:incremental, :batch, :quickprop).
            Do however note that it is not used in :rprop.
            The default learning rate is 0.7.

set_quickprop_decay(quickprop_decay)

Sets the quickprop decay factor

set_quickprop_mu(quickprop_mu)

Sets the quickprop mu factor.

set_rprop_decrease_factor(rprop_decrease_factor)

The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training.

set_rprop_delta_max(rprop_delta_max)

The maximum step-size is a positive number determining how large the maximum step-size may be.

set_rprop_delta_min(rprop_delta_min)

The minimum step-size is a small positive number determining how small the minimum step-size may be.

set_rprop_delta_zero(rprop_delta_zero)

The initial step-size is a positive number determining the initial step size.

set_rprop_increase_factor(rprop_increase_factor)

The increase factor used during RPROP training.

set_train_error_function(train_error_function)

Sets the error function used during training. One of the following symbols:

                    :linear, :tanh

set_train_error_function(train_error_function)

Sets the error function used during training. One of the following symbols:

                    :linear, :tanh

set_train_stop_function(train_stop_function) → return value

Set the training stop function. One of the following symbols:

                    :mse, :bit

set_training_algorithm(train_error_function)

Set the training algorithm. One of the following symbols:

                    :incremental, :batch, :rprop, :quickprop

test_data(train_data) → return value

Test a set of training data and calculates the MSE for the training data.

train_epoch(train_data) → return value

Train one epoch with a set of training data, created with RubyFann::TrainData.new

train_on_data(train_data, max_epochs, epochs_between_reports, desired_error)

Train with training data created with RubyFann::TrainData.new

            max_epochs - The maximum number of epochs the training should continue
            epochs_between_reports - The number of epochs between printing a status report to stdout.
            desired_error - The desired <get_MSE> or <get_bit_fail>, depending on which stop function
                is chosen by <set_train_stop_function>.

Methods

Public Class methods

Public Instance methods