Python dans le Trading Algorithmique - page 21
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Testez facilement votre stratégie de coût moyen en dollars en Python
Testez facilement votre stratégie de coût moyen en dollars en Python
Dans les 20 prochaines minutes environ, nous mettrons en œuvre une stratégie de moyenne des coûts en dollars en Python. Cette stratégie vous permettra d'évaluer la performance de la moyenne d'achat pour un actif ou un indice spécifique sur une certaine période de temps. Nous utiliserons un outil appelé backtesting.py pour mettre en œuvre cette stratégie. Backtesting.py est un framework convivial en Python qui est moins intimidant que d'autres bibliothèques comme Vectorbt ou Backtrader. Si vous débutez avec Python, ce sera une excellente option pour vous.
La stratégie d'achats périodiques par sommes fixes que nous mettrons en œuvre est relativement simple, mais je vais également vous montrer comment l'étendre. Notre stratégie consiste à acheter un montant fixe en dollars d'un actif particulier tous les lundis ou mardis et à répéter ce processus jusqu'à ce que nous manquions de données. Pour commencer, ouvrez un terminal et configurez un nouvel environnement virtuel pour garantir un environnement propre pour notre implémentation. Une fois que vous avez configuré l'environnement virtuel, installez le package de backtesting à l'aide de pip :
backtest d'installation de pip
Après avoir installé le package, nous pouvons continuer avec notre fichier Python. Nous devrons importer certains modules et données nécessaires. Depuis le backtesting, importez les modules de backtest et de stratégie. De plus, importez des données factices à partir de backtesting.test, en particulier les données Google. Nous aurons également besoin du module pandas pour la manipulation des données.
Maintenant, définissons notre classe de stratégie. Créez une classe appelée DCA (Dollar Cost Average) qui hérite de la classe de stratégie. À l'intérieur de cette classe, nous allons définir une variable de classe appelée amount_to_invest, qui représente le montant fixe en dollars que nous voulons investir. Initialement, réglez-le sur 10.
Ensuite, nous devons définir deux fonctions dans cette classe : __init__ et next. La fonction __init__ est appelée lors de l'initialisation et est utilisée pour pré-calculer toutes les valeurs dont nous pourrions avoir besoin plus tard. Dans notre cas, nous allons créer un indicateur qui nous donne le jour de la semaine. Pour ce faire, nous allons utiliser la méthode self.indicator fournie par backtesting.py. Nous pouvons définir notre indicateur comme self.day_of_week = self.indicator(lambda x: x, self.data.close.s.dt.dayofweek). Cet indicateur renverra un tableau des valeurs du jour de la semaine (0-6, où lundi est 0 et dimanche est 6) pour nos données.
Passons maintenant à la fonction suivante, où nous implémentons notre logique de trading. Cette fonction est appelée pour chaque barre de données et nous permet de prendre des décisions en fonction des données actuelles. Dans notre cas, nous allons vérifier si le jour de la semaine est égal à 1 (mardi) en utilisant if self.day_of_week == 1:. Si c'est mardi, nous déclencherons un signal d'achat. Pour exécuter l'ordre d'achat, nous utiliserons la fonction self.buy fournie par backtesting.py. Nous pouvons calculer la taille de l'ordre d'achat en divisant le montant à investir par le cours de clôture actuel de l'actif. Pour nous assurer que nous achetons un nombre entier d'actions, nous pouvons utiliser math.floor pour arrondir le résultat.
Pour gérer les fractions d'actions, nous pouvons fractionner les actions en multipliant l'actif par un petit nombre, tel que 10 ** -6. Cela divisera les actions en microparts, qui pourront ensuite être reconverties en nombre réel d'actions achetées en divisant par le même petit nombre.
Enfin, nous devons exécuter le backtest et extraire les statistiques. Pour ce faire, nous pouvons utiliser bt.run() et affecter le résultat à une variable appelée stats. Nous pouvons également tracer les résultats en utilisant bt.plot().
Puisque nous n'avons pas encore implémenté la logique de vente, l'intrigue apparaît comme une ligne continue sans aucun argument de vente. Nous réglerons cela bientôt. Mais avant de le faire, extrayons quelques statistiques des résultats du backtest.
Pour ce faire, nous utiliserons la variable stats que nous avons définie précédemment. Nous pouvons imprimer diverses statistiques telles que le rendement total, le rendement annualisé, le prélèvement maximal, etc.
N'hésitez pas à ajouter plus de statistiques si vous souhaitez explorer des mesures de performances supplémentaires.
Passons maintenant à la mise en œuvre de la logique de vente. Comme nous utilisons une stratégie d'achats périodiques par sommes fixes, nous vendrons le même montant fixe chaque semaine. Dans notre cas, nous vendrons le vendredi.
Ici, nous vérifions si le jour de la semaine est 4 (vendredi) en utilisant l'indicateur day_of_week que nous avons créé précédemment. Si c'est vendredi, nous vendons le même montant en dollars que nous avons acheté plus tôt en divisant le montant_à_investir par le cours de clôture actuel. Cela garantit que nous vendons le nombre approprié d'actions correspondant au montant de notre investissement.
Maintenant, lorsque nous exécutons le backtest, nous devrions voir des points de vente sur le tracé, indiquant les vendredis où nous vendons notre position.
N'hésitez pas à expérimenter différentes variantes de cette stratégie, telles que l'ajustement des jours d'achat/vente ou la mise en place de conditions supplémentaires en fonction des mouvements de prix. Ce cadre vous permet d'étendre et de personnaliser facilement votre stratégie en fonction de vos besoins.
N'oubliez pas d'ajuster la variable amount_to_invest et d'explorer différentes données d'actifs pour voir comment la stratégie fonctionne.
J'espère que cela vous aidera à mettre en œuvre et à explorer la stratégie de moyenne des coûts en dollars à l'aide de la bibliothèque backtesting.py en Python. Dis moi si tu as d'autres questions!
Indicateurs personnalisés dans Backtesting.py - Python Deep Dive
Indicateurs personnalisés dans Backtesting.py - Python Deep Dive
Dans cette vidéo, nous allons explorer le processus de création d'indicateurs personnalisés dans la bibliothèque backtesting.py. Cette fonctionnalité nous permettra de tester facilement toute stratégie de trading en créant des indicateurs et en traduisant les fonctions Python dans un format compatible avec l'écosystème backtesting.py.
Avant de nous plonger dans les détails de la création d'indicateurs, il est recommandé de consulter un cours disponible gratuitement sur YouTube qui couvre la plupart des aspects de backtesting.py. Ce cours fournira une compréhension de haut niveau de la bibliothèque, ce qui sera utile lors de l'exploration de la création d'indicateurs dans cette vidéo.
Dans cette vidéo, nous allons nous concentrer sur trois exemples différents pour couvrir diverses idées d'indicateurs. Le premier exemple consiste à utiliser des signaux générés dans un programme Python externe et à les intégrer dans backtesting.py. Cette approche est utile lorsque vous avez déjà des signaux d'achat et de vente provenant d'une source externe et que vous souhaitez les incorporer dans votre processus de backtesting.
Le deuxième exemple démontrera l'utilisation de la bibliothèque pandas-ta pour renvoyer plusieurs valeurs pour chaque indicateur. Plus précisément, nous travaillerons avec l'indicateur des bandes de Bollinger et montrerons comment renvoyer une trame de données contenant à la fois les bandes inférieure et supérieure, au lieu d'un simple tableau numpy. Cet exemple mettra en évidence la polyvalence de la création d'indicateurs à valeurs multiples.
Enfin, nous allons coder une stratégie de momentum pour démontrer comment des indicateurs personnalisés peuvent être créés en utilisant Python pur. Cet exemple montrera la flexibilité de la création d'indicateurs à l'aide de la programmation Python, permettant des possibilités illimitées dans la conception d'indicateurs.
Pour suivre les exemples, assurez-vous que les bibliothèques nécessaires sont installées, y compris backtesting, pandas et pandas-ta. Une fois que vous avez installé ces bibliothèques, créez un fichier Python pour les exemples de code.
La partie initiale du code configure le passe-partout nécessaire lors de l'utilisation de backtesting.py. Il importe les classes requises, "backtest" et "stratégie", et importe des exemples de données pour le stock Google à partir de backtesting.py. Les données importées sont une trame de données pandas contenant des données de prix quotidiennes, y compris l'ouverture, le haut, le bas, la clôture et le volume, avec un index datetime.
Pour le premier exemple, nous supposons que vous avez déjà généré des signaux dans un programme externe et que vous souhaitez les transférer vers backtesting.py. Pour le démontrer, nous créons des signaux aléatoires à l'aide de numpy et les ajoutons à la trame de données Google. Ces signaux peuvent représenter n'importe quel indicateur que vous avez programmé en Python, où -1 indique un signal de vente, 0 indique aucune action et 1 représente un signal d'achat.
Ensuite, nous définissons une classe de stratégie appelée "SignalStrategy" qui hérite de la classe "Strategy" importée précédemment. Cette classe sera responsable de la mise en œuvre de la logique d'achat et de vente basée sur les signaux. La classe comprend la fonction d'initialisation " init " et la fonction "next".
Dans la fonction " init ", nous n'avons pas grand-chose à faire dans cet exemple particulier, mais il est de bonne pratique de l'inclure. La fonction "suivante" est l'endroit où la logique d'achat et de vente sera implémentée en fonction des signaux.
Pour exécuter le backtest, nous créons une instance de la classe backtest, en passant le data frame Google et la classe "SignalStrategy". Nous avons également défini la valeur du cache sur 10 000. Ensuite, nous exécutons le backtest et stockons les résultats dans la variable "stats". Enfin, nous imprimons les statistiques pour voir les performances de la stratégie.
L'exécution du code à ce stade ne donnera aucun échange car nous n'avons pas encore implémenté la logique d'achat et de vente. Cependant, nous pouvons accéder aux valeurs de signal en utilisant "self.data.signal" dans la fonction "next", qui nous donnera la dernière valeur de signal.
Pour mettre en œuvre la logique d'achat et de vente, nous vérifions la valeur actuelle du signal et la position actuelle. Si le signal est 1 (signal d'achat) et qu'il n'y a pas de position existante, nous exécutons un ordre d'achat en utilisant "self.buy". Si le signal est -1 (signal de vente) et qu'il existe une position longue, nous exécutons un ordre de vente en utilisant "self.sell".
Stratégie de signal externe :
Utilisation de pandas-ta pour les indicateurs personnalisés :
N'oubliez pas de remplacer les espaces réservés comme GOOG par vos données réelles et de personnaliser les stratégies en fonction de vos besoins spécifiques.
Arrêter les pertes dans Backtesting.py
Arrêter les pertes dans Backtesting.py
Dans cette vidéo, nous allons explorer le concept de stop loss dans la bibliothèque "backtesting.py". La vidéo couvrira trois exemples de complexité et de profondeur croissantes, offrant une compréhension complète des pertes d'arrêt dans "backtesting.py". Le présentateur suppose une certaine connaissance préalable de "backtesting.py" et recommande de regarder un cours gratuit sur YouTube pour les débutants avant de plonger dans ce sujet avancé.
Pour commencer, ouvrez un terminal et assurez-vous que "backtesting.py" est installé en exécutant la commande "pip install backtesting". Cela installera tous les packages nécessaires. Ensuite, créez un nouveau fichier Python, appelons-le "example.py", et importons les modules requis : "backtest" et "strategy" de "backtesting", et "googledale" de "backtesting.test". "googledale" est un ensemble de données de test fourni avec "backtesting.py".
Ensuite, définissez la classe de stratégie en créant une classe appelée "Strats" qui hérite de la classe "strategy". Implémentez les deux fonctions requises : « init » et « next ». À ce stade, nous sommes prêts à exécuter notre backtest. Initialisez un nouvel objet backtest, "bt", en utilisant la fonction "backtest". Transmettez les données "googledale" et la classe de stratégie que nous venons de définir. Fixez la valeur de rachat initiale à 10 000 $. Enfin, exécutez le backtest en utilisant la méthode "bt.run" et tracez les résultats en utilisant "bt.plot".
Initialement, la classe de stratégie n'effectue aucune action de trading. Pour illustrer un exemple simple de stop-loss, nous ajouterons une logique d'achat et de vente de base. Si nous avons un poste existant, nous ne prendrons aucune mesure. Cependant, si nous n'avons pas de position, nous passerons un ordre d'achat en utilisant la méthode "self.to_buy", en spécifiant la taille de la position (par exemple, 1 action). De plus, nous ajouterons un stop loss et un take profit. Le stop loss sera fixé à 10 unités en dessous du cours de clôture actuel, tandis que le take profit sera fixé à 20 unités au-dessus du cours de clôture actuel.
L'exécution du backtest générera un grand nombre de transactions. Dès qu'un trade est clôturé, un nouveau trade sera ouvert sur la barre suivante à moins que le stop loss ou le take profit ne soit déclenché. Il est important de comprendre comment "backtesting.py" gère les stop loss et les take profits. Dans les cas où le stop loss et le take profit sont déclenchés dans la même barre, la bibliothèque suppose que le stop loss est déclenché en premier. Ce comportement peut entraîner des résultats inattendus, en particulier lorsqu'il s'agit de données quotidiennes qui peuvent présenter des lacunes importantes.
Pour gérer plus efficacement les stop loss, on peut étendre la classe de stratégie et utiliser la "trailing strategy" fournie par "backtesting.py". Importez les modules nécessaires, y compris "crossover" et "trailing strategy" depuis "backtesting.lib". Dans la nouvelle classe de stratégie, héritez de "trailing strategy" au lieu de la classe de base "strategy". Redéfinissez la fonction « init » pour appeler la fonction « init » de la classe parente en utilisant « super ». Ensuite, utilisez la fonction « set_trailing_stop_loss » de la classe parente pour définir une valeur de stop loss suiveur.
Dans la section suivante de la vidéo, le présentateur explique plus en détail le fonctionnement de la "stratégie de suivi" et comment la personnaliser pour des besoins spécifiques. Cependant, dans cette section, l'accent est mis sur l'utilisation de la "stratégie de fin" dans notre code. En appelant la fonction " init " de la classe parente et en utilisant la fonction "set_trailing_stop_loss", nous pouvons tirer parti de la fonctionnalité trailing stop loss dans notre backtest.
Dans l'ensemble, la vidéo fournit une explication étape par étape de la mise en œuvre des stop loss dans "backtesting.py". Il couvre des exemples simples ainsi que des concepts plus avancés comme le suivre d'une valeur de 10, ce qui signifie que notre stop loss suivra le prix de 10 unités.
Maintenant que nous avons configuré notre fonction d'initialisation, passons à la fonction suivante. C'est là que l'essentiel de notre logique de trading sera implémenté. Dans la fonction suivante, nous appellerons d'abord la fonction suivante de la classe parent en utilisant super().next(). Cela garantit que la fonctionnalité de stop loss suiveur est exécutée avec l'autre logique de trading.
Ensuite, nous allons ajouter du code pour ajuster notre trailing stop loss. Nous utiliserons une instruction conditionnelle pour vérifier si nous avons une position ouverte (self.position n'est pas None). Si nous avons une position, nous mettrons à jour le trailing stop loss en utilisant la méthode update_trailing_sl fournie par la classe trailing_strategy. Cette méthode prend le prix actuel comme argument et met à jour le stop loss en conséquence.
Validation Backtest en Python (Fooled By Randomness)
Validation Backtest en Python (Fooled By Randomness)
Nous avons tous été dans cette situation où nous créons une stratégie de trading, la testons par la suite, et lorsque nous la mettons enfin en œuvre, elle ne fonctionne pas comme prévu. L'une des principales raisons de cette déception est le surajustement de la stratégie à un ensemble spécifique de données historiques utilisées dans le backtest. Dans cette vidéo, je vais démontrer une stratégie pour lutter contre le surajustement et m'assurer que vous ne vous fiez pas à des stratégies qui manquent de bases solides ou qui vous laissent berner par le hasard.
Plongeons-nous dans un exemple précis. J'ai effectué un backtest sur une stratégie simple basée sur le RSI en utilisant Bitcoin comme actif. La stratégie consiste à vendre lorsque le RSI est élevé et à acheter lorsque le RSI est bas. Les résultats du backtest ont montré un rendement modeste d'environ 3 %, malgré une baisse de 15 % de Bitcoin au cours de la période testée. À première vue, cela peut sembler une stratégie prometteuse pour les marchés baissiers.
Cependant, il est crucial d'examiner les performances de la stratégie sur différentes périodes pour déterminer si elle identifie systématiquement des opportunités rentables ou si elle a simplement eu de la chance avec les valeurs de paramètres choisies lors du backtest. Pour y parvenir, j'ai effectué plusieurs backtests de 30 jours, couvrant différentes périodes tout au long de l'année.
En traçant la distribution des rendements de ces backtests, nous pouvons avoir un aperçu de l'efficacité de la stratégie. Le graphique montre chaque fenêtre de 30 jours sous la forme d'un point, représentant les rendements obtenus au cours de cette période. La boîte à moustaches qui l'accompagne affiche le rendement médian, les quartiles, les valeurs maximales et minimales. En analysant le graphique, il devient évident que le rendement médian sur une période de 30 jours est de -8,5 %. De plus, la distribution des rendements semble être aléatoire, semblable aux résultats auxquels on pourrait s'attendre d'un ensemble de générateurs de nombres aléatoires entre -35 et 15. Ces résultats indiquent fortement que la stratégie n'est pas unique ou efficace au-delà des données historiques spécifiques utilisées dans le back-test.
Pour valider la stratégie et atténuer l'influence du surajustement, nous devons effectuer des backtests sur un plus large éventail de données. À cette fin, j'ai téléchargé plusieurs fichiers de données couvrant toute l'année, du début de 2022 à la fin de 2022. J'ai combiné ces fichiers dans un fichier CSV principal contenant des données de bougie d'une minute pour toute la période.
Dans le code de validation, j'ai fait quelques ajustements mineurs pour tenir compte de l'ensemble de données étendu. La stratégie de base reste la même, se concentrant sur la logique de trading basée sur le RSI. Cependant, j'ai introduit une boucle pour effectuer des backtests sur des fenêtres de 30 jours à travers les données. Chaque backtest calcule les retours, qui sont ensuite ajoutés à une liste pour une analyse plus approfondie.
En générant une boîte à moustaches à l'aide des rendements collectés, nous pouvons visualiser la distribution des performances de la stratégie sur différentes fenêtres de 30 jours. Ce graphique révèle la variabilité des rendements et fournit une image plus claire de la performance de la stratégie sur différents intervalles de temps. Dans cet exemple spécifique, le graphique indique des rendements principalement négatifs pour presque tous les mois, ce qui suggère que la stratégie manque de rentabilité constante.
Ces techniques de validation et de vérification des stratégies de trading peuvent être appliquées à n'importe quel cadre de backtesting de votre choix. Le code fourni utilise la bibliothèque backtesting.py, mais vous pouvez l'adapter à d'autres bibliothèques comme vectorbt ou backtrader. L'idée clé est de s'assurer que votre stratégie démontre sa robustesse sur diverses périodes de temps et n'est pas simplement le produit d'un surajustement à un ensemble spécifique de données historiques.
En suivant ces étapes de validation, vous pouvez réduire le risque de vous fier à des stratégies qui ne sont pas fondées sur la réalité ou d'être victime de résultats aléatoires. Il est essentiel d'aller au-delà des performances du backtest et de considérer l'efficacité de la stratégie dans différentes conditions de marché pour prendre des décisions éclairées lors de la mise en œuvre de stratégies de trading.
Après avoir analysé les résultats du backtest et la distribution des rendements sur différentes périodes, nous avons découvert que la performance de la stratégie était essentiellement aléatoire. Il n'a pas fourni de rentabilité constante en dehors de la période spécifique utilisée pour le backtesting. Cela indique que la stratégie souffrait de surajustement et manquait de robustesse.
Pour éviter de tomber dans le piège du surajustement et augmenter les chances de développer des stratégies de trading fiables, voici quelques recommandations :
Utilisez des données suffisantes et diversifiées : assurez-vous que votre backtest intègre une quantité importante de données historiques pour couvrir diverses conditions de marché. Cela permet de saisir un plus large éventail de scénarios et réduit la probabilité de surajustement à des conditions de marché spécifiques.
Validez sur plusieurs périodes : au lieu de vous fier uniquement à une seule période pour le backtesting, testez votre stratégie sur différentes périodes. Cela donne un aperçu de sa performance dans diverses conditions de marché et aide à déterminer si la stratégie a une rentabilité constante ou si les résultats observés étaient dus au hasard.
Mettre en œuvre des tests hors échantillon : réservez une partie de vos données historiques pour les tests hors échantillon. Après avoir effectué votre backtest principal sur le jeu de données initial, validez la stratégie sur les données réservées que le modèle n'a pas vues auparavant. Cela permet d'évaluer la capacité de la stratégie à s'adapter à des conditions de marché inédites et fournit une évaluation plus réaliste de ses performances.
Méfiez-vous de l'ajustement de la courbe : évitez une optimisation excessive ou un réglage des paramètres pour ajuster trop étroitement la stratégie aux données historiques. Les stratégies trop adaptées à des modèles de données spécifiques sont plus susceptibles d'échouer dans le commerce réel. Visez la robustesse plutôt que de rechercher des performances exceptionnelles uniquement sur des données historiques.
Envisagez l'analyse en aval : Au lieu de vous fier uniquement aux backtests statiques, envisagez d'utiliser l'analyse en aval. Cela implique de ré-optimiser et de retester périodiquement votre stratégie à mesure que de nouvelles données deviennent disponibles. Il vous permet d'adapter et d'affiner votre stratégie en continu, en améliorant ses performances dans des conditions de marché changeantes.
Utilisez des tests de signification statistique : appliquez des tests statistiques pour évaluer la signification des performances de votre stratégie. Cela aide à déterminer si les résultats observés sont statistiquement significatifs ou simplement dus au hasard. Les tests statistiques courants utilisés dans le backtesting comprennent les tests t, les tests bootstrap et les simulations de Monte Carlo.
En suivant ces directives, vous pouvez réduire le risque de développer des stratégies trop adaptées aux données historiques et augmenter la probabilité de créer des approches de trading robustes et fiables.
N'oubliez pas que l'objectif est de développer des stratégies de trading qui démontrent une rentabilité constante dans différentes conditions de marché, plutôt que des stratégies qui se contentent de bien performer sur des données historiques.
Une introduction accélérée à Python pour les ingénieurs en apprentissage automatique
Une introduction accélérée à Python pour les ingénieurs en apprentissage automatique
L'instructeur du cours commence par présenter le concept de modélisation prédictive et son importance dans l'industrie. La modélisation prédictive se concentre sur le développement de modèles capables de faire des prédictions précises, même s'ils ne fournissent pas d'explication sur la raison pour laquelle ces prédictions sont faites. L'instructeur souligne que le cours se concentrera spécifiquement sur les données tabulaires, telles que les feuilles de calcul ou les bases de données. L'objectif est de guider les étudiants qui ne sont plus des développeurs intéressés par l'apprentissage automatique en Python pour devenir compétents dans l'utilisation de nouveaux ensembles de données, le développement de modèles prédictifs de bout en bout et l'utilisation de Python et de la bibliothèque SCIPy pour les tâches d'apprentissage automatique.
Pour commencer, l'instructeur propose un cours accéléré sur la syntaxe Python. Ils couvrent des concepts fondamentaux tels que les variables et les affectations, clarifiant la distinction entre le signe "égal" utilisé pour l'affectation et le signe "double égal" utilisé pour les comparaisons d'égalité. L'instructeur montre comment utiliser Jupyter Notebook pour le codage Python et fournit des conseils de navigation, tels que la création d'un nouveau bloc-notes, l'utilisation d'alias pour les bibliothèques, l'exécution de cellules et la copie ou le déplacement de cellules. Ils expliquent également la fonction d'enregistrement automatique et l'enregistrement manuel des blocs-notes. Enfin, la vidéo aborde brièvement l'arrêt de l'exécution du noyau.
Ensuite, l'instructeur explique comment utiliser la barre d'outils dans Jupyter Notebook pour la navigation du moteur Python et comment annoter des blocs-notes à l'aide de Markdown. La vidéo couvre les principales instructions de contrôle de flux, y compris les conditions if-then-else, les boucles for et les boucles while. Ces instructions permettent la prise de décision et la répétition dans le code Python. L'instructeur présente ensuite trois structures de données cruciales pour l'apprentissage automatique : les tuples, les listes et les dictionnaires. Ces structures de données offrent des moyens efficaces de stocker et de manipuler des données. De plus, la vidéo comprend un cours accéléré sur NumPy, une bibliothèque qui permet des opérations numériques en Python. Il couvre la création de tableaux, l'accès aux données et l'exécution d'opérations arithmétiques avec des tableaux.
La vidéo aborde ensuite deux bibliothèques essentielles, Matplotlib et Pandas, qui sont couramment utilisées dans l'apprentissage automatique pour l'analyse et la visualisation des données. Matplotlib permet aux utilisateurs de créer divers tracés et graphiques, facilitant la visualisation des données. Pandas, d'autre part, fournit des structures de données et des fonctions pour la manipulation et l'analyse des données, en particulier par le biais de structures de séries et de trames de données. La vidéo met en évidence l'importance de la fonction read_csv de Pandas pour le chargement de fichiers CSV, le format le plus courant dans les applications d'apprentissage automatique. Il met également l'accent sur l'utilité des fonctions Pandas pour résumer et tracer les données afin d'obtenir des informations et de préparer les données pour les tâches d'apprentissage automatique. Les statistiques descriptives en Python sont mentionnées comme un outil crucial pour comprendre les caractéristiques et la nature des données.
La vidéo plonge dans des techniques de visualisation de données spécifiques qui peuvent faciliter l'analyse des données avant d'appliquer des techniques d'apprentissage automatique. Les histogrammes, les diagrammes de densité et les diagrammes en boîte sont présentés comme des moyens d'observer la distribution des attributs et d'identifier les valeurs aberrantes potentielles. Les matrices de corrélation et les matrices de nuages de points sont présentées comme des méthodes pour identifier les relations entre les paires d'attributs. La vidéo souligne l'importance de la mise à l'échelle, de la standardisation, de la normalisation et de la binarisation des données en tant qu'étapes de prétraitement nécessaires pour préparer les données pour les algorithmes d'apprentissage automatique. La méthode d'ajustement et de transformation est expliquée comme une approche courante pour le prétraitement des données.
Le prochain sujet abordé concerne les techniques de prétraitement des données dans l'apprentissage automatique. La vidéo couvre la normalisation et la standardisation comme deux techniques importantes. La normalisation implique la remise à l'échelle des attributs pour qu'ils aient la même échelle, tandis que la normalisation implique la transformation des attributs pour avoir une moyenne de zéro et un écart type de un. La binarisation, qui limite les données pour créer des attributs binaires ou des valeurs nettes, est également expliquée. L'importance de la sélection des fonctionnalités est soulignée, car des fonctionnalités non pertinentes ou partiellement non pertinentes peuvent avoir un impact négatif sur les performances du modèle. La vidéo présente la sélection univariée comme une approche statistique de la sélection des caractéristiques et met en évidence l'utilisation de méthodes récursives d'élimination des caractéristiques et d'importance des caractéristiques qui utilisent des ensembles d'arbres de décision comme une forêt aléatoire ou des arbres supplémentaires. L'analyse en composantes principales (ACP) est également discutée en tant que technique de réduction des données qui peut compresser l'ensemble de données en un plus petit nombre de dimensions à l'aide de l'algèbre linéaire.
La vidéo souligne l'importance des méthodes de rééchantillonnage pour évaluer les performances des algorithmes d'apprentissage automatique sur des données invisibles. Il met en garde contre l'évaluation des algorithmes sur le même ensemble de données utilisé pour la formation, car cela peut conduire à un surajustement et à une mauvaise généralisation à de nouvelles données. Des techniques telles que les ensembles de fractionnement de test de train, la validation croisée k-fold, la validation croisée sans un et les fractionnements de test aléatoires répétés sont expliquées comme des moyens d'obtenir des estimations fiables des performances de l'algorithme. La vidéo se termine par une discussion sur diverses mesures de performance pour les algorithmes d'apprentissage automatique, telles que la précision de la classification, la perte logarithmique, l'aire sous la courbe, la matrice de confusion et le rapport de classification.
La vidéo se penche sur les mesures de performance utilisées pour évaluer les prédictions faites par les modèles d'apprentissage automatique. Il couvre la précision de la classification, la perte de log (pour évaluer les probabilités), l'aire sous la courbe des caractéristiques de fonctionnement du récepteur (ROC) (pour les problèmes de classification binaire), la matrice de confusion (pour évaluer la précision du modèle avec plusieurs classes) et le rapport de classification (qui fournit une précision , rappel, score F1 et support pour chaque classe). De plus, la vidéo explique trois métriques de régression courantes : l'erreur absolue moyenne, l'erreur quadratique moyenne et le R au carré. Des exemples pratiques sont présentés pour illustrer comment calculer ces métriques à l'aide de Python.
L'orateur introduit le concept de vérification ponctuelle pour déterminer quels algorithmes d'apprentissage automatique fonctionnent bien pour un problème spécifique. La vérification ponctuelle consiste à évaluer plusieurs algorithmes et à comparer leurs performances. La vidéo montre la vérification ponctuelle de six modèles d'apprentissage automatique différents, y compris des algorithmes linéaires et non linéaires, en utilisant Python avec la bibliothèque scikit-learn. Le conférencier souligne que les résultats peuvent varier en raison de la nature stochastique des modèles. La section se termine par une introduction aux modèles d'apprentissage automatique de régression, préparant les téléspectateurs pour la prochaine section sur la vérification ponctuelle de ces modèles.
Ensuite, l'orateur présente des modèles d'apprentissage automatique linéaires et non linéaires en utilisant l'ensemble de données sur le prix des maisons de Boston comme exemple. Un harnais de test avec validation croisée 10 fois est utilisé pour démontrer comment vérifier chaque modèle, et l'erreur quadratique moyenne est utilisée comme indicateur de performance (inversée en raison d'une bizarrerie dans la fonction de score croisé). Le modèle de régression linéaire, en supposant une distribution gaussienne pour les variables d'entrée et leur pertinence par rapport à la variable de sortie, est discuté. La régression Ridge, une modification de la régression linéaire qui minimise la complexité du modèle, est également expliquée. L'orateur souligne l'importance de comprendre le pipeline ou le processus plutôt que de se laisser entraîner dans la mise en œuvre spécifique du code à ce stade.
La vidéo explore le processus de compréhension et de visualisation des variables d'entrée pour un problème d'apprentissage automatique. Il suggère d'utiliser des diagrammes univariés tels que des diagrammes en boîte et moustaches et des histogrammes pour comprendre la distribution des variables d'entrée. Pour l'analyse multivariée, les diagrammes de dispersion peuvent aider à identifier les relations structurelles entre les variables d'entrée et révéler des corrélations élevées entre des paires d'attributs spécifiques. La vidéo aborde également le processus d'évaluation, à l'aide d'un harnais de test avec validation croisée 10 fois pour évaluer les performances du modèle. L'importance de créer un ensemble de données de validation pour évaluer indépendamment la précision du meilleur modèle est soulignée. Six modèles d'apprentissage automatique différents sont évalués, et le plus précis est sélectionné pour faire des prédictions. Le rapport de classification, la matrice de confusion et l'estimation de la précision sont utilisés pour évaluer les prédictions. Enfin, la vidéo aborde la régression de régularisation, mettant en évidence la construction de modèles Lasso et Elastic Net pour réduire la complexité des modèles de régression.
La vidéo présente un problème de classification binaire dans l'apprentissage automatique, visant à prédire le métal à partir de la roche à l'aide de l'ensemble de données Sonar Mines versus Rocks. Le jeu de données contient 208 instances avec 61 attributs, y compris l'attribut de classe. Des statistiques descriptives sont analysées, indiquant que bien que les données soient dans la même fourchette, des moyens différents suggèrent que la normalisation des données pourrait être bénéfique. Les visualisations de données unimodales et multimodales, telles que les histogrammes, les diagrammes de densité et les visualisations de corrélation, sont explorées pour mieux comprendre les données. Un ensemble de données de validation est créé et une base de référence pour les performances du modèle est établie en testant divers modèles, y compris la régression linéaire, la régression logistique, l'analyse discriminante linéaire, les arbres de régression de classification, les machines à vecteurs de support (SVM), Bayes naïf et les k-plus proches voisins ( KNN). La précision de chaque algorithme est calculée à l'aide d'une validation croisée de 10 fois et comparée.
Dans le segment suivant, la vidéo explique comment évaluer différents algorithmes d'apprentissage automatique à l'aide de données et de réglages standardisés. La normalisation consiste à transformer les données, de sorte que chaque attribut a une moyenne de 0 et un écart type de 1, ce qui peut améliorer les performances de certains modèles. Pour éviter les fuites de données pendant le processus de transformation, un pipeline qui normalise les données et construit le modèle pour chaque pli dans le harnais de test de validation croisée est recommandé. La vidéo montre des techniques de réglage pour les k-plus proches voisins (KNN) et les machines à vecteurs de support (SVM) à l'aide d'une recherche de grille avec validation croisée de 10 fois sur la copie standardisée de l'ensemble de données de formation. Les configurations optimales pour KNN et SVM sont identifiées et la précision des modèles est évaluée. Enfin, la vidéo traite brièvement de KNN, de la régression par arbre de décision et de SVM en tant que modèles d'apprentissage automatique non linéaires.
Statistiques appliquées pour les ingénieurs en apprentissage automatique
Statistiques appliquées pour les ingénieurs en apprentissage automatique
L'instructeur de la vidéo présente le domaine des statistiques et souligne son importance dans le travail avec des problèmes de modélisation prédictive dans l'apprentissage automatique. Ils expliquent que les statistiques offrent une gamme de techniques, allant des simples statistiques récapitulatives aux tests d'hypothèses et aux statistiques d'estimation. Le cours est conçu pour fournir une base étape par étape dans les méthodes statistiques, avec des exemples pratiques en Python. Il couvre six aspects fondamentaux des statistiques pour l'apprentissage automatique et se concentre sur les applications du monde réel, ce qui le rend adapté aux ingénieurs en apprentissage automatique.
L'instructeur met l'accent sur la relation étroite entre l'apprentissage automatique et les statistiques et suggère que les programmeurs peuvent bénéficier de l'amélioration de leurs compétences statistiques grâce à ce cours. Ils classent le domaine des statistiques en deux catégories : les statistiques descriptives et les statistiques inférentielles. Les statistiques descriptives impliquent de résumer et de décrire des données à l'aide de mesures telles que des moyennes et des représentations graphiques. Les statistiques inférentielles, en revanche, sont utilisées pour faire des inférences sur une population plus large sur la base de données d'échantillon.
L'importance d'un traitement approprié des données est également soulignée, y compris la gestion de la perte de données, de la corruption et des erreurs. La vidéo se penche ensuite sur les différentes étapes impliquées dans la préparation des données pour les modèles d'apprentissage automatique. Cela comprend le nettoyage des données, la sélection des données, l'échantillonnage des données et la transformation des données à l'aide de méthodes statistiques telles que la standardisation et la normalisation. L'évaluation des données est également soulignée et la vidéo traite de la conception expérimentale, du rééchantillonnage des données et de la sélection de modèles pour estimer la compétence d'un modèle. Pour prédire de nouvelles données, la vidéo recommande d'utiliser des statistiques d'estimation.
La vidéo explique les différentes échelles de mesure utilisées en statistique, à savoir les échelles nominale, ordinale, d'intervalle et de rapport. Il aborde les techniques statistiques applicables à chaque échelle et comment elles peuvent être mises en œuvre dans l'apprentissage automatique. L'importance de comprendre et de signaler l'incertitude dans la modélisation est soulignée, en particulier lorsque l'on travaille avec des ensembles d'échantillons. La vidéo se concentre ensuite sur la distribution normale, qui est couramment observée dans divers ensembles de données. Il montre comment générer des exemples de données et évaluer visuellement leur adéquation à une distribution gaussienne à l'aide d'un histogramme. Bien que la plupart des ensembles de données n'aient pas une distribution gaussienne parfaite, ils présentent souvent des propriétés de type gaussienne.
L'importance de sélectionner une méthode granulaire de fractionnement des données pour exposer la distribution gaussienne sous-jacente est mise en évidence. Les mesures de la tendance centrale, telles que la moyenne et la médiane, sont explorées, ainsi que la variance et l'écart type en tant que mesures de la propagation de la distribution. Le caractère aléatoire est considéré comme un outil essentiel de l'apprentissage automatique, aidant les algorithmes à devenir plus robustes et précis. Diverses sources d'aléa, y compris les erreurs de données et le bruit, sont expliquées.
La vidéo explique que les algorithmes d'apprentissage automatique exploitent souvent le caractère aléatoire pour obtenir de meilleures performances et générer des modèles plus optimaux. Le caractère aléatoire permet aux algorithmes d'explorer différentes possibilités et de trouver de meilleurs mappages de données. Les sources contrôlables et incontrôlables d'aléa sont discutées, et l'utilisation de la fonction de départ pour rendre l'aléatoire cohérent dans un modèle est expliquée. La vidéo fournit un exemple utilisant le module aléatoire Python pour générer des nombres aléatoires et met en évidence la différence entre le générateur de nombres pseudo-aléatoires de la bibliothèque numpy et le générateur de nombres pseudo-aléatoires de la bibliothèque standard. Deux cas pour savoir quand amorcer le générateur de nombres aléatoires sont également discutés, à savoir lors de la préparation des données et des fractionnements de données.
L'accent est mis sur le fractionnement constant des données et l'utilisation de générateurs de nombres pseudo-aléatoires lors de l'évaluation d'un algorithme. La vidéo recommande d'évaluer le modèle d'une manière qui intègre l'incertitude mesurée et les performances de l'algorithme. L'évaluation d'un algorithme sur plusieurs fractionnements de données donne un aperçu de la façon dont ses performances varient avec différentes données d'entraînement et de test. L'évaluation d'un algorithme plusieurs fois sur les mêmes fractionnements de données aide à comprendre comment ses performances varient d'elles-mêmes. La vidéo présente également la loi des grands nombres et le théorème central limite, soulignant qu'avoir plus de données améliore les performances du modèle et qu'à mesure que la taille de l'échantillon augmente, la distribution de la moyenne se rapproche d'une distribution gaussienne.
La vidéo illustre le théorème central limite à l'aide de lancers de dés et de code, montrant comment les moyennes d'échantillon se rapprochent d'une distribution gaussienne à mesure que la taille de l'échantillon augmente.
La vidéo souligne l'importance d'évaluer les modèles d'apprentissage automatique et de comprendre l'incertitude impliquée dans leurs prédictions. Il introduit des mesures d'évaluation telles que l'exactitude, la précision, le rappel et le score F1, qui sont couramment utilisés pour évaluer les performances des modèles de classification. La vidéo explique que la précision mesure l'exactitude globale des prédictions, la précision mesure la proportion de véritables prédictions positives sur toutes les prédictions positives, le rappel mesure la proportion de véritables prédictions positives sur toutes les instances positives réelles, et le score F1 combine la précision et le rappel dans une seule métrique. Il aborde également le concept de matrice de confusion, qui fournit une vue plus détaillée des performances d'un modèle de classification en indiquant le nombre de prédictions vraies positives, vraies négatives, fausses positives et fausses négatives.
L'orateur montre comment calculer ces métriques d'évaluation à l'aide de la bibliothèque scikit-learn de Python. Il montre comment importer les modules nécessaires, diviser les données en ensembles d'entraînement et de test, former un modèle de classification, faire des prédictions sur l'ensemble de test et évaluer les performances du modèle en utilisant l'exactitude, la précision, le rappel et le score F1. La vidéo souligne l'importance d'évaluer les modèles sur des données inédites pour garantir leurs capacités de généralisation.
En outre, la vidéo présente le concept des courbes de caractéristique de fonctionnement du récepteur (ROC) et de l'aire sous la courbe (AUC) comme mesures d'évaluation pour les modèles de classification binaires. Les courbes ROC tracent le taux de vrais positifs par rapport au taux de faux positifs à divers seuils de classification, fournissant une représentation visuelle des performances du modèle sur différentes valeurs de seuil. L'AUC représente l'aire sous la courbe ROC et fournit une mesure unique pour comparer les performances de différents modèles. La vidéo explique comment tracer une courbe ROC et calculer l'AUC à l'aide de la bibliothèque scikit-learn de Python.
Le concept de surajustement est discuté comme un problème courant dans l'apprentissage automatique, où un modèle fonctionne bien sur les données de formation mais ne parvient pas à se généraliser à de nouvelles données invisibles. La vidéo explique que le surajustement se produit lorsqu'un modèle devient trop complexe et apprend des modèles spécifiques aux données de formation qui ne tiennent pas dans la population générale. La vidéo montre comment le surajustement peut être visualisé en comparant les performances d'entraînement et de test d'un modèle. Cela explique qu'un modèle de surajustement aura une faible erreur d'apprentissage mais une erreur de test élevée, ce qui indique une mauvaise généralisation. La vidéo suggère des techniques de régularisation telles que la régression ridge et la régression Lasso comme moyens d'atténuer le surajustement en ajoutant un terme de pénalité à la fonction objectif du modèle.
Le concept de validation croisée est présenté comme une technique pour évaluer les performances et la généralisation des modèles d'apprentissage automatique. La vidéo explique que la validation croisée consiste à diviser les données en plusieurs sous-ensembles, à former le modèle sur une partie des données et à évaluer ses performances sur la partie restante. Ce processus est répété plusieurs fois, avec différents sous-ensembles utilisés pour la formation et les tests, et les résultats sont moyennés pour fournir une estimation des performances du modèle. La vidéo montre comment effectuer une validation croisée à l'aide de la bibliothèque scikit-learn de Python, en particulier la méthode de validation croisée K-fold.
Ensuite, la vidéo aborde le concept de sélection de fonctionnalités et son importance dans l'apprentissage automatique. Il explique que la sélection des caractéristiques consiste à identifier les caractéristiques ou les variables les plus pertinentes qui contribuent aux performances du modèle. La vidéo souligne l'importance de sélectionner des caractéristiques informatives pour améliorer la précision du modèle, réduire le surajustement et améliorer l'interprétabilité. Il présente différentes techniques de sélection de caractéristiques, telles que la sélection univariée, l'élimination récursive des caractéristiques et les scores d'importance des caractéristiques. La vidéo montre comment implémenter la sélection de fonctionnalités à l'aide de la bibliothèque scikit-learn de Python.
Le concept de réduction de la dimensionnalité est également discuté en tant que technique pour lutter contre la malédiction de la dimensionnalité dans l'apprentissage automatique. La vidéo explique que la réduction de la dimensionnalité implique de réduire le nombre de caractéristiques ou de variables dans un ensemble de données tout en préservant la plupart des informations pertinentes. Il présente l'analyse en composantes principales (ACP) comme technique de réduction de la dimensionnalité couramment utilisée. L'ACP vise à transformer les données dans un espace de dimension inférieure en identifiant les directions de variance maximale dans les données. La vidéo explique que l'ACP crée de nouvelles fonctionnalités, appelées composants principaux, qui sont des combinaisons linéaires des fonctionnalités d'origine. Ces composants principaux capturent les informations les plus importantes dans les données et peuvent être utilisés comme entrées pour les modèles d'apprentissage automatique.
La vidéo montre comment effectuer une PCA à l'aide de la bibliothèque scikit-learn de Python. Il montre comment importer les modules nécessaires, normaliser les données, initialiser un objet PCA, adapter le modèle PCA aux données et transformer les données dans l'espace de dimension inférieure. La vidéo explique également comment déterminer le nombre optimal de composantes principales à retenir en fonction du ratio de variance expliqué.
Le concept d'apprentissage d'ensemble est présenté comme une technique pour améliorer les performances des modèles d'apprentissage automatique en combinant plusieurs modèles individuels. La vidéo explique que l'apprentissage d'ensemble tire parti de la sagesse des foules, où chaque modèle individuel apporte ses propres prédictions, et la prédiction finale est déterminée sur la base d'un mécanisme de vote ou de moyenne. La vidéo traite de deux méthodes d'apprentissage d'ensemble populaires : le bagging et le boosting. Le bagging implique la formation de plusieurs modèles sur différents sous-ensembles de données et l'agrégation de leurs prédictions, tout en se concentrant sur les modèles de formation de manière séquentielle, chaque modèle accordant plus d'importance aux instances qui ont été mal classées par les modèles précédents.
La vidéo montre comment implémenter l'apprentissage d'ensemble à l'aide de la bibliothèque scikit-learn de Python. Il montre comment importer les modules nécessaires pour le bagging et le boosting, initialiser les modèles d'ensemble, les adapter aux données et faire des prédictions à l'aide des modèles d'ensemble. La vidéo souligne que l'apprentissage d'ensemble peut souvent améliorer les performances globales et la robustesse des modèles d'apprentissage automatique.
Enfin, la vidéo aborde brièvement des sujets avancés en apprentissage automatique, tels que l'apprentissage en profondeur et le traitement du langage naturel (TAL). Il mentionne que l'apprentissage en profondeur implique la formation de réseaux de neurones profonds à plusieurs couches pour apprendre des modèles complexes de données. La PNL se concentre sur le développement de modèles et de techniques pour comprendre et traiter le langage humain, permettant des applications telles que la classification de texte, l'analyse des sentiments et la traduction automatique. La vidéo se termine en soulignant que l'apprentissage automatique est un domaine vaste et en évolution rapide avec de nombreuses applications et opportunités d'exploration et d'apprentissage supplémentaires.
La vidéo fournit un aperçu complet des concepts et techniques essentiels de l'apprentissage automatique, y compris l'évaluation des modèles, le surajustement, la régularisation, la validation croisée, la sélection des caractéristiques, la réduction de la dimensionnalité, l'apprentissage d'ensemble et une introduction à l'apprentissage en profondeur et à la PNL. Il présente des implémentations pratiques à l'aide de Python et de la bibliothèque scikit-learn, ce qui en fait une ressource précieuse pour les débutants et ceux qui cherchent à améliorer leur compréhension de l'apprentissage automatique.
Algèbre linéaire appliquée pour les ingénieurs en apprentissage automatique
Algèbre linéaire appliquée pour les ingénieurs en apprentissage automatique
La vidéo souligne l'importance de l'apprentissage de l'algèbre linéaire pour les ingénieurs en apprentissage automatique, car elle constitue un élément fondamental pour comprendre le calcul et les statistiques, qui sont essentiels à l'apprentissage automatique. Avoir une compréhension plus approfondie de l'algèbre linéaire offre aux praticiens une meilleure intuition du fonctionnement des méthodes d'apprentissage automatique, leur permettant de personnaliser les algorithmes et d'en développer de nouveaux.
Le cours adopte une approche descendante pour enseigner les bases de l'algèbre linéaire, en utilisant des exemples concrets et des structures de données pour démontrer les opérations sur les matrices et les vecteurs. L'algèbre linéaire est décrite comme la mathématique des matrices et des vecteurs, fournissant un langage pour la manipulation des données et permettant la création de nouvelles colonnes ou tableaux de nombres par le biais d'opérations sur ces structures de données. Initialement développée à la fin des années 1800 pour résoudre des systèmes d'équations linéaires, l'algèbre linéaire est devenue une condition préalable essentielle à la compréhension de l'apprentissage automatique.
Le conférencier introduit le concept d'algèbre linéaire numérique, qui implique l'application de l'algèbre linéaire dans les ordinateurs. Cela comprend la mise en œuvre d'opérations d'algèbre linéaire et la résolution des problèmes qui surviennent lorsque l'on travaille avec une précision limitée en virgule flottante dans les ordinateurs numériques. L'algèbre linéaire numérique joue un rôle crucial dans l'apprentissage automatique, en particulier dans les algorithmes d'apprentissage en profondeur qui s'appuient fortement sur les unités de traitement graphique (GPU) pour effectuer efficacement des calculs d'algèbre linéaire. Diverses bibliothèques d'algèbre linéaire numérique open source, avec des bibliothèques basées sur Fortran comme base, sont couramment utilisées pour calculer des opérations d'algèbre linéaire, souvent en conjonction avec des langages de programmation comme Python.
L'importance de l'algèbre linéaire dans les statistiques est mise en évidence, en particulier dans l'analyse statistique multivariée, l'analyse en composantes principales et la résolution de problèmes de régression linéaire. La vidéo mentionne également le large éventail d'applications de l'algèbre linéaire dans des domaines tels que le traitement du signal, l'infographie et même la physique, avec des exemples comme la théorie de la relativité d'Albert Einstein utilisant des tenseurs et le calcul tensoriel, un type d'algèbre linéaire.
La vidéo explore plus en détail l'application pratique de l'algèbre linéaire dans les tâches d'apprentissage automatique. Il introduit le concept d'utilisation d'opérations d'algèbre linéaire, telles que le recadrage, la mise à l'échelle et le cisaillement, pour manipuler des images, démontrant comment la notation et les opérations d'algèbre linéaire peuvent être utilisées dans ce contexte. De plus, la vidéo explique la technique de codage populaire appelée codage à chaud pour les variables catégorielles. La principale structure de données utilisée dans l'apprentissage automatique, les tableaux à N dimensions ou tableaux ND, est présentée, avec la bibliothèque NumPy en Python présentée comme un outil puissant pour créer et manipuler ces tableaux. La vidéo couvre des fonctions importantes, telles que la pile en V et l'empilement horizontal, qui permettent la création de nouveaux tableaux à partir de tableaux existants.
La manipulation et l'accès aux données dans les tableaux NumPy, couramment utilisés pour représenter les données d'apprentissage automatique, sont expliqués. La vidéo montre comment convertir des listes unidimensionnelles en tableaux à l'aide de la fonction de tableau et créer des tableaux de données bidimensionnels à l'aide de listes de listes. Il couvre également les opérations d'indexation et de découpage dans les tableaux NumPy, y compris l'utilisation de l'opérateur deux-points pour le découpage et l'indexation négative. L'importance du découpage dans la spécification des variables d'entrée et de sortie dans l'apprentissage automatique est mise en évidence.
Les techniques de travail avec des ensembles de données multidimensionnels dans l'apprentissage automatique sont abordées dans la vidéo. Il commence par un découpage unidimensionnel et progresse vers un découpage bidimensionnel, ainsi que par la séparation des données en valeurs d'entrée et de sortie pour la formation et les tests. Le remodelage de tableaux est couvert, expliquant comment remodeler des tableaux unidimensionnels en tableaux bidimensionnels avec une colonne et transformer des données bidimensionnelles en tableaux tridimensionnels pour les algorithmes qui nécessitent plusieurs échantillons d'un ou plusieurs pas de temps et caractéristiques. Le concept de diffusion de tableaux est introduit, ce qui permet d'utiliser des tableaux de tailles différentes dans des opérations arithmétiques, permettant ainsi de traiter efficacement des ensembles de données de tailles variables.
La vidéo aborde également les limites de l'arithmétique de tableau dans NumPy, en particulier le fait que les opérations arithmétiques ne peuvent être effectuées que sur des tableaux de mêmes dimensions et de même taille. Cependant, cette limitation est surmontée par la fonction de diffusion intégrée de NumPy, qui réplique le plus petit tableau le long de la dernière dimension non concordante, permettant l'arithmétique entre des tableaux de formes et de tailles différentes. La vidéo fournit trois exemples de diffusion, y compris des tableaux scalaires et unidimensionnels, scalaire dans un tableau bidimensionnel et tableau unidimensionnel dans un tableau bidimensionnel. Il est à noter que la diffusion suit une règle stricte, indiquant que l'arithmétique ne peut être effectuée que lorsque la forme de chaque dimension dans les tableaux est égale ou que l'un d'eux a une taille de dimension de un.
Ensuite, l'orateur introduit le concept de vecteurs, qui sont des tuples d'une ou plusieurs valeurs appelées scalaires. Les vecteurs sont souvent représentés à l'aide de caractères minuscules tels que "v" et peuvent être considérés comme des points ou des coordonnées dans un espace à n dimensions, où "n" représente le nombre de dimensions. La création de vecteurs sous forme de tableaux NumPy en Python est expliquée. La vidéo couvre également les opérations arithmétiques vectorielles, telles que l'addition et la soustraction de vecteurs, qui sont effectuées élément par élément pour des vecteurs de longueur égale, ce qui donne un nouveau vecteur de même longueur. De plus, l'orateur explique comment les vecteurs peuvent être multipliés par des scalaires pour mettre à l'échelle leur magnitude et montre comment effectuer ces opérations à l'aide de tableaux NumPy en Python. Le produit scalaire de deux vecteurs est également discuté, ce qui donne un scalaire et peut être utilisé pour calculer la somme pondérée d'un vecteur.
L'accent est ensuite mis sur les normes vectorielles et leur importance dans l'apprentissage automatique. Les normes vectorielles font référence à la taille ou à la longueur d'un vecteur et sont calculées à l'aide d'une mesure qui résume la distance du vecteur à l'origine de l'espace vectoriel. Il est souligné que les normes vectorielles sont toujours positives, sauf pour un vecteur de toutes les valeurs nulles. La vidéo présente quatre calculs de normes vectorielles courants utilisés dans l'apprentissage automatique. Il commence par la norme vectorielle L1, suivie de la norme L2 (norme euclidienne) et de la norme max. La section définit également les matrices et explique comment les manipuler en Python. L'arithmétique matricielle, y compris la multiplication matrice-matrice (produit scalaire), la multiplication matrice-vecteur et la multiplication scalaire, est discutée. Une matrice est décrite comme un tableau bidimensionnel de scalaires avec une ou plusieurs colonnes et une ou plusieurs lignes, généralement représentées par des lettres majuscules telles que "A".
Ensuite, le concept d'opérations matricielles pour l'apprentissage automatique est introduit. Cela inclut la multiplication matricielle, la division matricielle et la multiplication scalaire matricielle. La multiplication matricielle, également connue sous le nom de produit scalaire matriciel, nécessite que le nombre de colonnes dans la première matrice soit égal au nombre de lignes dans la seconde matrice. La vidéo mentionne que la fonction point de NumPy peut être utilisée pour implémenter cette opération. Le concept de transposition de matrice est également expliqué, où une nouvelle matrice est créée en inversant le nombre de lignes et de colonnes de la matrice d'origine. Enfin, le processus d'inversion de matrice est discuté, ce qui implique de trouver une autre matrice qui, lorsqu'elle est multipliée par la matrice d'origine, donne une matrice d'identité.
Poursuivant la discussion sur l'inversion de matrice, la vidéo explore davantage ce concept. L'inversion d'une matrice est indiquée par un exposant négatif 1 à côté de la matrice. La vidéo explique que l'inversion de matrice implique de trouver des méthodes numériques efficaces. L'opération de trace d'une matrice carrée est introduite, qui calcule la somme des éléments diagonaux et peut être calculée à l'aide de la fonction de trace dans NumPy. Le déterminant d'une matrice carrée est défini comme une représentation scalaire du volume de la matrice et peut également être calculé à l'aide de la fonction det dans NumPy. Le rang d'une matrice est brièvement mentionné, qui estime le nombre de lignes ou de colonnes linéairement indépendantes dans la matrice et est généralement calculé à l'aide de la décomposition en valeurs singulières. Enfin, le concept de matrices creuses est expliqué, soulignant qu'elles contiennent principalement des valeurs nulles et peuvent être coûteuses en calculs à représenter et à utiliser.
La vidéo se penche ensuite sur les matrices clairsemées, qui sont des matrices principalement composées de valeurs nulles et diffèrent des matrices denses qui ont pour la plupart des valeurs non nulles. La parcimonie est quantifiée en calculant le score de parcimonie, qui est le nombre de valeurs nulles divisé par le nombre total d'éléments dans la matrice. La vidéo met l'accent sur deux problèmes principaux associés à la parcimonie : la complexité spatiale et la complexité temporelle. Il est à noter que représenter et travailler avec des matrices creuses peut être coûteux en calcul.
Pour relever ces défis, la vidéo mentionne que Scipy fournit des outils pour créer et manipuler des matrices creuses. De plus, il souligne que de nombreuses fonctions d'algèbre linéaire dans NumPy et Scipy peuvent fonctionner sur des matrices creuses, permettant des calculs et des opérations efficaces sur des données clairsemées.
Les matrices creuses sont couramment utilisées dans l'apprentissage automatique appliqué pour l'observation des données et la préparation des données. Leur rareté permet un stockage et un traitement plus efficaces de grands ensembles de données avec un nombre important de valeurs nulles. En tirant parti de la structure parcimonieuse, les algorithmes d'apprentissage automatique peuvent bénéficier d'une utilisation réduite de la mémoire et de calculs plus rapides.
Ensuite, la vidéo aborde différents types de matrices couramment utilisées en algèbre linéaire, en particulier celles pertinentes pour l'apprentissage automatique. Des matrices carrées sont introduites, où le nombre de lignes est égal au nombre de colonnes. Les matrices rectangulaires, qui ont différents nombres de lignes et de colonnes, sont également mentionnées. La vidéo explique la diagonale principale d'une matrice carrée, qui se compose d'éléments avec les mêmes indices de ligne et de colonne. L'ordre d'une matrice carrée, défini comme le nombre de lignes ou de colonnes, est également couvert.
De plus, la vidéo présente des matrices symétriques, qui sont des matrices carrées égales à leur transposée. Les matrices triangulaires, y compris les matrices triangulaires supérieure et inférieure, sont expliquées. Les matrices diagonales, où tous les éléments non diagonaux sont nuls, sont également discutées. Les matrices d'identité, qui sont des matrices carrées avec des uns sur la diagonale principale et des zéros ailleurs, sont expliquées dans le contexte de leur rôle d'identités multiplicatives. Des matrices orthogonales, formées lorsque deux vecteurs ont un produit scalaire égal à zéro, sont également introduites.
La vidéo se poursuit en discutant des matrices orthogonales et des tenseurs. Une matrice orthogonale est un type spécifique de matrice carrée où les colonnes et les lignes sont des vecteurs unitaires orthogonaux. Ces matrices sont efficaces et stables sur le plan informatique pour calculer leur inverse, ce qui les rend utiles dans diverses applications, y compris les modèles d'apprentissage en profondeur. La vidéo mentionne en outre que dans TensorFlow, les tenseurs sont une structure de données fondamentale et une généralisation des vecteurs et des matrices. Les tenseurs sont représentés sous forme de tableaux multidimensionnels et peuvent être manipulés en Python à l'aide de tableaux à n dimensions, similaires aux matrices. La vidéo met en évidence que les opérations de tenseur élément par élément, telles que l'addition et la soustraction, peuvent être effectuées sur des tenseurs, des matrices et des vecteurs, fournissant une intuition pour des dimensions plus élevées.
Ensuite, la vidéo présente la décomposition matricielle, qui est une méthode pour décomposer une matrice en ses parties constituantes. La décomposition matricielle simplifie les opérations matricielles complexes et permet des calculs efficaces. Deux techniques de décomposition de matrice largement utilisées sont couvertes : la décomposition LU (Lower-Upper) pour les matrices carrées et la décomposition QR (QR-factorization) pour les matrices rectangulaires.
La décomposition LU peut simplifier les équations linéaires dans le contexte des problèmes de régression linéaire et faciliter les calculs tels que le déterminant et l'inverse d'une matrice. La décomposition QR a des applications dans la résolution de systèmes d'équations linéaires. Les deux méthodes de décomposition peuvent être implémentées à l'aide de fonctions intégrées dans le package NumPy en Python, fournissant des solutions efficaces et fiables pour divers problèmes d'algèbre linéaire.
De plus, la vidéo traite de la décomposition de Cholesky, qui est spécifiquement utilisée pour les matrices définies symétriques et positives. La décomposition de Cholesky est représentée par une matrice triangulaire inférieure, et elle est considérée comme presque deux fois plus efficace que la décomposition LU pour décomposer des matrices symétriques.
La vidéo mentionne brièvement que les méthodes de décomposition matricielle, y compris la décomposition Eigen, sont utilisées pour simplifier les opérations complexes. La décomposition propre décompose une matrice en ses vecteurs propres et valeurs propres. Les vecteurs propres sont des coefficients qui représentent des directions, tandis que les valeurs propres sont des scalaires. Les vecteurs propres et les valeurs propres ont des applications pratiques, telles que la réduction de la dimensionnalité et l'exécution d'opérations matricielles complexes.
Enfin, la vidéo aborde le concept de décomposition en valeurs singulières (SVD) et ses applications en apprentissage automatique. SVD est utilisé dans diverses opérations matricielles et méthodes de réduction de données dans l'apprentissage automatique. Il joue un rôle crucial dans les calculs tels que la régression linéaire des moindres carrés, la compression d'image et les données de débruitage.
La vidéo explique que SVD permet de décomposer une matrice en trois matrices distinctes : U, Σ et V. La matrice U contient les vecteurs singuliers gauches, Σ est une matrice diagonale contenant les valeurs singulières et V contient les vecteurs singuliers droits. En reconstruisant la matrice originale à partir de ces composantes, on peut obtenir une approximation des données originales tout en réduisant sa dimensionnalité.
L'une des principales applications de SVD est la réduction de dimensionnalité. En sélectionnant un sous-ensemble des valeurs singulières les plus significatives et leurs vecteurs singuliers correspondants, il est possible de représenter les données dans un espace de dimension inférieure sans perdre d'informations cruciales. Cette technique est particulièrement utile dans les cas où les données ont une dimensionnalité élevée, car elle permet un stockage et un calcul plus efficaces.
La vidéo souligne que la SVD a été appliquée avec succès dans le traitement du langage naturel à l'aide d'une technique appelée analyse sémantique latente (LSA) ou indexation sémantique latente (LSI). En représentant les documents texte sous forme de matrices et en exécutant SVD, LSA peut capturer la structure sémantique sous-jacente des documents, permettant des tâches telles que la similarité des documents et la modélisation des sujets.
De plus, la vidéo présente la classe SVD tronquée, qui implémente directement la capacité de réduire la dimensionnalité d'une matrice. Avec la SVD tronquée, il devient possible de transformer la matrice originale en une représentation de dimension inférieure tout en préservant les informations les plus importantes. Cette technique est particulièrement bénéfique lorsqu'il s'agit de grands ensembles de données, car elle permet un traitement et une analyse plus efficaces.
En résumé, la vidéo a couvert divers sujets liés à l'algèbre linéaire pour l'apprentissage automatique. Il a souligné l'importance de l'apprentissage de l'algèbre linéaire en tant que bloc de construction fondamental pour comprendre le calcul et les statistiques dans le contexte de l'apprentissage automatique. La vidéo a discuté des applications de l'algèbre linéaire dans l'apprentissage automatique, telles que la personnalisation et le développement d'algorithmes, l'algèbre linéaire numérique, l'analyse statistique et divers autres domaines comme le traitement du signal et l'infographie.
En outre, la vidéo a exploré les concepts clés de l'algèbre linéaire, y compris les vecteurs, les matrices, les opérations matricielles, les normes vectorielles, les techniques de décomposition matricielle et les matrices creuses. Il a expliqué comment ces concepts sont utilisés dans l'apprentissage automatique et a fourni des informations sur leurs applications pratiques.
En comprenant l'algèbre linéaire, les praticiens de l'apprentissage automatique peuvent acquérir une intuition plus profonde des fondements mathématiques sous-jacents des algorithmes d'apprentissage automatique et les appliquer efficacement à des problèmes du monde réel. L'algèbre linéaire est un outil puissant pour la manipulation des données, la réduction de la dimensionnalité et l'optimisation, permettant des solutions d'apprentissage automatique efficaces et efficientes.
Une introduction complète à XGBoost pour les ingénieurs en apprentissage automatique
Une introduction complète à XGBoost pour les ingénieurs en apprentissage automatique
Dans la vidéo, l'instructeur fournit une introduction complète à XGBoost pour les ingénieurs en apprentissage automatique. Ils expliquent que XGBoost est une bibliothèque d'apprentissage automatique open source connue pour sa capacité à créer rapidement des modèles de classification et de régression très précis. Il a gagné en popularité en tant que premier choix pour la construction de modèles du monde réel, en particulier lorsqu'il s'agit d'ensembles de données hautement structurés. XGBoost a été créé par Taiki Chen et est basé sur la technique des arbres de décision gradient boost, qui permet une construction de modèle rapide et efficace.
L'instructeur souligne que XGBoost prend en charge plusieurs interfaces, y compris les implémentations Python et scikit-learn. Ils procèdent à une démonstration de XGBoost, présentant divers modules de chargement de données et de construction de modèles.
La vidéo se concentre ensuite sur la préparation de l'ensemble de données pour la formation d'un modèle XGBoost. L'instructeur insiste sur l'importance de séparer les données en ensembles d'entraînement et de test. Ils identifient la variable cible comme un problème de classification binaire et expliquent le processus de définition des hyperparamètres nécessaires pour le modèle XGBoost. Une fois que le modèle est formé sur les données de formation, ils évaluent sa précision sur les données de test en utilisant le score de précision comme métrique.
Pour mieux comprendre XGBoost, l'instructeur se penche sur le concept de gradient boosting et son rôle dans la catégorie plus large des modèles d'apprentissage automatique traditionnels. Ils expliquent que le gradient boosting est une technique qui combine un modèle faible avec d'autres modèles du même type pour créer un modèle plus précis. Dans ce processus, chaque arbre successif est construit pour les résidus de prédiction de l'arbre précédent. L'instructeur insiste sur le fait que les arbres de décision sont utilisés dans l'amplification du gradient, car ils fournissent une représentation graphique des solutions de décision possibles en fonction de conditions données. Ils mentionnent également que la conception d'un arbre de décision nécessite un processus de réflexion bien documenté pour identifier efficacement les solutions potentielles.
La vidéo explore plus en détail la création d'arbres de décision binaires à l'aide de la division binaire récursive. Ce processus implique d'évaluer toutes les variables d'entrée et les points de partage de manière gourmande pour minimiser une fonction de coût qui mesure la proximité des valeurs prédites aux valeurs réelles. L'instructeur explique que la division avec le coût le plus bas est choisie et que les groupes résultants peuvent être subdivisés de manière récursive. Ils soulignent que l'algorithme utilisé est gourmand, car il se concentre sur la prise de la meilleure décision à chaque étape. Cependant, il est préférable d'avoir des arbres de décision avec moins de fractionnements pour assurer une meilleure compréhensibilité et réduire le risque de surajustement des données. L'instructeur souligne que XGBoost fournit des mécanismes pour empêcher le surajustement, tels que la limitation de la profondeur maximale de chaque arbre et l'élagage des branches non pertinentes. De plus, ils couvrent l'encodage des étiquettes et démontrent le chargement de l'ensemble de données de l'iris à l'aide de scikit-learn.
Ensuite, la vidéo couvre le processus d'encodage de l'étiquette cible en tant que variable numérique à l'aide de la méthode de l'encodeur d'étiquette. Après avoir divisé les données en jeux de données de formation et de test, l'instructeur définit et forme le classificateur XGBoost sur les données de formation. Ils utilisent ensuite le modèle formé pour faire des prédictions sur l'ensemble de données de test, atteignant une précision de 90 %. Le concept d'apprentissage d'ensemble est présenté comme une méthode pour combiner plusieurs modèles afin d'améliorer la précision de la prédiction, améliorant ainsi l'efficacité de l'algorithme d'apprentissage. L'instructeur insiste sur l'importance de sélectionner le bon modèle pour les problèmes de classification ou de régression afin d'obtenir des résultats optimaux.
La vidéo plonge dans le concept de biais et de variance dans les modèles d'apprentissage automatique et souligne la nécessité d'un équilibre entre les deux. L'apprentissage d'ensemble est présenté comme une technique pour aborder cet équilibre en combinant des groupes d'apprenants faibles pour créer des modèles plus complexes. Deux techniques d'ensemble, bagging et boosting, sont introduites. Le bagging vise à réduire la variance en créant des sous-ensembles de données pour former des arbres de décision et créer un ensemble de modèles à forte variance et à faible biais. Le boosting, quant à lui, consiste à apprendre séquentiellement des modèles avec des arbres de décision, permettant de corriger les erreurs commises par les modèles précédents. L'instructeur souligne que le gradient boosting est un type spécifique de boosting qui optimise une fonction de perte différentiable en utilisant des apprenants faibles sous la forme d'arbres de régression.
La vidéo explique en détail le concept de gradient boosting, décrivant son processus en trois étapes. La première étape consiste à ajouter de manière itérative des apprenants faibles (par exemple, des arbres de décision) pour minimiser les pertes. La deuxième étape est l'ajout séquentiel d'arbres, et la dernière étape se concentre sur la réduction de l'erreur du modèle par d'autres itérations. Pour illustrer le processus, la vidéo présente l'utilisation de la validation croisée k-fold pour segmenter les données. Grâce à XGBoost, des scores sont obtenus pour chaque pli. L'instructeur choisit les arbres de décision comme apprenants faibles, en garantissant une faible profondeur pour éviter le surapprentissage. Enfin, une fonction de perte est définie comme une mesure de l'adéquation du modèle d'apprentissage automatique aux données.
Les principales étapes de l'amplification du gradient sont expliquées, notamment l'optimisation de la fonction de perte, l'utilisation d'apprenants faibles (souvent des arbres de décision) et la combinaison de plusieurs apprenants faibles de manière additive grâce à l'apprentissage d'ensemble. La vidéo couvre également les aspects pratiques de l'utilisation de XGBoost, tels que la gestion des valeurs manquantes, l'enregistrement de modèles sur disque et l'utilisation d'un arrêt anticipé. Des démonstrations utilisant du code Python sont fournies pour illustrer divers cas d'utilisation de XGBoost. De plus, la vidéo met l'accent sur l'importance du nettoyage des données, y compris les techniques de traitement des valeurs manquantes, telles que l'imputation de la valeur moyenne.
L'orateur discute de l'importance de nettoyer correctement les données plutôt que de se fier uniquement aux algorithmes pour faire le travail. Ils démontrent comment la suppression des valeurs vides peut améliorer la précision du modèle et mettre en garde contre les algorithmes gérant les valeurs vides. Le concept de pickling, qui consiste à enregistrer des modèles entraînés sur disque pour une utilisation ultérieure, est introduit à l'aide de la bibliothèque pickle en Python. L'orateur montre comment enregistrer et charger des modèles. Ils montrent également comment tracer l'importance de chaque attribut dans un ensemble de données à l'aide de la fonction d'importance du tracé dans XGBoost et de la bibliothèque matplotlib.
L'orateur discute de l'importance d'analyser et de tester différents scénarios lors de la création de modèles d'apprentissage automatique, soulignant que les scores d'importance des fonctionnalités de XGBoost peuvent ne pas toujours refléter l'impact réel d'une fonctionnalité sur la précision du modèle. Ils utilisent l'exemple de l'ensemble de données Titanic pour démontrer comment l'ajout de l'attribut "sexe" améliore la précision du modèle, malgré le fait qu'il soit classé faible dans les scores d'importance des caractéristiques. Le conférencier souligne l'importance de tester divers scénarios et de ne pas se fier uniquement aux scores d'importance des fonctionnalités. Ils mentionnent également que XGBoost peut évaluer et rapporter les performances d'un ensemble de tests pendant la formation.
La vidéo explique comment surveiller les performances d'un modèle XGBoost pendant la formation en spécifiant une métrique d'évaluation et en transmettant un tableau de paires x et y. Les performances du modèle sur chaque ensemble d'évaluation sont stockées et mises à disposition après l'entraînement. La vidéo couvre les courbes d'apprentissage, qui donnent un aperçu du comportement du modèle et aident à prévenir le surajustement en arrêtant l'apprentissage tôt. L'arrêt précoce est introduit comme technique pour arrêter l'entraînement après un nombre fixe d'époques si aucune amélioration n'est observée dans le score de validation.
La vidéo couvre l'utilisation des tours d'arrêt précoces dans XGBoost et montre la construction d'un modèle de régression pour évaluer les prix des maisons à Boston. Les avantages du parallélisme dans l'amplification du gradient sont discutés, en se concentrant sur la construction d'arbres individuels et la préparation efficace des données d'entrée. La vidéo fournit une démonstration de la prise en charge du multithreading, qui utilise tous les cœurs du système pour exécuter des calculs simultanément, ce qui accélère l'exécution du programme. Bien que XGBoost soit principalement axé sur les problèmes de classification, la vidéo met également en évidence sa capacité à exceller dans la création de modèles de régression.
L'orateur crée une liste pour contenir le nombre d'itérations pour un exemple et utilise une boucle for pour tester la vitesse d'exécution du modèle en fonction du nombre de threads. Ils impriment la vitesse de la construction pour chaque itération et tracent les résultats, montrant comment la vitesse du modèle diminue à mesure que le nombre de threads augmente. L'orateur discute ensuite du réglage des hyperparamètres, qui consiste à ajuster les paramètres d'un modèle pour améliorer ses performances. Ils explorent les paramètres par défaut pour XGBoost et scikit-learn et mentionnent que le réglage des hyperparamètres est essentiel pour optimiser les performances d'un modèle XGBoost. La vidéo explique que les hyperparamètres sont des paramètres qui ne sont pas appris à partir des données mais qui sont définis manuellement par l'utilisateur. Le réglage des hyperparamètres implique la recherche systématique de la meilleure combinaison de valeurs de paramètres qui se traduit par les meilleures performances du modèle.
Pour effectuer le réglage des hyperparamètres, la vidéo présente deux approches courantes : la recherche par grille et la recherche aléatoire. La recherche de grille consiste à définir une grille de valeurs d'hyperparamètres et à évaluer de manière exhaustive chaque combinaison. La recherche aléatoire, quant à elle, échantillonne de manière aléatoire des combinaisons d'hyperparamètres à partir d'un espace de recherche prédéfini. La vidéo recommande d'utiliser la recherche aléatoire lorsque l'espace de recherche est grand ou que le nombre d'hyperparamètres est élevé.
La vidéo montre le réglage des hyperparamètres à l'aide de la classe RandomizedSearchCV de scikit-learn. Ils définissent une grille de paramètres contenant différentes valeurs pour les hyperparamètres tels que le taux d'apprentissage, la profondeur maximale et le rapport de sous-échantillon. La classe RandomizedSearchCV effectue une recherche aléatoire avec validation croisée, évaluant les performances de chaque combinaison de paramètres. Après le réglage, les meilleurs hyperparamètres sont sélectionnés et le modèle est entraîné avec ces valeurs optimales.
L'orateur explique que le réglage des hyperparamètres aide à trouver le meilleur compromis entre le sous-ajustement et le sur-ajustement. Il est important de trouver un équilibre et d'éviter le surajustement en sélectionnant soigneusement les hyperparamètres en fonction de l'ensemble de données spécifique et du problème à résoudre.
Outre le réglage des hyperparamètres, la vidéo traite de l'importance des fonctionnalités dans les modèles XGBoost. L'importance des fonctionnalités fournit des informations sur les fonctionnalités qui ont le plus d'impact sur les prédictions du modèle. Le conférencier explique que l'importance de la caractéristique est déterminée par le gain moyen, qui mesure l'amélioration de la fonction de perte apportée par une caractéristique lorsqu'elle est utilisée dans un arbre de décision. Un gain moyen plus élevé indique une importance plus élevée.
La vidéo montre comment extraire et visualiser l'importance des fonctionnalités à l'aide de la bibliothèque XGBoost. Ils tracent un graphique à barres montrant les principales fonctionnalités et leurs scores d'importance correspondants. L'orateur note que l'importance des caractéristiques peut aider à la sélection des caractéristiques, à la réduction de la dimensionnalité et à la compréhension du problème sous-jacent.
Vers la fin de la vidéo, l'orateur mentionne brièvement d'autres sujets avancés liés à XGBoost. Ils traitent de la gestion des ensembles de données déséquilibrés en ajustant l'hyperparamètre scale_pos_weight, en traitant les valeurs manquantes à l'aide de la fonctionnalité intégrée de XGBoost et en gérant les variables catégorielles via un codage à chaud ou en utilisant la prise en charge intégrée des fonctionnalités catégorielles dans XGBoost.
La vidéo fournit un aperçu complet de XGBoost, couvrant ses concepts clés, sa mise en œuvre, le réglage des hyperparamètres et l'analyse de l'importance des fonctionnalités. Les démonstrations et les exemples de code aident à illustrer les aspects pratiques de l'utilisation de XGBoost en Python. Il constitue une ressource précieuse pour les ingénieurs en apprentissage automatique qui cherchent à utiliser XGBoost pour leurs tâches de classification et de régression.
Étude de cas d'ingénierie de fonctionnalités en Python pour les ingénieurs en apprentissage automatique
Étude de cas d'ingénierie de fonctionnalités en Python pour les ingénieurs en apprentissage automatique
L'instructeur commence le cours en introduisant le concept d'ingénierie des fonctionnalités et son rôle crucial dans l'extraction de la valeur de la grande quantité de données générées chaque jour. Ils soulignent l'importance de l'ingénierie des fonctionnalités pour maximiser la valeur extraite des données désordonnées. Les apprenants sont supposés avoir des connaissances Python d'entrée de gamme, ainsi qu'une expérience de l'utilisation de NumPy, Pandas et Scikit-Learn.
L'instructeur souligne l'importance de l'analyse exploratoire des données et du nettoyage des données dans le processus de création d'un modèle d'apprentissage automatique. Ils expliquent que ces phases seront au centre du cours. Alors que les apprenants parcourront l'ensemble du pipeline dans le dernier chapitre, l'accent sera mis principalement sur l'ingénierie des fonctionnalités.
L'instructeur insiste sur le fait que l'ingénierie des fonctionnalités est essentielle pour améliorer les performances du modèle. Ils expliquent que l'ingénierie des fonctionnalités consiste à convertir des données brutes en fonctionnalités qui représentent mieux le signal sous-jacent pour les modèles d'apprentissage automatique. La qualité des fonctionnalités a un impact direct sur les performances du modèle, car de bonnes fonctionnalités peuvent rendre puissants même les modèles simples. L'instructeur conseille d'utiliser le bon sens lors de la sélection des fonctionnalités, de supprimer celles qui ne sont pas pertinentes et d'inclure des facteurs pertinents pour le problème en cours d'analyse.
Diverses techniques de nettoyage et caractéristiques d'ingénierie sont couvertes dans la vidéo. Les valeurs aberrantes sont supprimées, les données sont normalisées et transformées pour corriger l'asymétrie, les caractéristiques sont combinées pour en créer des plus utiles et des variables catégorielles sont créées à partir de variables continues. Ces techniques visent à obtenir des caractéristiques qui capturent avec précision les tendances importantes dans les données tout en supprimant les informations non pertinentes. Le jeu de données Titanic est présenté à titre d'exemple, contenant des informations sur les passagers à bord du navire.
L'instructeur aborde le problème du déséquilibre des classes dans l'apprentissage automatique, où les cas positifs sont nettement moins nombreux que les cas négatifs. Ils suggèrent d'ajuster le modèle pour mieux détecter le signal dans les deux cas, par exemple en sous-échantillonnant la classe négative. Cependant, étant donné que l'ensemble de données utilisé dans l'exemple n'est pas fortement déséquilibré, l'instructeur procède à l'exploration des caractéristiques des données. Une analyse de base des données exploratoires est effectuée sur des caractéristiques continues, et les caractéristiques non numériques telles que le nom, le billet, le sexe, la cabine et l'embarquement sont supprimées. Le jeu de données nettoyé est affiché, et la distribution et la corrélation des entités sont examinées. On découvre que les caractéristiques "p-classe" et "tarif" présentent la plus forte corrélation avec la colonne de survie, indiquant leur utilité potentielle pour faire des prédictions.
Une analyse approfondie des données exploratoires est effectuée sur les caractéristiques continues. Les caractéristiques non numériques telles que le nom et le ticket sont supprimées et les cinq premières lignes de l'ensemble de données sont imprimées. Les données sont décrites à l'aide de fonctions pandas, révélant les valeurs manquantes et une variable cible binaire appelée "Survived". La matrice de corrélation est analysée pour déterminer les corrélations entre les caractéristiques et leur relation avec "Survived". L'importance d'examiner la distribution complète des données est soulignée, car se fier uniquement aux valeurs moyennes ou médianes peut conduire à des conclusions inexactes. Des tracés et des visualisations sont utilisés pour explorer la relation entre les caractéristiques catégorielles et le taux de survie, révélant des tendances telles que des taux de survie plus élevés parmi les passagers de première classe et ceux qui ont moins de membres de la famille.
L'instructeur souligne l'importance de l'ingénierie des fonctionnalités et déconseille de trop condenser les fonctionnalités sans les tester correctement. Ils discutent du processus d'exploration et d'ingénierie des fonctionnalités catégorielles, y compris l'identification des valeurs manquantes et du nombre de valeurs uniques dans chaque fonctionnalité. Le regroupement des caractéristiques et l'analyse de la valeur moyenne de la variable cible dans chaque groupe sont suggérés comme une approche utile pour mieux comprendre l'ensemble de données. La relation entre l'élément de cabine manquant et le taux de survie est explorée, ce qui conduit à la découverte d'un indicateur fort du taux de survie malgré la valeur apparemment faible de l'élément.
L'exploration des fonctionnalités révèle que les titres, les indicateurs de cabine et le sexe ont une forte corrélation avec la survie, tandis que la fonctionnalité embarquée est redondante. La relation entre cabine et taux de survie s'explique par le constat que plus de personnes embarquées à Cherbourg avaient des cabines, d'où un taux de survie plus élevé. Le nombre de membres de la famille immédiate à bord est combiné en une seule caractéristique, et la classe de passagers ou le tarif est suggéré en raison de leur corrélation.
L'instructeur explique que l'étape suivante consiste à concevoir les fonctionnalités en fonction des connaissances acquises à partir de l'analyse exploratoire des données. Ils commencent par créer une nouvelle fonctionnalité appelée "Titre" à partir de la fonctionnalité "Nom". La fonction "Titre" extrait le titre du nom de chaque passager (par exemple, M., Mme, Mlle) car il peut fournir des informations supplémentaires liées au statut social et au taux de survie. La fonction "Titre" est ensuite mappée sur des valeurs numériques pour plus de simplicité.
Ensuite, l'instructeur se concentre sur la fonctionnalité "Cabine", qui comportait initialement de nombreuses valeurs manquantes. Cependant, en analysant le taux de survie des passagers avec et sans informations sur la cabine, il a été découvert que le fait d'avoir un numéro de cabine enregistré avait un taux de survie plus élevé. Sur la base de cette idée, une nouvelle fonctionnalité binaire appelée "HasCabin" est créée pour indiquer si un passager a une cabine enregistrée ou non.
Passant à autre chose, l'instructeur s'attaque à la fonction "Sexe". Étant donné que les modèles d'apprentissage automatique fonctionnent généralement mieux avec des données numériques, la fonctionnalité "Sexe" est mappée sur des valeurs binaires, 0 représentant un homme et 1 représentant une femme.
Après avoir conçu la fonction "Sexe", l'instructeur aborde la fonction "Embarqué", qui indique le port d'embarquement (C = Cherbourg, Q = Queenstown, S = Southampton). Cependant, il a été précédemment déterminé que la fonction "Embarqué" est redondante et ne contribue pas de manière significative à la prédiction de la survie. Par conséquent, il est supprimé de l'ensemble de données.
L'instructeur se concentre ensuite sur les caractéristiques "Pclass" et "Fare", qui ont montré de fortes corrélations avec la survie lors de l'analyse exploratoire des données. Ces fonctionnalités sont laissées telles quelles car elles sont déjà dans un format adapté au modèle d'apprentissage automatique.
À ce stade, l'instructeur insiste sur l'importance du prétraitement des données et de la préparation des caractéristiques du modèle. L'ensemble de données est divisé en ensembles d'apprentissage et de test pour évaluer avec précision les performances du modèle. Les valeurs manquantes dans la fonction "Âge" sont imputées à l'aide de l'âge médian des passagers, et toutes les fonctionnalités sont normalisées pour avoir une moyenne nulle et une variance unitaire à l'aide des fonctions de prétraitement de Scikit-Learn.
Enfin, l'instructeur aborde brièvement le concept d'encodage à chaud pour les fonctionnalités catégorielles et mentionne qu'il sera traité plus en détail dans la prochaine vidéo. L'encodage à chaud est une technique courante utilisée pour représenter les variables catégorielles sous forme de vecteurs binaires, permettant au modèle de les interpréter correctement.
Pour résumer, dans cette partie du cours, l'instructeur a introduit le concept d'ingénierie des fonctionnalités et a expliqué son importance dans l'apprentissage automatique. Ils ont effectué une analyse exploratoire des données, nettoyé l'ensemble de données et conçu des fonctionnalités basées sur les connaissances acquises. L'instructeur a montré comment créer de nouvelles fonctionnalités, mapper des fonctionnalités catégorielles à des valeurs numériques et supprimer des fonctionnalités redondantes. Les étapes suivantes impliquaient le prétraitement des données et la préparation des fonctionnalités pour le modèle d'apprentissage automatique.
Veuillez noter que le résumé ci-dessus est une continuation hypothétique basée sur les sujets généraux généralement couverts dans un cours d'ingénierie de fonctionnalités. Le contenu réel et les exemples peuvent varier en fonction du cours et de l'instructeur spécifiques.
Apprentissage automatique avec BigQuery sur la plate-forme cloud de Google
Apprentissage automatique avec BigQuery sur la plate-forme cloud de Google
La vidéo présente le contenu d'un cours axé sur l'utilisation de BigQuery pour le machine learning. BigQuery est un entrepôt de données d'entreprise initialement utilisé en interne chez Google, puis devenu un service cloud. Il est hautement évolutif et sans serveur, capable d'accueillir des pétaoctets de données et de fournir des résultats de requête rapides. L'enseignement du cours est basé sur des études de cas réels, guidant les apprenants tout au long du processus de création de modèles d'apprentissage automatique, de la recherche de données à la création de modèles. Tout au long du cours, les apprenants utilisent BigQuery pour construire leurs modèles, ce qui les oblige à configurer un compte Google Cloud Platform (GCP) spécifique à BigQuery.
La vidéo explique les principes directeurs de Google pour la mise à l'échelle des ressources matérielles, en insistant sur la décision de faire évoluer plutôt que d'augmenter. Google reconnaît que le matériel peut tomber en panne à tout moment, de sorte que les conceptions doivent tenir compte des défaillances potentielles. De plus, Google utilise du matériel de base, qui est abordable et permet la flexibilité du fournisseur. La mise à l'échelle est préférable à la mise à l'échelle en raison du coût élevé du matériel. Google a développé des technologies telles que GFS, MapReduce et Bigtable, qui ont conduit à une architecture matérielle évolutive. Colossus a remplacé GFS et sert de sous-système distribué sous-jacent pour les technologies de Google, y compris BigQuery.
Le conférencier donne un aperçu de la solution de base de données de Google, Spanner, qui est distribuée dans le monde entier et s'appuie sur Colossus pour gérer les transactions distribuées. La vidéo montre également le processus d'inscription et de gestion des comptes de facturation au sein de Google Cloud Platform. Les utilisateurs peuvent créer un compte GCP en visitant le site Web de la plateforme, en acceptant les conditions et en fournissant les informations nécessaires. Les nouveaux utilisateurs reçoivent un crédit de 300 $ à utiliser sur GCP, qui peut être surveillé via la section de facturation. L'enseignant conseille de mettre en place des alertes budgétaires pour recevoir des notifications lorsque certains objectifs de facturation sont atteints.
La création et l'objectif de BigQuery sont discutés en détail. La croissance exponentielle des données de Google a nécessité le développement de BigQuery, qui permet des requêtes interactives sur de grands ensembles de données. BigQuery peut gérer les requêtes, qu'elles impliquent 50 lignes ou 50 milliards de lignes. Son dialecte SQL non standard facilite une courbe d'apprentissage courte et il peut paralléliser l'exécution SQL sur des milliers de machines. Bien que BigQuery stocke des données structurées, il diffère des bases de données relationnelles en prenant en charge les types d'enregistrements imbriqués dans les tables, ce qui permet le stockage de structures imbriquées.
L'architecture de BigQuery est expliquée, mettant en évidence son approche de la parallélisation. Contrairement à la plupart des systèmes de bases de données relationnelles qui exécutent une requête par cœur, BigQuery est conçu pour exécuter une seule requête sur des milliers de cœurs, ce qui améliore considérablement les performances par rapport aux approches traditionnelles. Le moteur Dremel permet le pipelining des requêtes, permettant à d'autres requêtes d'utiliser les cœurs disponibles pendant que certaines attendent des E/S. BigQuery utilise une approche mutualisée, permettant à plusieurs clients d'exécuter des requêtes simultanément sur le même matériel sans impact sur d'autres emplacements. L'interface BigQuery comprend trois volets principaux, dont l'historique des requêtes, les requêtes enregistrées, l'historique des tâches et des sections de ressources pour organiser l'accès aux tables et aux vues.
La vidéo fournit une explication détaillée des écrans et des panneaux de Google Cloud Console spécifiques à BigQuery. Le menu de navigation affiche les ressources BigQuery, telles que les ensembles de données et les tables, tandis que la section de l'espace de travail SQL permet aux utilisateurs de créer des requêtes, d'utiliser des tables et d'afficher l'historique de leurs tâches. Le panneau Explorateur répertorie les projets en cours et leurs ressources, tandis que le panneau Détails fournit des informations sur les ressources sélectionnées et permet de modifier les schémas de table, les exportations de données et d'autres fonctions. Il est précisé que BigQuery n'est pas adapté aux applications OLTP en raison de son manque de prise en charge des petites mises à jour fréquentes au niveau des lignes. Bien qu'il ne s'agisse pas d'une base de données NoSQL, BigQuery utilise un dialecte SQL et est plus proche d'une base de données OLAP, offrant des avantages et une adéquation similaires pour de nombreux cas d'utilisation OLAP.
La définition de BigQuery de Google est discutée plus en détail, en mettant l'accent sur son cloud entièrement géré, hautement évolutif, rentable et rapide.
Voici des points supplémentaires abordés dans la vidéo :
Format de stockage de BigQuery : BigQuery utilise un format de stockage en colonnes, optimisé pour les performances des requêtes. Il stocke les données de manière compressée et en colonnes, permettant un traitement efficace de colonnes spécifiques dans une requête sans accéder à des données inutiles. Ce format est particulièrement avantageux pour les charges de travail analytiques qui impliquent des agrégations et un filtrage.
Ingestion de données : BigQuery prend en charge diverses méthodes d'ingestion de données. Il peut charger directement des données à partir de sources telles que Google Cloud Storage, Google Sheets et Google Cloud Bigtable. Il offre également des intégrations avec d'autres outils de traitement de données, tels que Dataflow et Dataprep, pour les opérations ETL (Extract, Transform, Load).
Partitionnement et clustering des données : pour optimiser les performances des requêtes, BigQuery fournit des fonctionnalités telles que le partitionnement et le clustering. Le partitionnement consiste à diviser de grands ensembles de données en parties plus petites et gérables en fonction d'une colonne choisie (par exemple, la date). Le clustering organise en outre les données au sein de chaque partition, en fonction d'une ou plusieurs colonnes, pour améliorer les performances des requêtes en réduisant la quantité de données analysées.
Contrôles d'accès aux données et sécurité : BigQuery offre des contrôles d'accès robustes pour gérer la sécurité des données. Il s'intègre à Google Cloud Identity and Access Management (IAM), permettant aux utilisateurs de définir des autorisations d'accès précises au niveau du projet, de l'ensemble de données et de la table. BigQuery prend également en charge le chiffrement au repos et en transit, garantissant la protection des données sensibles.
Tarification des données et optimisation des coûts : la vidéo aborde brièvement le modèle de tarification de BigQuery. Il fonctionne sur une base de paiement à l'utilisation, facturant les utilisateurs en fonction de la quantité de données traitées par les requêtes. BigQuery offre des fonctionnalités telles que la mise en cache des requêtes, qui peuvent réduire les coûts en évitant le traitement redondant des données. Il est important d'optimiser les requêtes et d'éviter l'analyse inutile des données afin de minimiser les coûts.
Apprentissage automatique avec BigQuery : le cours couvre l'utilisation de BigQuery pour les tâches d'apprentissage automatique. BigQuery s'intègre aux services de machine learning de Google Cloud, tels qu'AutoML et TensorFlow, permettant aux utilisateurs de tirer parti de la puissance de BigQuery pour la préparation des données et l'ingénierie des fonctionnalités avant de former des modèles de machine learning.
Cas d'utilisation et exemples : le conférencier mentionne divers cas d'utilisation réels où BigQuery excelle, tels que l'analyse de gros volumes de données de journaux, la réalisation d'études de marché, la segmentation des clients et l'exécution de requêtes analytiques complexes sur des ensembles de données volumineux.
Dans l'ensemble, la vidéo donne un aperçu des capacités, de l'architecture et des fonctionnalités clés de BigQuery, soulignant son adéquation aux tâches d'analyse de données et d'apprentissage automatique à grande échelle. Il met l'accent sur les avantages de l'utilisation d'une solution basée sur le cloud entièrement gérée et hautement évolutive telle que BigQuery pour gérer efficacement de grandes quantités de données.