Apprentissage Automatique et Réseaux Neuronaux - page 43

[MetaQuotes]

Comment fonctionne réellement ChatGPT

Comment fonctionne réellement ChatGPT

ChatGPT est un modèle d'apprentissage automatique capable d'identifier correctement le contenu préjudiciable dans les conversations de chat. Son architecture est basée sur l'apport humain, et ses lacunes sont soulignées. Des lectures recommandées sont également fournies.

• 00:00:00 ChatGPT est un chatbot conçu pour atténuer les problèmes de désalignement du modèle. Il utilise l'apprentissage par renforcement à partir de la rétroaction humaine pour affiner un modèle pré-formé.
  
  
• 00:05:00 ChatGPT est un modèle d'apprentissage automatique capable d'identifier correctement le contenu préjudiciable dans les conversations de chat. Son architecture est basée sur l'apport humain, et ses lacunes sont soulignées. Des lectures recommandées sont également fournies.

[MetaQuotes]

Apprentissage automatique à partir de zéro Cours complet

Apprentissage automatique à partir de zéro Cours complet

Implémenter vous-même des modèles d'apprentissage automatique est l'un des meilleurs moyens de les maîtriser. Bien que cela semble être une tâche difficile, c'est souvent plus facile que vous ne l'imaginez pour la plupart des algorithmes. Au cours des 10 prochains jours, nous utiliserons Python et occasionnellement Numpy pour des calculs spécifiques afin de mettre en œuvre un algorithme d'apprentissage automatique chaque jour.

Vous pouvez trouver le code dans notre dépôt GitHub : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch

[MetaQuotes]

Comment implémenter KNN à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/01%20KNN

Comment implémenter KNN à partir de zéro avec Python

Dans la vidéo intitulée "Comment implémenter KNN à partir de zéro avec Python", l'orateur explique comment créer un classificateur KNN à partir de zéro en utilisant Python. Ils couvrent les étapes impliquées dans la mise en œuvre de l'algorithme, telles que le calcul de la distance entre le nouveau point de données et d'autres points de l'ensemble de données, la sélection des k points les plus proches et la détermination de l'étiquette de classification ou de la moyenne de régression. L'orateur implémente l'algorithme à l'aide d'une classe en Python et démontre son implémentation réussie sur l'ensemble de données iris avec un taux de précision de 96 %. Ils invitent également les téléspectateurs à consulter le code sur leur référentiel Github et à poser des questions dans la section des commentaires.

• 00:00:00 Dans cette section, nous découvrons l'algorithme k Nearest Neighbors (k-NN), son fonctionnement et les étapes nécessaires pour implémenter l'algorithme en Python. k-NN est un algorithme basé sur la distance où les k points de données les plus proches sont sélectionnés en fonction de leur distance au nouveau point de données. Cette valeur de k est déterminée par l'utilisateur et peut être utilisée à la fois pour les problèmes de régression et de classification. L'algorithme commence par calculer la distance entre le nouveau point de données et les autres points de données du jeu de données. Ensuite, les k points les plus proches sont choisis et la moyenne de leurs valeurs est prise pour la régression, ou l'étiquette avec le vote majoritaire est déterminée pour la classification. Nous verrons également comment implémenter l'algorithme en utilisant une classe en Python avec une fonction d'ajustement et de prédiction, et une fonction d'assistance pour calculer la distance entre deux points.
  
  
• 00:05:00 Dans cette section, l'orateur explique comment créer un classificateur KNN à partir de zéro en utilisant Python. En commençant par la méthode de tri d'arc pour trier le tableau de distance, ils passent à la sélection des k voisins les plus proches, à l'obtention de l'étiquette de classe la plus courante et au retour de l'étiquette la plus courante. Ils implémentent ensuite ce classificateur sur l'ensemble de données d'iris pour classer les types de fleurs et atteindre un taux de précision de 96 %, démontrant la mise en œuvre réussie de KNN. L'orateur invite les téléspectateurs à vérifier le code disponible sur leur référentiel Github et à poser des questions dans la section des commentaires.

[MetaQuotes]

Comment implémenter la régression linéaire à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/02%20Linear%20Regression

Comment implémenter la régression linéaire à partir de zéro avec Python

