Existe-t-il un moyen de mesurer explicitement la complexité d'un modèle d'apprentissage automatique en Python
Je m'intéresse au débogage de modèle et l'un des points qu'il recommande est de comparer votre modèle avec un modèle "moins complexe" afin de voir si les performances sont nettement meilleures sur le modèle le plus complexe.
Cela soulève ma question:
Supposons que vous ayez un modèle d'ensemble et un modèle linéaire pour une tâche de classification "Il semble naturel de penser que le modèle d'ensemble est plus complexe que le modèle linéaire"
Mais quel serait le moyen de mesurer numériquement la complexité du modèle afin de pouvoir comparer deux ou plusieurs modèles en ces termes?
Existe-t-il une implémentation python qui peut vous aider dans une telle tâche?
Réponses
Je n'ai entendu parler d'aucune façon indépendante du modèle de mesurer la complexité du modèle. Il existe plusieurs stratégies, mais elles dépendent du modèle.
Vous pouvez résoudre le problème en utilisant différentes familles de modèles.
Pour les modèles linéaires, vous pouvez compter le nombre de paramètres différents de zéro utilisés. Nombre d'entités utilisées pour la prédiction.
Pour l' arbre de décision, vous pouvez compter la profondeur maximale atteinte par l'arbre.
Pour les réseaux de neurones, vous pouvez compter le nombre de paramètres que votre NN optimise.
Pour les méthodes d'ensemble (forêt aléatoire, amplification de gradient), vous pouvez utiliser une agrégation des différents apprenants faibles utilisés dans le modèle.
Pour l'implémentation python, il existe plusieurs implémentations en fonction du modèle pour lequel vous souhaitez la mesurer. Certains d'entre eux si vous remarquez sont vraiment faciles à mesurer.
Il est intuitivement difficile de comparer la complexité entre différentes familles de modèles. Qu'est-ce qui est plus complexe une régression linéaire avec 4 coefficients ou un arbre de décision avec max_depth = 3?
Sur le sujet de la complexité de l'apprentissage profond, Hinton, Oriol, Jeff Dean ont publié un article Distilling the knowledge of a Neural Network . Où ils parlent de simplifier la complexité d'un réseau neuronal.
C'est peut-être un peu naïf mais la première idée qui me vient à l'esprit est de simplement compter le nombre de paramètres à estimer lors de l'entraînement: plus il y a de valeurs à estimer, plus le modèle est complexe, puisque l'espace d'hypothèses est plus grand . Par exemple, un modèle linéaire n'a besoin que$n+1$ paramètres (avec $n$le nombre de caractéristiques), alors que le nombre de paramètres dont un modèle d'ensemble a besoin est la somme des nombres de paramètres pour chaque apprenant, il est donc susceptible d'être plus élevé. Cette idée pourrait être affinée pour prendre en compte la plage de valeurs d'un paramètre.
En guise d'approximation très grossière, on pourrait simplement calculer la taille de l'objet qui représente le modèle en python (en supposant que la représentation du modèle est efficace en espace, ce n'est pas toujours le cas).
Comme vous le savez probablement, la «complexité» est un terme chargé en informatique. Normalement, la complexité est mesurée en «notation big-O» et concerne la façon dont les solutions évoluent dans le temps à mesure que le nombre d'entrées augmente. Par exemple, cet article traite de la complexité de calcul des couches convolutives.
Dans l'apprentissage profond, cependant, les architectures de réseaux neuronaux concurrentes appliquent généralement le même algorithme (rétropropagation) aux mêmes types de problèmes (par exemple, la classification ImageNet); la seule différence est l'architecture. En outre, la plupart des architectures utilisent des éléments de calcul similaires (par exemple, des couches convolutives et des couches linéaires). C'est donc une convention d'utiliser le nombre de paramètres comme substitut de la complexité. Il est vrai que ce n'est qu'une approximation: deux réseaux peuvent avoir le même nombre de paramètres mais nécessitent des nombres d'opérations différents. Mais c'est généralement une bonne approximation, étant donné que différentes architectures ont généralement les similitudes mentionnées ci-dessus, mais peuvent avoir des tailles qui diffèrent de plusieurs ordres de grandeur.
À titre de référence, considérons la figure 1 du document EfficientNet . Ils utilisent le nombre de paramètres pouvant être entraînés comme substitut de la «taille du modèle» et notent que le nombre de paramètres est corrélé plus ou moins linéairement avec le temps d'exécution.
En ce qui concerne une fonction Python qui compte le nombre de paramètres trainable, cela dépendra si vous utilisez Keras, tensorflow, PyTorch, etc. Keras, ceci est une ligne: model.count_params(). Dans PyTorch, vous pouvez le calculer model.parameters()comme indiqué ici .
Comme mentionné par d'autres réponses ici, lorsque nous parlons de complexité du modèle, nous pensons généralement au nombre de paramètres que le modèle apprend. Quand quelqu'un parle de comparer à un modèle moins complexe, cela veut souvent dire comparer à un modèle intuitivement moins complexe (soit un modèle de la même classe, par exemple un réseau de neurones avec moins de neurones, soit un modèle d'une classe plus simple, par exemple un modèle linéaire plutôt qu'une forêt aléatoire).
Une façon de penser à la complexité d'un modèle entre des modèles très différents est la complexité de Kolmogorov , et vous pouvez l'approcher en regardant la quantité d'espace occupé par vos modèles enregistrés (par exemple décapés). Dans l'exemple que vous avez donné, l'ensemble occuperait plus d'espace disque que le modèle linéaire, à moins que l'ensemble ne soit plus simple que le modèle linéaire (par exemple, un ensemble de deux modèles linéaires avec 10 coefficients appris chacun contre un modèle linéaire avec 200 coefficients appris).
Une option est le critère d'information bayésien (BIC) qui est un critère de sélection de modèle qui tente de récompenser l'ajustement de la modélisation, tel que mesuré par la probabilité maximisée, tout en pénalisant le nombre de paramètres.
Une implémentation de BIC est dans le RegscorePypackage.
1. Mais quelle serait une façon de mesurer numériquement la complexité du modèle afin de pouvoir comparer deux ou plusieurs modèles en ces termes?
Vous pouvez utiliser la dimension VC pour mesurer la complexité d'un modèle dans un format numérique. Voir la dimension Vapnik – Chervonenkis sur Wikipedia .
2. Existe-t-il une implémentation python qui peut vous aider dans une telle tâche?
Il existe déjà un lien d'échange de pile qui explique la dimension VC. Comment calculer la dimension VC?