def train(self, network, data_set, name_metric_function, metric_value_min, nb_iterations_max, interval_check=100): """ Apply the training process on a `DataSet`, until the metric value computed using metric_function *equals or is greater than* metric_value_min. :Returns: integer : the number of iterations in the learning. :Raises NpyValueError: If interval_check is lower than 1. :Raises NpyTransferFunctionError: If name_metric_function does not correspond to a metric function. """ if interval_check < 1: raise NpyValueError, 'interval_check has to be greater or equal to 1' Factory.check_prefix(name_metric_function, Metric.prefix) metric_function = Factory.build_instance_by_name(name_metric_function) nb_iterations_current = 0 metric_value_computed = metric_value_min - 1 while nb_iterations_current < nb_iterations_max and metric_value_computed < metric_value_min: network.learn_cycles(data_set, interval_check) data_classification = network.classify_data_set(data_set) metric_value_computed = metric_function.compute_metric(data_set, data_classification) nb_iterations_current += interval_check return nb_iterations_current
def set_label_function(self, name_label_function): """ :Raises NpyTransferFunctionError: If name_label_function does not correspond to a label function. """ try: Factory.check_prefix(name_label_function, Label.prefix) self._label_function = Factory.build_instance_by_name(name_label_function) except NpyTransferFunctionError, e: raise NpyTransferFunctionError, e.msg
def train_network(self, network, data_set, name_metric_function, metric_value_min, nb_iterations_max, interval_check): """ Apply the training process on a `DataSet`, until the `Metric` value computed using metric_function *equals or is greater than* metric_value_min. This makes the assumption that the metric functions gives higher values for higher network performances. The training is stopped after nb_iterations_max to avoid infinite loops due to unreachable `Metric` values. """ if interval_check < 1: raise NpyValueError, 'interval_check has to be greater or equal to 1.' if nb_iterations_max != None and nb_iterations_max < 1: raise NpyValueError, 'nb_iterations_max has to be greater or equal to 1, or equal to None.' try: Factory.check_prefix(name_metric_function, Metric.prefix) metric_function = Factory.build_instance_by_name(name_metric_function) except NpyTransferFunctionError, e: raise NpyTransferFunctionError, e.msg
def add_unit(self, nb_nodes, name_activation_function=None, name_update_function=None, name_error_function=None): """ Adds a unit to the network as the new output unit. Takes care of making the connections with the previous unit. :Parameters: nb_nodes : integer Number of nodes required in the unit. name_activation_function : string Name of the `Activation` to use to compute the activation function for the current unit. name_update_function : string Name of the `Update` to use to compute the updates to the weights. name_error_function : string Name of the `Error` to use to compute the error of the `Unit`. If equal to None, then the error function is set automatically, depending on the unit position in the network. :Returns: The `Unit` that has just been added to the network. In the case of the input unit, None is returned. :Raises NpyTransferFunctionError: If the function names do not correspond to valid functions. :Raises NpyUnitError: If an error related to the unit topology is encountered. """ # A positive number of nodes is required if nb_nodes <= 0: raise NpyUnitError, 'Number of nodes must be strictly positive.' # And for the non-input units, the activation and update functions # must be defined. if self.unit_input != None \ and (name_activation_function == None or name_update_function == None): raise NpyUnitError, 'Activation and update functions must be specified.' # Handle the input unit if self.unit_input == None: unit = UnitInput(nb_nodes) self.unit_input = unit else: # Handle the other units if len(self.units) == 0: unit_previous = self.unit_input else: unit_previous = self.units[-1] if self.use_bias == True: # Add 1 in order to implement the bias nb_previous_nodes = unit_previous.get_nb_nodes() + 1 # Retreive transfert function instances try: Factory.check_prefix(name_activation_function, Activation.prefix) activation_function = Factory.build_instance_by_name(name_activation_function) Factory.check_prefix(name_update_function, Update.prefix) update_function = Factory.build_instance_by_name(name_update_function) if name_error_function == None: error_function = None else: Factory.check_prefix(name_error_function, Error.prefix) error_function = Factory.build_instance_by_name(name_error_function) except NpyTransferFunctionError, e: raise NpyTransferFunctionError, e.msg # Create the unit and add it to the network unit = Unit(nb_nodes, nb_previous_nodes, activation_function, update_function, error_function) self.units.append(unit)