Apprendre à voir [Partie 11 : Des aiguilles dans une botte de foin]

Find AI Tools
No difficulty
No complicated process
Find ai tools

Apprendre à voir [Partie 11 : Des aiguilles dans une botte de foin]

Table of Contents

  1. Introduction
  2. The Challenge of Slow Code
  3. The Complexity of Rule Search
  4. The Intractability Issue
  5. The Distinction Between P and NP
  6. The Search for Scalable Solutions
  7. The Advent of Decision Trees
  8. The Speed and Efficiency of Decision Trees
  9. Leveraging Information for Faster Results
  10. Conclusion

🌟 Le Défi du Code Lent

Lors de notre dernière tentative d'exécution de code, nous avons constaté que celui-ci n'était terminé qu'à 4% seulement au bout de quelques minutes. Après avoir préparé un café et attendu encore 57 minutes, notre code a finalement abouti à son terme. Si notre objectif était simplement d'apprendre à notre machine à reconnaître des règles basées sur les pixels pour classer des représentations binaires de chiffres et d'images, cela ne poserait pas de problème. Cependant, nous souhaitons que notre approche d'apprentissage automatique puisse s'appliquer à des problèmes bien plus complexes. Le fait de s'en tenir à des règles qui utilisent uniquement quatre des 81 Dimensions de nos données pose un réel problème.

🚀 La Complexité de la Recherche de Règles

Si vous avez déjà programmé, vous savez probablement qu'il existe des moyens beaucoup plus efficaces de programmer notre algorithme que d'utiliser des boucles Python. Avant de nous aventurer sur cette voie, examinons de plus près ce qui a rendu notre code si lent. Si nous revenons en arrière, nous constatons que ces boucles ont mis respectivement 0,2, 3 et 94 secondes à s'exécuter dans les cas où nous utilisions un, deux ou trois pixels. Bien que chacun de ces temps ne soit pas problématique en soi, ils révèlent une tendance inquiétante : nos temps d'exécution augmentent de manière exponentielle à mesure que la complexité de nos règles augmente.

Ce qui est vraiment préoccupant, c'est la vitesse à laquelle nos temps d'exécution augmentent. En théorie, le temps d'exécution devrait être proportionnel au nombre de règles que nous testons et au nombre d'exemples sur lesquels nous testons chaque règle. En ajoutant plus de pixels pour augmenter la complexité de nos règles, nous avons maintenu constant le nombre d'exemples testés pour chaque règle, mais nous avons dû tester un plus grand nombre de règles. En appelant le nombre de pixels dans une règle donnée "K", il y a 81 façons de choisir K pixels, et chaque pixel peut valoir 1 ou 0. Ainsi, pour un ensemble donné de K pixels, il existe 2^K règles possibles. Cela donne un total de 2^K * (81 choisir K) règles possibles.

Nous comprenons maintenant pourquoi notre règle à quatre pixels a pris autant de temps à trouver : nous avons dû examiner plus de 26 millions de règles. Ce qui est encore plus préoccupant, c'est ce qui se passe lorsque nous continuons à augmenter K. Si nous faisons l'hypothèse que le temps nécessaire pour tester chaque règle reste le même, il faudrait environ 31 heures pour trouver la meilleure règle à cinq pixels et 33 jours pour trouver la meilleure règle à six pixels. La croissance exponentielle que nous observons ici signifie que, quelle que soit la rapidité de notre ordinateur ou l'efficacité de notre code, nous ne pourrons jamais trouver les meilleures règles pour des valeurs même modestes de K dans un délai raisonnable.

❗ L'Intractabilité du Problème

Même si notre code s'exécutait mille fois plus rapidement, il faudrait quand même environ deux semaines pour trouver la meilleure règle à huit pixels. Ainsi, ce n'est pas simplement l'implémentation spécifique de notre algorithme d'apprentissage qui est lente. Il y a quelque chose de plus fondamental dans notre approche de l'apprentissage à partir de données qui échoue lorsque K augmente. Nous avons trouvé une approche qui permet réellement d'apprendre à partir des données, mais la nature de notre algorithme signifie que nous ne pouvons tout simplement pas l'utiliser pour les problèmes de taille moyenne et plus importants qui nous intéressent réellement. Cela signifie que notre approche ne peut pas être mise à l'échelle.

Nous ne sommes bien sûr pas les premiers à rencontrer ce problème. Cette incapacité à mettre à l'échelle est connue sous le nom d'"intratabilité" et a empêché de nombreux premiers algorithmes d'intelligence artificielle de se développer au-delà des données de démonstration. Intéressant, depuis lors, nous avons découvert que de nombreux problèmes que nous cherchons à résoudre tombent naturellement dans l'une des deux catégories suivantes : ceux qui peuvent être résolus dans un temps qui augmente de manière polynomiale avec la taille du problème, et ceux qui peuvent être résolus dans un temps qui augmente de manière exponentielle avec la taille du problème. Aujourd'hui, cette distinction est une partie critique de l'informatique tant pratique que théorique, elle nous en dit beaucoup sur la complexité intrinsèque d'un problème donné. En fait, si vous demandez à un informaticien la difficulté d'un problème, il peut vous répondre en vous indiquant comment le temps requis pour résoudre le problème augmente avec la taille du problème. Cette méthode de mesure de la difficulté d'un problème a conduit les informaticiens à classer les problèmes en classes de complexité en fonction de ces critères. Les problèmes qui peuvent être résolus en temps polynomial sont dits appartenir à la classe de complexité "P", et de nombreux problèmes intéressants qui semblent pouvoir être résolus en temps exponentiel relèveront de la classe de complexité "NP". À mesure que la taille de notre problème augmente, les différences entre ces deux classes deviennent évidentes, ce qui signifie que nous pouvons généralement résoudre des problèmes dans la classe "P", tandis que les problèmes de la classe "NP" deviennent rapidement intraitables. Plus intéressant encore, bien qu'on pense largement que c'est vrai, prouver que "P" est effectivement différent de "NP" reste une question de recherche ouverte, et prouver l'une ou l'autre de ces affirmations vaut la jolie somme d'un million de dollars de la part de l'Institut Clay de mathématiques.

