Ejemplo n.º 1
0
    def load_snapshot(self, model, epoch: int):
        path = self.get_snapshot_path(epoch)

        if not os.path.exists(path):
            return None

        logger.debug('loading snapshot epoch %d from %s', epoch, path)
        model.load_weights(path)
Ejemplo n.º 2
0
    def dump_snapshot(self, model, epoch: int):
        if not os.path.exists(
                os.path.join(self.exp_absolute_path,
                             self.snapshots_dir_relative_path)):
            os.makedirs(
                os.path.join(self.exp_absolute_path,
                             self.snapshots_dir_relative_path))

        path = self.get_snapshot_path(epoch)
        logger.debug('saving snapshot epoch %d at %s', epoch, path)
        model.save_weights(path)
Ejemplo n.º 3
0
def load_config(path, handler=None):
    import os

    if not os.path.exists(path):
        raise RuntimeError('could not find path: ' + path)

    if os.path.isdir(path):
        new_path = os.path.join(path, 'config.json')
        logger.debug('found a directory at path:', path,
                     '\nLooking for a config file in:', new_path)
        path = new_path

    handler = get_handler(handler or 'DefaultLocal', instantiate=False)
    return handler.load_config(path)
Ejemplo n.º 4
0
    def kfold_cross_validation(self, n_splits):
        """
            Evaluates the precision of the classifier by running its prediction on the training data set
            :param n_splits: number of splits to split the training data into
            :type n_splits: int
            :return: the percentage of correctly predicted categories
            :rtype: float
        """

        if n_splits == 1:
            return np.mean(
                self.predict(self._clf_data.data) == self._clf_data.target)

        length = len(self._clf_data.data)
        sub_length = int(length / n_splits)
        logger.info(
            "Training data splitted in {} splits, each of length of {}, for a total length of {}"
            .format(n_splits, sub_length, length))

        splits = []
        for i in range(0, n_splits):
            split = ClassifierData(
                self._clf_data.data[i:i + sub_length],
                self._clf_data.target[i:i + sub_length],
                self._clf_data.target_names[i:i + sub_length])
            splits.append(split)
            split_length = len(split.data)

        total = 0
        precisions = []

        for split in splits:
            training_data = ClassifierData([], [], self.target_names)
            total += len(split.data)

            for other_split in splits:
                if other_split != split:
                    for i in range(len(other_split.data)):
                        training_data.data.append(other_split.data[i])
                    for i in range(len(other_split.data)):
                        training_data.target.append(other_split.target[i])

            #type(self) will invoke the right constructor for children
            test_classifier = type(self)(training_data.data,
                                         training_data.target,
                                         training_data.target_names)
            test_classifier.train()
            logger.debug("Trained on split {}".format(split))

            precision = np.mean(
                test_classifier.predict(split.data) == split.target)
            logger.debug("Precision on other split {} : {}".format(
                split, precision))

            precisions.append(precision)
            logger.debug("Total added splits length: {}".format(total))

        return np.mean(precisions)
Ejemplo n.º 5
0
def get_feature(feature_name, **params):
    assert isinstance(feature_name, str)
    logger.debug('Fetching %s Feature', feature_name)
    return mapping[feature_name.lower()](**params)