[PYTHON] Algorithme de règles de domaine pour apprendre les règles interprétables - Peut également être utilisé à partir de lnterpretML de Microsoft Research -

J'ai trouvé une bibliothèque d'apprentissage des règles appelée skope-rules. Ceci est un projet scikit-learn-contrib. À titre de test, si vous exécutez l'exemple de code de l'ensemble de données iris que tout le monde aime, vous obtiendrez la règle suivante.

Rules for iris virginica
('petal_length > 4.75 and petal_width > 1.75', (0.9743589743589743, 0.9047619047619048, 1))
('petal_width > 1.6500000357627869', (0.9514316093263462, 0.9218081435472739, 3))
('petal_length > 5.049999952316284', (0.9696691176470589, 0.8007518796992481, 2))

Il y a une règle par ligne, par exemple, la première règle petal_length> 4,75 et petal_width> 1,75 a une précision d'environ 0,97, un rappel d'environ 0,90 et le nombre d'occurrences dans l'arbre de décision à partir duquel il a été appris. Lisez-le une fois. Je vois.

Utilisation de l'apprentissage des règles

Au fait, devrions-nous normalement classer par l'arbre de décision dans «l'arbre de décision original» ci-dessus? Maris de droite et de gauche qui ont pensé, oui, si vous êtes dans un environnement où vous pouvez déduire avec un arbre de décision compliqué, vous devriez utiliser XGBoost ou LightGBM pour obtenir de la précision, mais il y a certains sites où ce n'est pas le cas.

• L'arbre de décision compliqué ne peut pas être incorporé dans l'arête
• Dans de rares cas, un comportement qui provoque une désinférence inattendue n'est pas autorisé.
• Le même ensemble de données et le même environnement de vérification qu'au moment de l'inférence ne peuvent pas être préparés au moment de l'apprentissage

C'est un cas où des règles simples qui peuvent être interprétées plutôt que de l'exactitude sont requises. De plus, comme il existe de nombreuses fonctionnalités et qu'il est difficile de faire des essais et des erreurs en devinant les gens, je pense que ce type d'apprentissage de règles crée une dépendance lorsque l'on veut mien.

algorithme skope-rules

Le contour de l'algorithme est cité car la figure de README est facile à comprendre.

skope-rules/schema.png

En d'autres termes, il s'agit d'un flux d'apprentissage d'un grand nombre d'arbres de décision, de les désassembler pour obtenir un grand nombre de règles candidates, de filtrer et d'exclure des règles similaires, puis d'en produire des exactes. Le but de cet article est de lire ce détail à partir du code. Cependant, le corps principal est un fichier de moins de 700 lignes, de sorte que le flux est facile à suivre.

Bagging estimator

Tout d'abord, [Bagging] chacun des arbres de classification et de retour (http://ibisforest.org/index.php?%E3%83%90%E3%82%AE%E3%83%B3%E3%82%B0 ), Et créez de nombreux arbres de décision originaux tout en modifiant le paramètre de profondeur. Bien que les règles de domaine traitent de la classification binaire, elles sont également traitées comme un problème de pseudo régression en passant des échantillons de poids. Cependant, si aucun poids n'est passé, l'arbre de retour sera également appris à 0/1. On ne sait pas dans quelle mesure l'apprentissage non seulement de l'arbre de classification mais aussi de l'arbre de retour contribue à la règle finale, mais de toute façon, la règle inexacte sera abandonnée plus tard, donc pour le moment, c'est une atmosphère dans laquelle je peux me précipiter pour augmenter le nombre de candidats à la règle. Je ressens.

En tant que code