Cette vidéo couvre le processus de mise en œuvre de la régression linéaire à partir de zéro à l'aide de Python. L'orateur explique comment trouver la meilleure ligne d'ajustement en utilisant l'erreur quadratique moyenne et comment calculer les poids et les biais avec la descente de gradient. L'orateur explique également comment le taux d'apprentissage affecte la convergence et montre comment tester le modèle à l'aide de la fonction d'ensemble de données de scikit-learn. Ils corrigent également une faute de frappe dans le code et ajustent le taux d'apprentissage pour améliorer l'ajustement de la ligne de prédiction. Le code est partagé sur GitHub et les spectateurs sont invités à poser des questions.

• 00:00:00 Dans cette section, l'accent est mis sur la régression linéaire, qui consiste à comprendre le modèle d'un ensemble de données donné et à tracer une ligne linéaire qui correspond le mieux possible aux données. L'erreur quadratique moyenne est utilisée pour calculer l'erreur de la ligne pour tous les points de données, et la ligne la mieux ajustée est trouvée en calculant les valeurs des paramètres du modèle ou du poids et du biais qui donnent une erreur quadratique moyenne minimale en utilisant la descente de gradient. Le taux d'apprentissage est utilisé pour contrôler la vitesse ou la lenteur d'aller dans la direction que la descente de gradient nous dit d'aller, où un faible taux d'apprentissage peut entraîner une approche lente de l'erreur minimale, tandis qu'un taux d'apprentissage élevé peut entraîner des sauts dans l'espace aérien et incapacité à trouver le minimum. Pendant la formation, le poids et le biais sont initialisés à zéro, et l'équation reçoit un point de données pour prédire ou estimer
  le résultat et l'erreur de l'équation sont calculés, ce qui facilite l'utilisation de la multiplication matricielle avec tous les points de données pour calculer les gradients. Pendant les tests, un modèle entraîné prédit les résultats à l'aide de l'équation.
  
  
• 00:05:00 Dans cette section, l'orateur implémente une régression linéaire à partir de zéro avec Python. Le locuteur initialise le taux d'apprentissage, définit une valeur par défaut pour le nombre d'itérations et définit les poids et les biais comme zéro. Le locuteur procède ensuite à la prédiction du résultat en prenant le produit scalaire de x avec les poids et en ajoutant le biais. Pour calculer les dérivées, le locuteur utilise une équation simple, puis met à jour les poids et les biais en calculant les gradients. Enfin, l'orateur résume les différences entre les prédictions et les valeurs réelles, et le processus est répété pour un certain nombre d'itérations jusqu'à convergence.
  
  
• 00: 10: 00 Dans cette section, l'orateur explique comment entraîner le modèle de régression linéaire et faire des prédictions à l'aide de la classe donnée. La mise à jour des poids et des biais est effectuée en soustrayant le taux d'apprentissage multiplié par les dérivées des poids et des biais respectivement. Pour effectuer plusieurs itérations d'exécution de l'algorithme, une boucle for est ajoutée pour exécuter l'algorithme sur l'ensemble de données. Enfin, l'orateur montre comment tester l'efficacité de l'algorithme de régression linéaire à l'aide d'une fonction d'ensemble de données scikit-learn, en ajustant une ligne qui donne de bonnes performances et en calculant l'erreur quadratique moyenne pour les prédictions. Une erreur de dimension est rencontrée en raison d'un mauvais calcul du produit scalaire, qui est corrigé en obtenant la transposition de x.
  
  
• 00: 15: 00 Dans cette section, le présentateur corrige une faute de frappe dans le code et l'utilise pour créer un modèle de régression linéaire qui prédit les valeurs y en fonction des valeurs x d'un ensemble de données donné. Ils visualisent ensuite la ligne de prédiction et remarquent que bien qu'elle soit bien ajustée, elle pourrait être améliorée. Le présentateur décide d'ajuster le taux d'apprentissage et relance le modèle pour obtenir un meilleur ajustement. Ils partagent le code sur GitHub et invitent les téléspectateurs à poser des questions si nécessaire.

[MetaQuotes]

Comment implémenter la régression logistique à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/03%20Logistic%20Regression

Comment implémenter la régression logistique à partir de zéro avec Python

