Learning Deep Forest, un nouveau dispositif d'apprentissage comparable à DNN

Je veux aller dans les buissons de Deep Forest, pas dans les ténèbres de Deep Learning.

Un algorithme qui peut être une alternative à DNN est Deep Forest. Lisez l'article Deep Forest: Toward the Alternative of Deep Neural Network ou [Article](https://arxiv.org/pdf/1702.08835. Quand je lis pdf), il semble qu'il ait une structure profonde en utilisant plusieurs collections d'arbres de décision appelés forêts aléatoires et en les organisant beaucoup dans le sens de la largeur et de la profondeur.

Cet article est utile pour les forêts aléatoires. C'est une explication de la forêt aléatoire dans un outil d'apprentissage automatique appelé scikit-learn qui est un module de python, mais comme le code à exécuter cette fois est également Python et que scikit-learn est utilisé, il est incroyablement utile.

Il semble y avoir une implémentation en langage R autre que Python. (Exemple de code d'implémentation Deep Forest)

Obtenez le code

Créer une forêt profonde à partir de zéro est difficile. Je me perds. Alors, obtenez la Deep Forest implémentée en Python à partir de github.

https://github.com/leopiney/deep-forest

De l'apprentissage aux tests, README fonctionne bien. Le taux de réponse correct semble raisonnable et pas mal. À propos, comme il n'est compatible qu'avec le processeur, le taux d'utilisation du processeur sera assez élevé.

Enregistrer le modèle

J'ai hâte de tout expérimenter, mais c'est un peu gênant que je ne puisse pas enregistrer le modèle entraîné, donc j'ajouterai les deux fonctions membres suivantes à la classe MGCForest dans deep_forest.py.

deep_forest.py

class MGCForest():

    :
    :
    :

    def save_model(self):
        # save multi-grained scanner
        for mgs_instance in self.mgs_instances:
            stride_ratio = mgs_instance.stride_ratio
            folds = mgs_instance.folds
            for i, estimator in enumerate(mgs_instance.estimators):
                joblib.dump(estimator, 'model/mgs_submodel_%.4f_%d_%d.pkl' % (stride_ratio, folds, i + 1)) 
        
        # save cascade forest
        for n_level, one_level_estimators in enumerate(self.c_forest.levels):
            for i, estimator in enumerate(one_level_estimators):
                joblib.dump(estimator, 'model/cforest_submodel_%d_%d.pkl' % (n_level + 1, i + 1))

    def load_model(self):
        # load multi-grained scanner
        for mgs_instance in self.mgs_instances:
            stride_ratio = '%.4f' % mgs_instance.stride_ratio
            folds = mgs_instance.folds
            for i in range(len(mgs_instance.estimators)):
                model_name = 'model/mgs_submodel_%s_%d_%d.pkl' % (stride_ratio, folds, i + 1)
                print('load model: {}'.format(model_name))
                mgs_instance.estimators[i] = joblib.load(model_name)

        # load cascade forest
        model_files = glob.glob('model/cforest_submodel_*.pkl')
        model_files.sort()
        max_level = 0
        model_dict = dict()
        for model_name in model_files:
            model_subname = re.sub('model/cforest_submodel_', '', model_name)
            model_level = int(model_subname.split('_')[0])
            if max_level < model_level:
                max_level = model_level

            if model_level not in model_dict.keys():
                model_dict[model_level] = list()
            print('load model: {}'.format(model_name))
            model_dict[model_level].append(joblib.load(model_name))

        self.c_forest.levels = list()
        for n_level in range(1, max_level + 1):
            self.c_forest.levels.append(model_dict[n_level])

        n_classes_ = self.c_forest.levels[0][0].n_classes_
        self.c_forest.classes = np.unique(np.arange(n_classes_))

Si vous appelez la fonction save_model après l'entraînement avec la fonction fit, les paramètres du modèle seront enregistrés dans le répertoire model (veuillez créer le répertoire model et vider le contenu avant d'appeler la fonction save_model). Si vous souhaitez charger les paramètres du modèle entraîné, vous pouvez appeler la fonction load_model.

Deep Forest est créé par plusieurs forêts aléatoires, mais lors de l'enregistrement d'un modèle, il est nécessaire de créer et d'enregistrer un fichier de paramètres pour chaque forêt aléatoire. Par conséquent, il existe plusieurs fichiers pkl dans le répertoire du modèle.

À l'origine, la forêt aléatoire a l'avantage qu'il s'agit d'un modèle qui n'est pas affecté par la différence dans la plage de valeurs de chaque quantité d'entité. Les réseaux de neurones ne le font pas, vous devez donc normaliser la plage de valeurs pour chaque fonctionnalité de 0 à 1. Par conséquent, j'espère que cette forêt profonde inspirera grandement sa puissance lorsque vous souhaitez combiner non seulement des images mais également diverses autres fonctionnalités.