for max_depth in self._max_depths:
    bagging_clf = BaggingClassifier(
        base_estimator=DecisionTreeClassifier(
           max_depth=max_depth,
...
    bagging_reg = BaggingRegressor(
        base_estimator=DecisionTreeRegressor(
            max_depth=max_depth,

[skope-rules / skrules / skope_rules.py](https://github.com/scikit-learn-contrib/skope-rules/blob/d9a777f84836905f726cb6221fe335cc1b935ae5/skrules/skope_rules.py#L268 pour la lisibilité) * Formaté Cité

Avec ce sentiment, j'utilise la classe d'arbre de décision de scikit-learn. Par conséquent, les inconvénients de ne pas pouvoir gérer les variables catégorielles et les valeurs manquantes ont été repris tels quels ... Il semble que ce domaine soit pris en charge par des variables catégorielles dans scikit-learn lui-même, donc il pourrait être résolu bientôt. https://github.com/scikit-learn/scikit-learn/pull/12866

-> Set of logical rules

Suivez l'arbre de décision de la racine aux feuilles et connectez les conditions de branchement avec AND pour chaque chemin pour créer une règle.

def recurse(node, base_name):
    if tree_.feature[node] != _tree.TREE_UNDEFINED:
        name = feature_name[node]
        symbol = '<='
        symbol2 = '>'
        threshold = tree_.threshold[node]
        text = base_name + ["{} {} {}".format(name, symbol, threshold)]
        recurse(tree_.children_left[node], text)
        text = base_name + ["{} {} {}".format(name, symbol2, threshold)]
        recurse(tree_.children_right[node], text)
    else:
        rule = str.join(' and ', base_name)
        rule = (rule if rule != '' else ' == '.join([feature_names[0]] * 2))
        rules.append(rule)

skope-rules/skrules/skope_rules.py

Il s'agit d'une recherche de priorité en profondeur car elle est suivie d'une fonction récursive.

-> High performing rules

Out-of-Bag de l'arbre de décision d'origine pour chaque règle Calculer la précision et le rappel des données et à partir de la valeur minimale définie Ne laissez que les règles élevées.

Ce qui est un peu intéressant ici, c'est qu'au lieu d'utiliser l'arbre de décision d'origine pour déterminer si la règle est vraie

def _eval_rule_perf(self, rule, X, y):
    detected_index = list(X.query(rule).index)

skope-rules/skrules/skope_rules.py

Je nourris pandas.DataFrame.query comme. Dans skope-rules, les règles sont conservées sous forme de chaînes telles que petal_length> 4.75 et petal_width> 1.75, afin qu'elles puissent être traitées comme des requêtes. Cependant, étant donné que la chaîne de caractères est à nouveau fractionnée lors de la liste des quantités de caractéristiques décrites plus tard, on a l'impression qu'elle ne peut pas être mise en œuvre.

Semantic Rule Deduplication

Regroupez les règles similaires qui ont survécu ci-dessus pour laisser les meilleures règles pour les scores F1 pour chaque groupe. Sans cela, un certain nombre de règles avec des seuils légèrement différents seraient générés.

Qu'ils soient similaires ou non

def split_with_best_feature(rules, depth, exceptions=[]):
...
    for rule in rules:
        if (most_represented_term + ' <=') in rule[0]:
            rules_splitted[0].append(rule)
        elif (most_represented_term + ' >') in rule[0]:
            rules_splitted[1].append(rule)
        else:
            rules_splitted[2].append(rule)
        new_exceptions = exceptions+[most_represented_term]
        return [split_with_best_feature(ruleset, depth-1, exceptions=new_exceptions)
                for ruleset in rules_splitted]

skope-rules/skrules/skope_rules.py

En regardant les quantités d'entités couramment utilisées et leurs nombres d'inégalités dans l'ordre, on a l'impression qu'elles sont triées dans le même groupe si elles sont ensemble jusqu'à la profondeur définie.

Essayez d'appeler depuis lnterpretML

Maintenant, skope-rules est inclus dans le package lnterpretML développé par Microsoft Research, alors appelons-le également à partir de là. Une classe appelée DecisionListClassifier est un wrapper pour skope-rules.

from interpret.glassbox import DecisionListClassifier
from interpret import show
from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()
dlc = DecisionListClassifier()
dlc.fit(pd.DataFrame(iris.data, columns=iris.feature_names),
        iris.target == iris.target_names.tolist().index('virginica'))
show(dlc.explain_global())

Il n'y a qu'un ensemble d'interprétabilité, et cela semble bon.

Sentiments divers

Récemment, je m'intéresse à l'interprétabilité des modèles d'apprentissage automatique. Pour l'état actuel de l'interprétabilité, voir «Explication of Judgment Basis for Machine Learning Model (Ver.2)». Il y a plusieurs raisons de demander l'interprétabilité, mais dans interpréter / README de lnterpretML,

• Débogage: Pourquoi avez-vous supprimé l'inférence?
• L'équité: n'est-ce pas un modèle discriminatoire?
• Collaboration avec les gens: comment comprendre et faire confiance au modèle?
• Conformité: répondez-vous aux exigences de la loi?
• Domaines à haut risque: soins médicaux, finance, justice ...

Est écrit. Je pense que les points changeront en fonction du travail, mais ma motivation personnelle est que je veux aussi acquérir les connaissances découvertes par le modèle, et j'arrange et détourne les connaissances en incorporant mes propres pensées et intuition. Je sens que je veux le faire. Pour cela, je pense que nous devrions apprendre «un modèle lisible qui ne nécessite pas d'explication» dès le début au lieu de gérer un modèle compliqué, mais dans ce cas, combien de méthodes peuvent être utilisées? Dans Apprentissage automatique interprétable - Chapitre 4 Modèles interprétables], régression linéaire, régression logistique, modèle linéaire généralisé, modèle additif généralisé ・ Arbre de décision ・ RuleFit ・ Naive Bayes ・ k La méthode du voisinage est mentionnée. RuleFit, comme skope-rules, obtient les règles des arbres de décision, sauf qu'elles sont utilisées comme fonctionnalités pour la régression linéaire. Ici, bien sûr, il devrait y avoir un compromis entre la précision du modèle et l'interprétabilité, "[Le labyrinthe de l'explicabilité de l'apprentissage automatique (interprétabilité)](https://tjo.hatenablog.com/entry/2019/12/ Le chiffre de "Intelligence Artificielle Explicable (XAI): Concepts, Taxonomies, Opportunités et Défis vers une IA Responsable" introduit dans "19/190000)" est un sentiment. Je vais le citer car il est facile à comprendre.

Par conséquent, il doit y avoir une zone stérile même si vous recherchez une interprétabilité parfaite, et dans des domaines tels que les images et les langages naturels où l'apprentissage en profondeur a réussi, l'adversaire est la capacité cognitive humaine, de sorte que le modèle devient compliqué et mystérieux. Je me demande, mais j'ai une observation optimiste qu'une méthode plus équilibrée dort dans le domaine physique ou de l'ingénierie qui capture traditionnellement le phénomène avec une belle formule. Je suis. Il y a environ dix ans, "[L'intelligence artificielle qui a découvert les lois de la physique par elle-même](https://wired.jp/2009/04/15/%e3%80%8c%e7%89%a9%e7%90%86" % e6% b3% 95% e5% 89% 87% e3% 82% 92% e8% 87% aa% e5% 8a% 9b% e3% 81% a7% e7% 99% ba% e8% a6% 8b% e3 % 80% 8d% e3% 81% 97% e3% 81% 9f% e4% ba% ba% e5% b7% a5% e7% 9f% a5% e8% 83% bd /) »Programmation génétique est devenu un sujet brûlant, mais j'aimerais pouvoir apprendre un petit graphique de calcul comme celui-ci. Si vous l'utilisez pour la génération de quantité d'entités comme "Génération de quantités d'entités par programmation génétique", il peut être combiné avec diverses méthodes, donc je suppose qu'il n'y a aucun moyen ici. C'est à peu près cette heure aujourd'hui.