La vidéo explique comment implémenter la régression logistique à partir de zéro avec Python, en utilisant la fonction sigmoïde pour créer des probabilités et une entropie croisée comme fonction d'erreur. L'instructeur partage des instructions étape par étape pour calculer les prédictions, les gradients et mettre à jour les biais par itérations. Ils montrent également comment charger un ensemble de données sur le cancer du sein et former le classificateur de régression logistique pour prédire si une tumeur est maligne ou bénigne. La vidéo se termine par l'évaluation de la précision du modèle à l'aide d'une fonction personnalisée. Dans l'ensemble, l'implémentation est réussie et prouve que l'algorithme de régression logistique fonctionne bien.

• 00:00:00 Dans cette section, la vidéo traite de la régression logistique et de la manière dont elle implique la création de probabilités au lieu de valeurs spécifiques à l'aide de la fonction sigmoïde. Au lieu d'utiliser l'erreur quadratique moyenne, la régression logistique utilise l'entropie croisée pour sa fonction d'erreur. Pour utiliser la descente de gradient, le gradient de la fonction d'erreur en termes de poids et de biais doit être calculé. Le taux d'apprentissage est utilisé pour déterminer la vitesse d'approche de la direction donnée par le gradient. Pendant les tests, la probabilité est calculée et l'étiquette est choisie en fonction de la probabilité la plus élevée. La mise en œuvre de la régression logistique est similaire à la régression linéaire, mais avec l'initialisation des poids et des biais à zéro.
  
  
• 00:05:00 Dans cette section de la vidéo, l'instructeur explique comment implémenter la régression logistique avec Python en utilisant une fonction sigmoïde pour prédire les résultats. Le processus implique de calculer les prédictions à partir du produit des poids et des valeurs x plus le biais, de les mettre dans une fonction sigmoïde pour donner les résultats et de calculer les gradients. L'instructeur montre comment calculer le gradient pour le biais et les mises à jour par itérations. La section explique également comment effectuer une inférence avec régression logistique en obtenant la probabilité et en choisissant l'étiquette en fonction des valeurs des prédictions.
  
  
• 00:10:00 Dans cette section, l'instructeur montre comment mettre en œuvre une régression logistique à partir de zéro à l'aide de Python. Ils expliquent le processus étape par étape, montrant comment calculer les probabilités et les étiquettes de classe à l'aide de la fonction sigmoïde, et comment ajuster le taux d'apprentissage pour obtenir de meilleurs résultats. L'instructeur charge également un ensemble de données sur le cancer du sein à partir de Scikit-learn et forme le classificateur de régression logistique pour prédire si une tumeur est maligne ou bénigne en fonction des caractéristiques de l'ensemble de données. Enfin, ils évaluent la précision de l'algorithme et montrent comment le calculer à l'aide d'une fonction personnalisée. Dans l'ensemble, l'implémentation est réussie et montre que l'algorithme fait maison fonctionne plutôt bien.

[MetaQuotes]

Comment implémenter Random Forest à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/05%20Random%20Forests

Comment implémenter Random Forest à partir de zéro avec Python

Ce didacticiel vidéo explique comment implémenter des forêts aléatoires à partir de zéro avec Python. Pendant la formation, un sous-ensemble aléatoire de l'ensemble de données est sélectionné et un arbre de décision est créé avec ce sous-ensemble. Ce processus est répété pour le nombre d'arbres déterminé avant de commencer l'algorithme. Lors de l'inférence, la prédiction est obtenue à partir de chaque arbre, et s'il s'agit d'une classification, le vote majoritaire de l'étiquette de classe est pris. L'orateur montre comment l'implémenter en créant une liste en y répartissant les arbres de décision et en l'ajoutant à un tableau Numpy. La précision peut être calculée en utilisant le nombre de valeurs vraies correctement prédites divisé par le nombre total de valeurs vraies. L'orateur parle également du nombre d'arbres, de la profondeur maximale et de la répartition minimale de l'échantillon pouvant être modifiés pour obtenir une plus grande précision.