👉 À la Recherche de Solutions Scalables

Nos recherches jusqu'à présent suggèrent que notre problème, c'est-à-dire trouver la meilleure règle à K pixels à partir d'exemples d'apprentissage avec des étiquettes, n'appartient pas à la classe de complexité "P". Autrement dit, il semble qu'il n'y ait pas de solution qui mette à l'échelle sous la forme d'une fonction polynomiale de la taille de notre entrée. Si tel est le cas, cela signifie que notre problème est aussi difficile, voire plus difficile, qu'une grande classe de problèmes très complexes. De plus, cela signifie que notre approche de l'apprentissage à partir de données ne pourra probablement jamais être mise à l'échelle.

Avant de baisser les bras, il est important de se rappeler que le fait de trouver une seule mauvaise solution à notre problème ne signifie pas qu'il n'existe pas de bonnes solutions. Nous devons être un peu plus quantitatifs sur la complexité temporelle de notre solution pour trouver la meilleure règle à K pixels. Plus tôt, nous avons calculé que nous devions tester 2^K (81 choisir K) règles pour trouver la meilleure règle utilisant K parmi nos 81 pixels. Soyez plus général ici et appelez la taille de nos exemples N (dans notre cas, N = 81). Le temps requis pour exécuter notre algorithme devrait dépendre du nombre d'exemples sur lesquels nous testons nos règles. Appelons cela M. Comment le temps requis pour exécuter notre algorithme change-t-il par rapport à K, N et M ? Nous devons tester 2^K (81 choisir K) * M règles individuelles. Tant que le temps requis pour tester une règle individuelle sur un exemple individuel est constant, l'augmentation du temps d'exécution de notre algorithme devrait suivre cette tendance. Comme nous le savons, cette fonction devient énorme, même pour des valeurs modérées de K, rendant notre solution intraitable.

Maintenant que nous avons une meilleure idée de la situation désastreuse dans laquelle nous nous trouvons, demandons-nous s'il existe une solution à ce problème. Pourrait-il y avoir une approche différente qui ne soit pas si terriblement inadaptée à la mise à l'échelle ? Serions-nous condamnés à répéter les mêmes erreurs ? N'oublions pas que le véritable problème réside dans le nombre de règles que nous devons vérifier, qui augmente avec le nombre de pixels dans notre règle. Comme nous vérifions chaque règle possible, le temps requis pour exécuter notre algorithme croît aussi rapidement que le nombre de règles possibles. Alors que notre meule de foin devient exponentiellement immense, nous continuons à rechercher notre aiguille de manière brute en examinant chaque brin de foin. Mais et si ce n'était pas nécessaire ? Et si nous pouvions tester une infime fraction des règles possibles et, en utilisant judicieusement les informations que nous tirons de chaque test, trouver rapidement une règle offrant les mêmes performances que celle que nous avons trouvée par recherche brute ? Merveilleusement, une stratégie qui réalise exactement cela a été découverte dans les années 1970 et 1980 par plusieurs chercheurs travaillant indépendamment dans les domaines de la statistique et de l'apprentissage automatique. Les algorithmes qu'ils ont développés, appelés arbres de décision, vont nous permettre d'accélérer considérablement notre recherche. La rapidité des arbres de décision appliqués à notre problème est tout simplement stupéfiante. Dans le cas à quatre pixels, notre approche brutale aurait nécessité 209 milliards de tests individuels, tandis que les arbres de décision n'en nécessiteront que 2,6 millions, ce qui amène ces arbres de décision à être 82 000 fois plus rapides que la recherche brutale. Et ce qui est encore plus incroyable, c'est qu'à mesure que la taille de notre problème augmente, les arbres de décision restent une solution viable et offrent une accélération encore plus spectaculaire par rapport à notre approche intractable de recherche brute. Grâce aux arbres de décision, nous serons capables de trouver une règle à 10 pixels en moins d'une seconde, alors que notre approche brutale nécessiterait plus de 8 000 ans. Les arbres de décision sont donc littéralement des trillions de fois plus rapides que notre approche brutale dans le cas à 10 pixels. Comment cela est-il possible ? Comment ces chercheurs ont-ils exploité les informations tirées d'un si petit nombre de tests ? Comment trouver une aiguille dans une botte de foin sans devoir examiner chaque brin de foin ? La réponse sera révélée dans la section suivante.

Most people like

Are you spending too much time looking for ai tools?
App rating
4.9
AI Tools
100k+
Trusted Users
5000+
WHY YOU SHOULD CHOOSE TOOLIFY

TOOLIFY is the best ai tool source.