• 00:00:00 Dans cette section, nous découvrons les forêts aléatoires, qui consistent en de nombreux arbres de décision différents. Le processus consiste à introduire un certain caractère aléatoire dans l'équation lors de la création de ces arbres. Pendant la formation, un sous-ensemble aléatoire de l'ensemble de données est sélectionné et un arbre de décision est créé avec ce sous-ensemble. Ce processus est répété pour le nombre d'arbres déterminé avant de commencer l'algorithme. Lors de l'inférence, la prédiction est obtenue à partir de chaque arbre, et s'il s'agit d'une classification, le vote majoritaire de l'étiquette de classe est pris. S'il s'agit d'une régression, la moyenne de toutes les prédictions est calculée. L'implémentation utilise la classe d'arbres de décision créée dans la leçon précédente et est initialisée en spécifiant le nombre d'arbres, la profondeur maximale, les échantillons minimum pour une scission, le nombre d'entités et un tableau vide pour contenir tous les arbres. La classe a une fonction d'ajustement et de prédiction, et ce qui est nécessaire est de passer les paramètres requis comme mentionné ci-dessus.
  
  
• 00:05:00 Dans cette section, l'instructeur explique comment ajuster un arbre de décision basé sur un sous-ensemble d'échantillons et l'ajouter à la liste des arbres dans un modèle de forêt aléatoire. Une fonction d'assistance "bootstrap_samples" est créée pour choisir au hasard un nombre spécifié d'échantillons avec remplacement à partir de l'ensemble de données donné. L'instructeur explique ensuite comment prédire à l'aide de la forêt aléatoire pour une entrée X, ce qui implique une itération sur tous les arbres de la forêt aléatoire et le renvoi d'une liste de prédictions, où chaque liste interne contient des prédictions pour le même échantillon à partir de différents arbres. Enfin, l'instructeur introduit la fonction "swap axis" de numpy pour réorganiser les listes et une fonction d'assistance "most_common" qui utilise la structure de données de compteur de la bibliothèque de collections pour renvoyer l'étiquette de classification la plus courante.
  
  
• 00:10:00 Dans cette section, l'orateur explique le processus de mise en œuvre d'une forêt aléatoire à partir de zéro en utilisant Python. Ils mentionnent une fonction d'assistance qui sera utilisée pour la prédiction et créent une liste, y répartissent les arbres de décision, puis l'ajoutent à un tableau NumPy qui sera renvoyé pour les prédictions. La précision est calculée en utilisant le nombre de valeurs vraies correctement prédites divisé par le nombre total de valeurs vraies. L'orateur mentionne également que le nombre d'arbres, la profondeur maximale et la répartition minimale de l'échantillon peuvent être manipulés pour obtenir une plus grande précision. L'orateur dirige les téléspectateurs vers le code sur leur référentiel GitHub et accueille les questions dans la section des commentaires. Enfin, l'intervenant passe la main à Patrick pour la suite du tutoriel.

[MetaQuotes]

Comment implémenter Naive Bayes à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/06%20NaiveBayes

Comment implémenter Naive Bayes à partir de zéro avec Python

Ce didacticiel vidéo se concentre sur la mise en œuvre de Naive Bayes à partir de zéro à l'aide de Python. L'instructeur donne un aperçu du théorème de Bayes et de l'hypothèse d'indépendance. Ils expliquent comment calculer la probabilité a priori et la probabilité conditionnelle de classe, nécessaires à l'apprentissage de l'algorithme. L'orateur introduit également la distribution gaussienne comme moyen de modéliser les probabilités. La vidéo montre les étapes d'entraînement et de prédiction de l'algorithme avec code. L'instructeur teste l'algorithme sur un ensemble de données de jouet avec deux classes, obtenant une précision de 96,5 %. Dans l'ensemble, ce didacticiel est une ressource utile pour ceux qui souhaitent apprendre Naive Bayes et l'implémenter en Python.

• 00: 00: 00 Dans cette section, l'orateur discute de la théorie derrière Naive Bayes, un classificateur probabiliste qui suppose l'indépendance entre les caractéristiques pour prédire les étiquettes de classe. Ils expliquent le théorème de Bayes et l'hypothèse d'indépendance, et comment cela est utilisé pour calculer la probabilité a posteriori de chaque classe. L'orateur poursuit en expliquant comment calculer la probabilité a priori et la probabilité conditionnelle de classe, qui sont toutes deux nécessaires à l'apprentissage de l'algorithme. Ils introduisent également la distribution gaussienne comme moyen de modéliser les probabilités. Les étapes de formation et de prédiction sont résumées et le code pour implémenter Naive Bayes est démontré. L'orateur fournit une définition des méthodes d'ajustement et de prédiction, et décrit les étapes nécessaires à la formation et à la prédiction dans chacune d'elles.
  
  
• 00:05:00 Dans cette section de la vidéo, l'instructeur explique comment implémenter Naive Bayes à partir de zéro en utilisant Python. Le code suppose que x et y sont déjà au format de tableau numpy et d. L'instructeur montre comment extraire x en utilisant x.shape et comment obtenir le nombre de classes uniques en utilisant numpy.unique(). L'étape suivante consiste à calculer la moyenne, la variance et le prior pour chaque classe. Cela peut être accompli en initialisant ces valeurs avec des zéros, puis en les calculant à l'aide de fonctions numpy. L'instructeur explique ensuite comment calculer la probabilité a posteriori pour chaque classe en utilisant une fonction d'assistance et une compréhension de liste. Enfin, l'instructeur montre comment renvoyer la prédiction sous la forme d'un tableau numpy.
  
  
• 00:10:00 Dans cette section, l'intervenant discute de l'implémentation de l'algorithme Naive Bayes en Python. Ils passent par les étapes de calcul des a priori, puis de calcul de la postérieure à l'aide d'une distribution gaussienne et de création d'une fonction d'assistance pour la densité de probabilité, suivie de la prédiction de la classe avec la postérieure la plus élevée. Enfin, ils testent l'algorithme sur un jeu de données jouet de 1000 échantillons et 10 caractéristiques avec deux classes, atteignant une précision de 96,5 %. L'orateur encourage une exploration plus approfondie du code et attend avec impatience la prochaine leçon.

[MetaQuotes]

Comment implémenter PCA (Principal Component Analysis) à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/07%20PCA

Comment implémenter PCA (Principal Component Analysis) à partir de zéro avec Python

La vidéo explique le processus de mise en œuvre de l'analyse en composantes principales (ACP) à partir de zéro en utilisant Python et Numpy. L'ACP est une technique qui réduit la dimensionnalité d'un ensemble de données tout en conservant la plupart des informations. L'instructeur parcourt les étapes de création d'une classe Python avec des méthodes d'ajustement et de transformation pour effectuer une ACP sur un ensemble de données. La méthode d'ajustement calcule d'abord la moyenne et la covariance des données et extrait les vecteurs propres et les valeurs propres. La méthode de transformation projette ensuite les données sur les composantes principales. L'orateur souligne l'importance de soustraire les moyennes et de trier les vecteurs propres dans le processus. Enfin, la mise en œuvre est testée sur l'ensemble de données Iris, ce qui aboutit à une réduction réussie de la dimensionnalité de quatre à deux dimensions.

• 00: 00: 00 Dans cette section, l'instructeur discute de l'analyse en composantes principales (ACP), une méthode d'apprentissage non supervisée qui réduit la dimensionnalité d'un ensemble de données en le transformant en un ensemble dimensionnel inférieur qui contient toujours la plupart des informations de l'ensemble plus large. L'instructeur explique comment l'ACP trouve une transformation telle que les entités transformées sont linéairement indépendantes, la dimensionnalité étant réduite en ne prenant que les dimensions les plus importantes. Les dimensions nouvellement trouvées doivent minimiser l'erreur de projection et les points projetés doivent avoir une dispersion maximale, ce qui signifie une variance maximale. L'instructeur parcourt les étapes pour implémenter PCA à partir de zéro en utilisant Python et Numpy. Ces étapes comprennent la soustraction de la moyenne de x, le calcul de la covariance de x et x et le tri des vecteurs propres en fonction de leurs valeurs propres par ordre décroissant.
  
  
• 00:05:00 Dans cette section, l'orateur explique la mise en œuvre de l'analyse en composantes principales (ACP) à l'aide de Python. Cela implique de créer une fonction "init" qui prend le nombre de composants en entrée, une méthode "fit" qui soustrait la moyenne, calcule la covariance, trie les vecteurs propres et stocke les composants principaux. La méthode 'transform' applique ensuite cette transformation aux nouvelles données. L'orateur parcourt chaque étape du code, soulignant l'importance de la soustraction des moyens et du tri des vecteurs propres, et finalement de la sortie des composants principaux pour la réduction de la dimensionnalité.
  
  
• 00: 10: 00 Dans cette section, l'orateur montre comment implémenter PCA (Principal Component Analysis) à partir de zéro en Python. Ils commencent par créer une classe avec une méthode d'ajustement et de transformation. La méthode d'ajustement calcule d'abord la moyenne des données et la centre autour de la moyenne. Ensuite, il calcule les covariances des données et extrait les vecteurs propres et les valeurs propres. La méthode de transformation projette ensuite les données sur les composantes principales avec un produit scalaire. Enfin, l'intervenant teste l'implémentation avec le jeu de données Iris et réussit à réduire la dimensionnalité des données de quatre à deux dimensions.

[MetaQuotes]

Comment implémenter Perceptron à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/08%20Perceptron

Comment implémenter Perceptron à partir de zéro avec Python

Le didacticiel vidéo explique la théorie derrière l'algorithme Perceptron, qui ne peut apprendre que des modèles linéairement séparables pour la classification binaire à l'aide d'une fonction d'activation, de pondérations et d'une entrée. Le présentateur décrit ensuite les étapes nécessaires pour implémenter le modèle Perceptron à partir de zéro en Python en sélectionnant le taux d'apprentissage et le nombre d'itérations pour l'algorithme d'optimisation et en définissant la fonction d'activation comme fonction d'étape unitaire. Après avoir initialisé les poids et les biais, le modèle apprend à partir des données d'apprentissage en mettant à jour les poids et les biais selon la règle de mise à jour Perceptron. Enfin, le présentateur évalue la précision du modèle en prédisant les étiquettes de classe pour les données de test, et la précision s'avère être de 100 %, indiquant un apprentissage réussi de la limite de décision.

• 00:00:00 Dans cette section, le présentateur explique la théorie de base de l'algorithme Perceptron et en quoi il s'agit d'un algorithme d'apprentissage supervisé de classificateurs binaires. Le Perceptron est un modèle simplifié d'un neurone biologique et est également connu comme le prototype des réseaux de neurones. L'algorithme Perceptron ne peut apprendre que des modèles linéairement séparables, et il peut être considéré comme une seule unité d'un réseau de neurones artificiels. Le présentateur explique ensuite la représentation mathématique du Perceptron, qui comprend les poids, l'entrée et la fonction d'activation, ainsi que les étiquettes de classe de classificateur binaire. La vidéo explique ensuite la règle de mise à jour Perceptron, qui permet à l'algorithme de mettre à jour les poids et les biais pour les pousser vers la classe cible positive ou négative en cas d'erreur de classification.
  
  
• 00:05:00 Dans cette section, l'orateur décrit les étapes pour implémenter un modèle perceptron à partir de zéro en Python. Ils commencent par sélectionner le taux d'apprentissage et le nombre d'itérations de l'algorithme d'optimisation. Ensuite, la fonction d'activation est stockée en tant que fonction de pas d'unité. Les poids et les biais sont initialisés à aucun au début et le code passe ensuite aux fonctions d'ajustement et de prédiction. Pour la fonction d'ajustement, le nombre d'échantillons et le nombre de caractéristiques sont obtenus à partir des données d'apprentissage, puis les poids et les biais sont initialisés. Les étiquettes de classe sont ajustées pour être 1 ou 0. Ensuite, l'optimisation est effectuée lorsque la sortie linéaire est calculée pour chaque entrée. Enfin, la fonction de prédiction est implémentée là où le modèle linéaire et la fonction d'activation sont utilisés pour calculer la sortie prédite pour les données de test.
  
  
• 00:10:00 Dans cette section, le présentateur explique l'implémentation du perceptron à partir de zéro avec Python. La règle de mise à jour pour le perceptron est delta w = alpha fois y moins y chapeau fois x et le biais delta est alpha fois y moins y chapeau. Le présentateur utilise ensuite cette règle pour mettre à jour les pondérations et le biais en fonction des parties de mise à jour. Après avoir expliqué la méthode d'ajustement, le présentateur passe à la méthode de prédiction, où la sortie linéaire est calculée puis passée à travers la fonction d'activation pour obtenir y prédit. Enfin, le présentateur teste cette implémentation à l'aide d'une fonction d'assistance pour la précision et les ensembles de données créent des blobs avec 150 échantillons et deux caractéristiques, créant un perceptron avec un taux d'apprentissage et un nombre d'itérations, l'ajustant avec des données d'apprentissage et prédisant avec des données de test. La précision s'avère être de 100%, indiquant un apprentissage réussi de la frontière de décision.

[MetaQuotes]

Comment implémenter SVM (Support Vector Machine) à partir de zéro avec Python

Code : https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/09%20SVM

Comment implémenter SVM (Support Vector Machine) à partir de zéro avec Python

Les machines à vecteurs de support (SVM) visent à trouver une frontière de décision linéaire qui maximise la séparation entre les classes, le poids étant appris pendant la formation. La fonction de coût implique une perte charnière déterminant à quelle distance nous sommes du bon côté de la frontière de décision, avec un terme de régularisation ajouté au compromis minimisant la perte et maximisant la distance. Les gradients sont calculés, les règles de mise à jour dérivées et les poids initialisés, tandis que la fonction de prédiction est la sortie de la fonction linéaire. Le code pour implémenter SVM à partir de zéro en Python à l'aide des bibliothèques NumPy et Scikit-learn est fourni, y compris le test et la division du train d'importation, les ensembles de données et le traçage de la limite de décision et des deux hyperplans confirmant une implémentation précise.

• 00:00:00 Dans cette section, la vidéo traite des machines à vecteurs de support (SVM), qui visent à trouver une limite de décision linéaire ou un hyperplan qui offre une séparation maximale entre les classes. L'hyperplan doit avoir la plus grande marge par rapport aux points ou vecteurs de support les plus proches, le poids (w) étant ce qui doit être appris pendant l'entraînement. Une fonction de perte est définie, qui implique une perte charnière qui détermine à quelle distance nous sommes du bon côté de la frontière de décision. Un terme de régularisation est ajouté à la fonction de coût pour faire un compromis entre la minimisation de la perte et la maximisation de la distance aux deux côtés, avec un paramètre Lambda contrôlant l'importance desdites parties dans la fonction de coût.
  
  
• 00: 05: 00 Dans cette section, le processus de recherche des pondérations et du biais pour SVM est discuté. Le calcul des gradients est expliqué et les règles de mise à jour sont dérivées du gradient. L'initialisation des poids est également démontrée. Les étiquettes de classe sont mises à jour pour avoir des valeurs de -1 ou 1, et les règles de mise à jour sont appliquées pour le nombre d'itérations spécifié. La fonction de prédiction est simplement la sortie de la fonction linéaire que nous obtenons à partir des poids appris. En comparant la sortie avec zéro, nous pouvons décider de la classe de l'échantillon de test donné. Le code de SVM est écrit en Python à l'aide des bibliothèques NumPy et Scikit-learn.
  
  
• 00:10:00 Dans cette section, le présentateur explique comment écrire un code python pour implémenter SVM à partir de zéro. La méthode se compose de deux parties, les méthodes d'ajustement et de prédiction. La méthode d'ajustement est notre formation, qui calcule les poids à partir des données données, tandis que la méthode de prédiction utilise les poids pour prédire la sortie en se rapprochant des données données. Le présentateur explique en outre les mises à jour du code selon différents gradients, qui dépendent de la condition. La condition y fois W fois x moins B doit être supérieure ou égale à un, que nous utilisons avec numpy dot pour vérifier. Le code suit avec le test d'importation de train, la division et les ensembles de données de sklearn et matplotlib, et crée un exemple d'ensemble de données avec deux blobs d'ensembles de données avec deux fonctionnalités, puis s'assure que les classes sont -1 et plus un, divisées en ensembles d'entraînement et de test, et exécutez svm pour prédire la précision. Le présentateur décrit également le code pour tracer la limite de décision et les deux hyperplans à plus un et moins un, ce qui confirme une mise en œuvre précise.