Guide de l'apprentissage en ligne et des algorithmes agressifs passifs

Introduction

Les données sont générées à un rythme sans précédent à partir de sources telles que les médias sociaux, les transactions financières et les plateformes de commerce électronique. Gérer ce flux continu d'informations est un défi, mais il offre la possibilité de prendre des décisions opportunes et précises. Les systèmes en temps réel, tels que les transactions financières, les assistants vocaux et les systèmes de surveillance de la santé, comptent sur le traitement continu des données afin de fournir des réponses pertinentes et à jour.

Les algorithmes d'apprentissage par lots tels que KNN, SVM et les arbres de décision nécessitent que l'ensemble de données soit chargé en mémoire pendant la formation. Lorsque vous travaillez avec d'énormes ensembles de données, cela devient de plus en plus peu pratique, conduisant à des problèmes de stockage et de mémoire importants. Ceux-ci sont également inefficaces lorsque vous travaillez avec des données en temps réel.

En raison de ce problème, nous avons besoin d'un algorithme à la fois efficace et précis lorsque nous traitons d'énormes quantités de données. Les algorithmes passifs-agressifs se distinguent à cet égard. Contrairement aux algorithmes d'apprentissage par lots, ils n'ont pas besoin d'être formés sur l'ensemble de données complet pour faire des prédictions. Les algorithmes passifs-agressifs apprennent des données à la volée, éliminant la nécessité de stocker ou de traiter l'ensemble de données en mémoire en mémoire.

Objectifs d'apprentissage

• L'apprentissage en ligne et sa signification lorsqu'ils travaillent avec d'énormes volumes de données.
• Différence entre l'apprentissage en ligne et les algorithmes d'apprentissage par lots.
• Intuition mathématique derrière des algorithmes passifs-agressifs.
• Différents hyperparamètres et leur signification dans les algorithmes passifs-agressifs.
• Applications et cas d'utilisation d'algorithmes passifs-agressifs.
• Limites et défis des algorithmes passifs-agressifs.
• Implémentation d'un classificateur passif-agressif dans Python pour détecter le discours de haine à partir des données Reddit en temps réel.

Cet article a été publié dans le cadre du Blogathon de la science des données.

Table des matières

• Qu'est-ce que l'apprentissage en ligne?
  • Avantages de l'apprentissage en ligne dans les applications en temps réel
• Introduction aux algorithmes passifs-agressifs
• Rôle de la perte de charnière dans l'apprentissage passif-agressif
• Formulation mathématique des algorithmes passifs agressifs
  • Comprendre le paramètre d'agressivité (c)
• Impact de la régularisation dans les algorithmes passifs-agressifs
• Applications en temps réel des algorithmes passifs-agressifs
• Limitations et défis
• Construire un modèle de détection de discours de haine
  • Configuration de votre environnement pour le traitement des données en temps réel
  • Configurez le modèle Bert pré-entraîné pour l'étiquetage
• Questions fréquemment posées

Qu'est-ce que l'apprentissage en ligne?

L'apprentissage en ligne, également connu sous le nom d'apprentissage incrémentiel, est un paradigme d'apprentissage automatique où le modèle se met à jour progressivement avec chaque nouveau point de données plutôt que d'être formé sur un ensemble de données fixe à la fois. Cette approche permet au modèle de s'adapter en continu aux nouvelles données, ce qui les rend particulièrement utiles dans des environnements dynamiques où les données évoluent au fil du temps. Contrairement aux méthodes d'apprentissage par lots traditionnelles, l'apprentissage en ligne permet les mises à jour en temps réel et la prise de décision en traitant de nouvelles informations à leur arrivée.

Batch vs apprentissage en ligne: un aperçu comparatif

Examinons la comparaison par lots par rapport à l'apprentissage en ligne ci-dessous:

Apprentissage par lots:

• Méthode de formation: les algorithmes d'apprentissage par lots s'entraînent sur un ensemble de données fixe à la fois. Une fois formé, le modèle est utilisé pour les prédictions jusqu'à ce qu'il soit recyclé avec de nouvelles données.
• Exemples: réseaux de neurones, machines à vecteurs de support (SVM), voisins K-Dearest (KNN).
• Défis: le recyclage nécessite le traitement de l'ensemble de données à partir de zéro, ce qui peut prendre du temps et coûteux en calcul. Cela est particulièrement difficile avec les ensembles de données importants et croissants, car le recyclage peut prendre des heures même avec des GPU puissants.

Apprentissage en ligne:

• Méthode de formation: les algorithmes d'apprentissage en ligne mettent à jour le modèle progressivement avec chaque nouveau point de données. Le modèle apprend en continu et s'adapte aux nouvelles données en temps réel.
• Avantages: Cette approche est plus efficace pour gérer de grands ensembles de données et des flux de données dynamiques. Le modèle est mis à jour avec un minimum de ressources de calcul, et les nouveaux points de données peuvent être traités rapidement sans avoir besoin de se recycler à partir de zéro.
• Applications: L'apprentissage en ligne est bénéfique pour les applications nécessitant une prise de décision en temps réel, comme l'analyse boursière, les flux de médias sociaux et les systèmes de recommandation.

Avantages de l'apprentissage en ligne dans les applications en temps réel

• Adaptation continue: les modèles d'apprentissage en ligne s'adaptent aux nouvelles données à mesure qu'ils arrivent, ce qui les rend idéaux pour les environnements où les modèles de données évoluent au fil du temps, comme dans les systèmes de détection de fraude. Cela garantit que le modèle reste pertinent et efficace sans avoir besoin de recyclage à partir de zéro.
• Efficacité: les algorithmes d'apprentissage en ligne ne nécessitent pas de recyclage complet avec l'ensemble de données, ce qui permet d'économiser du temps et des ressources de calcul significatifs. Ceci est particulièrement utile pour les applications avec une puissance de calcul limitée, comme les appareils mobiles.
• Gestion des ressources: En traitant les données progressivement, les modèles d'apprentissage en ligne réduisent le besoin d'un espace de stockage étendu. Les anciennes données peuvent être rejetées après avoir été traitées, ce qui aide à gérer efficacement le stockage et maintient le système léger.
• Prise de décision en temps réel: l'apprentissage en ligne permet des mises à jour en temps réel, ce qui est crucial pour les applications qui s'appuient sur des informations à jour, telles que les systèmes de recommandation ou le trading d'actions en temps réel.

Introduction aux algorithmes passifs-agressifs

L'algorithme passif-agressif a été introduit pour la première fois par Crammer et.al. En 2006, par le biais de leur article intitulé «Algorithmes passifs-agressifs en ligne». Ces algorithmes relèvent de la catégorie d'apprentissage en ligne et sont principalement utilisés pour les tâches de classification. Ceux-ci sont efficaces de la mémoire car ils peuvent apprendre de chaque point de données progressivement, ajuster leurs paramètres, puis jeter les données de la mémoire. Cela rend les algorithmes passifs-agressifs particulièrement utiles lorsqu'ils traitent d'énormes ensembles de données et pour des applications en temps réel. De plus, sa capacité à s'adapter rapidement lui permet de bien performer dans des environnements dynamiques où la distribution des données peut changer avec le temps.

Vous vous demandez peut-être le nom inhabituel. Il y a une raison à cela. La partie passive de l'algorithme implique que si le point de données actuel est correctement classé, le modèle reste inchangé et préserve les connaissances acquises à partir des points de données précédents. La partie agressive, en revanche, indique que si une classification erronée se produit, le modèle ajustera considérablement ses poids pour corriger l'erreur.

Pour mieux comprendre le fonctionnement de l'algorithme PA, visualisons son comportement dans le contexte de la classification binaire. Imaginez que vous avez un ensemble de points de données, chacun appartenant à l'une des deux classes. L'algorithme PA vise à trouver un hyperplan de séparation qui divise les points de données en leurs classes respectives. L'algorithme commence par une supposition initiale pour l'hyperplan. Lorsqu'un nouveau point de données est mal classé, l'algorithme met à jour agressivement l'hyperplan actuel pour s'assurer que le nouveau point de données est correctement classé. D'un autre côté, lorsque le point de données est correctement classé, aucune mise à jour de l'hyperplan n'est requise.

Rôle de la perte de charnière dans l'apprentissage passif-agressif

L'algorithme passif-agressif utilise la perte de charnière comme fonction de perte et est l'un des principaux éléments constitutifs de l'algorithme. C'est pourquoi il est crucial de comprendre le fonctionnement de la perte de charnière avant de nous plonger dans l'intuition mathématique derrière l'algorithme.

La perte de charnière est largement utilisée dans l'apprentissage automatique, en particulier pour les classificateurs de formation tels que les machines à vecteurs de support (SVM).

Définition de la perte de charnière

Il est défini comme:

• w est le vecteur de poids du modèle
• xi est le vecteur de fonctionnalité du i-tème point de données
• Yi est la véritable étiquette du i-tème point de données, qui peut être 1 ou -1 en cas de classification binaire.

Prenons le cas d'un problème de classification binaire où l'objectif est de différencier deux classes de données. L'algorithme PA vise implicitement à maximiser la marge entre la limite de décision et les points de données. La marge est la distance entre un point de données et la ligne de séparation / hyperplan. Ceci est très similaire au fonctionnement du classificateur SVM, qui utilise également la perte de charnière comme fonction de perte. Une marge plus grande indique que le classificateur est plus confiant dans sa prédiction et peut distinguer avec précision les deux classes. Par conséquent, l'objectif est d'atteindre une marge d'au moins 1 le plus souvent possible.

Comprendre l'équation

Décomposons cela plus loin et voyons comment l'équation aide à atteindre la marge maximale:

• W · xi: Il s'agit du produit DOT du vecteur de poids W et du point de données XI. Il représente le degré de confiance dans la prédiction du classificateur.
• yi * (w · xi): il s'agit du score signé ou de la marge du classificateur, où le signe est déterminé par la véritable étiquette Yi . Une valeur positive signifie que le classificateur a prédit l'étiquette correcte, tandis qu'une valeur négative signifie qu'elle a prédit la mauvaise étiquette.
• 1 - yi * (w · xi) : Cela mesure la différence entre la marge souhaitée (1) et la marge réelle.
• max (0, 1 - yi * (w · xi)): lorsque la marge est d'au moins 1, la perte est égale à zéro. Sinon, la perte augmente linéairement avec le déficit de marge.

Pour le dire simplement, la perte de charnière pénalise des classifications incorrectes ainsi que des classifications correctes qui ne sont pas suffisamment confiantes. Lorsqu'un point de données est correctement classé avec au moins une marge unitaire, la perte est nulle. Sinon, si le point de données est dans la marge ou mal classé, la perte augmente linéairement avec la distance de la marge.

Formulation mathématique des algorithmes passifs agressifs

Le fondement mathématique du classificateur agressif passif tourne autour du maintien d'un vecteur de poids w qui est mis à jour en fonction de l'erreur de classification des points de données entrants. Voici un aperçu détaillé de l'algorithme:

Étant donné un ensemble de données:

Étape 1: Initialiser un vecteur de poids w

Étape2: Pour chaque nouveau point de données (xi, yi), où xiis le vecteur de fonctionnalité et yi est la véritable étiquette, l'étiquette prévue ŷ_iis calculée comme:

Étape 3: Calculez la perte de charnière

• Si l'étiquette prévue ŷ_i est correcte et que la marge est d'au moins 1, la perte est de 0.
• Sinon, la perte est la différence entre 1 et la marge.

Étape 4: Ajustez le vecteur de poids W en utilisant la règle de mise à jour suivante

Pour chaque point de données x_i, si l (w; (x_i, y_i))> 0 (marge mal classifiée ou insuffisante):

Le vecteur de poids mis à jour w_t 1 est donné comme:

Si l (w; (x_i, y_i)) = 0 (correctement classé avec une marge suffisante):

Ensuite, le vecteur de poids reste inchangé:

Notez que ces équations émergent après avoir résolu un problème d'optimisation contraint avec l'objectif d'obtenir une hyperplan de marge maximale entre les classes. Ceux-ci proviennent du document de recherche original et la dérivation de ceux-ci dépasse le cadre de cet article.

Ces deux équations de mise à jour sont le cœur de l'algorithme passif-agressif. La signification de ceux-ci peut être comprise en termes plus simples. D'une part, la mise à jour nécessite la nouvelle valeur de poids (W_T 1) pour classer correctement l'exemple actuel avec une marge suffisamment importante et donc des progrès sont réalisés. D'un autre côté, il doit rester le plus près possible du poids plus ancien (W_T) afin de conserver les informations apprises sur les tours précédents.

Comprendre le paramètre d'agressivité (c)

Le paramètre d'agressivité C est l'hyperparamètre le plus important de l'algorithme passif-agressif. Il régit à quel point l'algorithme met agressivement à jour ses poids lorsqu'une classification erronée se produit.

Une valeur C élevée conduit à des mises à jour plus agressives, ce qui entraîne un apprentissage plus rapide, mais aussi d'augmenter le risque de sur-ajustement. L'algorithme pourrait devenir trop sensible au bruit et aux fluctuations des données. D'un autre côté, une faible valeur de C conduit à des mises à jour moins agressives, ce qui rend l'algorithme plus robuste au bruit et aux valeurs aberrantes. Cependant, dans ce cas, il est lent de s'adapter aux nouvelles informations, en ralentissant le processus d'apprentissage.

Nous voulons que l'algorithme apprenne progressivement à partir de chaque nouvelle instance tout en évitant les échantillons bruyants. En conséquence, nous devons nous efforcer de trouver un équilibre entre les deux, ce qui nous permet de faire des mises à jour importantes tout en maintenant la stabilité du modèle et en empêchant la sur-ajustement. La plupart du temps, la valeur optimale de C dépend de l'ensemble de données spécifique et du compromis souhaité entre la vitesse d'apprentissage et la robustesse. Dans les scénarios pratiques, des techniques telles que la validation croisée sont utilisées pour arriver à une valeur optimale de C.

Impact de la régularisation dans les algorithmes passifs-agressifs

Les ensembles de données du monde réel contiennent presque toujours un certain degré de bruit ou d'irrégularités. Un point de données mal étiqueté peut amener l'algorithme PA à changer radicalement son vecteur de poids dans la mauvaise direction. Cet exemple unique mal étiqueté peut entraîner plusieurs erreurs de prédiction sur les cycles ultérieurs, ce qui a un impact sur la fiabilité du modèle.

Pour y remédier, il existe un hyperparamètre plus important qui aide à rendre l'algorithme plus robuste au bruit et aux valeurs aberrantes dans les données. Il a tendance à utiliser des mises à jour de poids plus douces dans le cas de la classification erronée. Ceci est similaire à la régularisation. L'algorithme est divisé en deux variantes en fonction du paramètre de régularisation, connu sous le nom de PA-I et PA-II.

Ceux-ci diffèrent principalement dans la définition de la variable de taille de pas τ (également connue sous le nom de perte normalisée) . Pour PA-I, la perte est plafonnée à la valeur du paramètre d'agressivité C.

La formule est donnée comme suit:

Pour PA-II, la taille de pas ou la perte normalisée peut être écrite comme:

Dans la mise en œuvre de Sklearn du classificateur agressif passif, ce paramètre de régularisation est considéré comme la perte. Cela peut être défini sur l'une des deux valeurs en fonction de laquelle des deux PA-I et PA-II que nous voulons utiliser. Si vous souhaitez utiliser la variante PA-I, alors la perte doit être définie sur «Hinge» autrement pour PA-II, la perte est définie sur «Hiled-Hiled».

La différence peut être énoncée en termes simples comme suit:

• PA-I est une variante plus agressive qui détend la contrainte de marge (la marge peut être inférieure à une), mais pénalise la perte linéairement en cas de prédictions incorrectes. Il en résulte un apprentissage plus rapide mais est plus sujet aux valeurs aberrantes que son homologue.
• PA-II est une variante plus robuste qui pénalise la perte quadratique, ce qui la rend plus résiliente aux données et abusives bruyantes. Dans le même temps, cela le rend plus conservateur en s'adaptant à la variance des données, ce qui entraîne un apprentissage plus lent.

Encore une fois, le choix entre ces deux dépend des caractéristiques spécifiques de votre ensemble de données. En pratique, il est souvent conseillé d'expérimenter les deux variantes avec des valeurs variables de C avant de choisir quelqu'un.

Applications en temps réel des algorithmes passifs-agressifs

L'apprentissage en ligne et les algorithmes passifs-agressifs ont un large éventail d'applications, du traitement des données en temps réel aux systèmes adaptatifs. Ci-dessous, nous examinons certaines des applications les plus percutantes de l'apprentissage en ligne.

Filtrage de spam

Le filtrage du spam est une application essentielle de la classification du texte où l'objectif est de faire la distinction entre le spam et les e-mails légitimes. La capacité de l'algorithme PA à apprendre progressivement est particulièrement bénéfique ici, car elle peut mettre à jour en permanence le modèle en fonction de nouvelles tendances de spam.

Analyse des sentiments

L'analyse des sentiments consiste à déterminer le sentiment exprimé dans un texte, comme un tweet ou une revue de produit. L'algorithme PA peut être utilisé pour construire des modèles qui analysent le sentiment en temps réel, en s'adaptant aux nouveaux argot, expressions et tendances du sentiment à mesure qu'ils émergent. Ceci est particulièrement utile dans la surveillance des médias sociaux et l'analyse des commentaires des clients, où les idées opportunes sont cruciales.

Détection de discours de haine

La détection de discours de haine est une autre application critique où l'algorithme PA peut être extrêmement utile. En apprenant progressivement de nouvelles instances de discours de haine, le modèle peut s'adapter à l'évolution des modèles et des contextes de langage. Ceci est vital pour maintenir l'efficacité des outils de modération automatisés sur des plates-formes comme Twitter, Facebook et Reddit, assurant un environnement en ligne plus sûr et plus inclusif.

Détection de fraude

Les institutions financières et les services en ligne surveillent en permanence les transactions et le comportement des utilisateurs afin de détecter des activités frauduleuses. La capacité de l'algorithme PA à mettre à jour son modèle à chaque nouvelle transaction aide à identifier les modèles de fraude à mesure qu'ils émergent, fournissant une forte défense contre l'évolution des tactiques frauduleuses.

Analyse boursière

Les cours des actions sur les marchés financiers sont très dynamiques, ce qui nécessite des modèles pour répondre rapidement aux nouvelles informations. Les algorithmes d'apprentissage en ligne peuvent être utilisés pour prévoir et analyser les cours des actions en apprenant progressivement de nouvelles données de marché, ce qui entraîne des prévisions opportunes et précises qui profitent aux traders et aux investisseurs.

Systèmes de recommandation

Les algorithmes d'apprentissage en ligne peuvent également être utilisés dans les systèmes de recommandation à grande échelle pour mettre à jour dynamiquement les recommandations en fonction des interactions utilisateur. Cette adaptabilité en temps réel garantit que les recommandations restent pertinentes et personnalisées à mesure que les préférences des utilisateurs changent.

Ce sont certains des domaines où les algorithmes d'apprentissage en ligne brillent vraiment. Cependant, leurs capacités ne se limitent pas à ces zones. Ceux-ci sont également applicables dans une variété d'autres domaines, notamment la détection des anomalies, le diagnostic médical et la robotique.

Limitations et défis

Bien que l'apprentissage en ligne et les algorithmes passifs-agressifs offrent des avantages à gérer les données en streaming et à l'adaptation pour changer rapidement, ils présentent également des inconvénients. Certaines des principales limitations sont:

• Les algorithmes passifs-agressifs traitent les données des données séquentiellement, ce qui les rend plus sensibles aux points de données bruyants ou erronés. Une seule valeur aberrante peut avoir un effet disproportionné sur l'apprentissage du modèle, entraînant des prédictions inexactes ou des modèles biaisés.
• Ces algorithmes ne voient qu'une seule instance de données à la fois, ce qui limite leur compréhension de la distribution globale des données et des relations entre les différents points de données. Cela rend difficile d'identifier les modèles complexes et de faire des prédictions précises.
• Étant donné que les algorithmes de PA apprennent des flux de données en temps réel, ils peuvent sur-adapter les données les plus récentes, en négligeant ou en oubliant potentiellement les modèles observés dans les données antérieures. Cela peut entraîner de mauvaises performances de généralisation lorsque la distribution des données change dans le temps.
• Le choix de la valeur optimale du paramètre d'agressivité C peut être difficile et nécessite souvent une expérimentation. Une valeur élevée augmente l'agressivité conduisant à un sur-ajustement, tandis qu'une faible valeur peut entraîner un apprentissage lent.
• L'évaluation des performances de ces algorithmes est assez complexe. Étant donné que la distribution des données peut changer avec le temps, l'évaluation des performances du modèle sur un ensemble de tests fixe peut être incohérente.

Construire un modèle de détection de discours de haine

Les plateformes de médias sociaux comme Twitter et Reddit génèrent quotidiennement des quantités massives de données, ce qui les rend idéales pour tester notre compréhension théorique des algorithmes d'apprentissage en ligne.

Dans cette section, je vais démontrer un cas d'utilisation pratique en créant une application de détection de discours de haine à partir de zéro en utilisant des données en temps réel de Reddit. Reddit est une plate-forme bien connue pour sa communauté diversifiée. Cependant, il fait également face au défi des commentaires toxiques qui peuvent être blessants et abusifs. Nous allons construire un système qui peut identifier ces commentaires toxiques en temps réel à l'aide de l'API Reddit.

Dans ce cas, la formation d'un modèle avec toutes les données à la fois serait impossible en raison de l'énorme volume de données. De plus, les distributions et les modèles de données continuent de changer avec le temps. Par conséquent, nous avons besoin de l'aide d'algorithmes passifs-agressifs capables d'apprendre à partir de données à la volée sans les stocker en mémoire.

Configuration de votre environnement pour le traitement des données en temps réel

Avant de commencer à implémenter le code, vous devez d'abord configurer votre système. Pour utiliser l'API Reddit, vous devez d'abord créer un compte sur Reddit si vous n'en avez pas déjà. Ensuite, créez une application Reddit et obtenez vos clés API et autres informations d'identification pour l'authentification. Une fois ces étapes préalables effectuées, nous sommes prêts à commencer à créer notre modèle de détection de discours de haine.

Le flux de travail du code ressemblera à ceci:

• Connectez-vous à l'API Reddit à l'aide de la bibliothèque «Praw».
• Diffusez les données en temps réel et alimentez-les dans le modèle.
• Étiquetez les données à l'aide d'un modèle BERT affiné pour la tâche de détection de la parole de haine.
• Former le modèle à l'aide du classificateur agressif passif.
• Testez notre modèle sur un ensemble de données de test invisible et mesurez les performances.

Installer les bibliothèques requises

La première étape consiste à installer les bibliothèques requises.

 PIP Installer Praw Scikit-Learn NLTK Transformers Torch Matplotlib SeaBorn OpenDatasets

Pour travailler avec Reddit, nous avons besoin de la bibliothèque «Praw» qui est l'emballage API Reddit. Nous avons également besoin de «NLTK» pour le traitement du texte, «Scikit-Learn» pour l'apprentissage automatique, `Matplotlib» et «Seaborn» pour les visualisations, les `` Transformers »et« Torch »pour créer des incorporations de mots et charger le modèle BERT affiné et` `OpenDataset» pour charger des données à partir de la boue.

Importer des bibliothèques et configurer l'API Reddit

Dans l'étape suivante, nous importons toutes les bibliothèques nécessaires et configurons une connexion à l'API Reddit à l'aide de `Praw`. Cela nous aidera à diffuser les commentaires de SubredDits.

 Importer RE
PRAWS IMPORT
Importer une torche
Importer NLTK
Importer Numpy comme NP
Importer des pandas en tant que PD
Importer Matplotlib.pyplot en tant que plt
Importer Seaborn comme SNS
Importer des opendaSets comme OD
à partir de mots d'arrêt d'importation nltk.corpus
de sklearn.feature_extraction.Text import tfidfvectorizer
De Sklearn.Linear_Model Importer passiveggressIveclassifier
De Sklearn.Metrics Import précision_score, confusion_matrix, classification_report
de sklearn.model_selection import train_test_split
De Transformers Import Automodel, AutomodelOorsequenceClassification, Autotokenizer
à partir des transformateurs import bertforsequenceclassification, berttokenizer, textClassificationPipeline

# Références API Reddit
Reddit_client_id = {your_client_id}
Reddit_client_secret = {your_client_secret}
Reddit_user_agent = {your_user_agent}

# Configurer la connexion API Reddit
reddit = prew.reddit (client_id = reddit_client_id,
                     client_secret = reddit_client_secret,
                     user_agent = reddit_user_agent)

Pour configurer avec succès une instance Reddit, remplacez simplement les espaces réservés ci-dessus par vos informations d'identification et vous êtes prêt à partir.

Nettoyez et préparez le texte

Lorsque vous traitez des données de texte brutes, il est courant d'avoir des exemples contenant des symboles, des hashtags, des mots d'argot, etc. Comme ceux-ci ne sont aucune utilisation pratique de notre modèle, nous devons d'abord nettoyer le texte afin de les supprimer.

 # Télécharger les mots d'arrêt
nltk.download ('stopwords')
stop_words = set (stopwords.words («anglais»))

# Nettoyez le texte et supprimez
Def Clean_text (texte):
    text = re.sub (r'http \ s | www \ s | https \ s ',' ', text, draps = re.Multiline)
    text = re.sub (r '\ @ \ w | \ #', '', texte)
    text = re.sub (r '\ w', '', text)
    text = re.sub (r '\ d', '', texte)
    text = re.sub (r '\ s', '', text)
    text = text.strip ()
    text = '' .join ([Word pour mot dans text.split () si word.lower () pas dans stop_words])
    RETOUR

Le code ci-dessus définit une fonction d'assistance qui prépare les commentaires en supprimant les mots indésirables, les caractères spéciaux et les URL.

Configurez le modèle Bert pré-entraîné pour l'étiquetage

Lorsque nous diffusons des commentaires bruts de Reddit, nous n'avons aucune idée si le commentaire est toxique ou non parce qu'il n'est pas étiqueté. Pour utiliser la classification supervisée, nous devons d'abord avoir étiqueté des données. Nous devons implémenter un système fiable et précis pour étiqueter les commentaires bruts entrants. Pour cela, nous utiliserions un modèle Bert affiné pour la détection de discours de haine. Ce modèle classera avec précision les commentaires dans les deux catégories.

 Model_path = "Junglelee / Bert-Toxic-Comment-classification"
tokenizer = berttokizer.from_pretrain (Model_path)
modèle = bertforsequenceclassification.from_pretrain (Model_path, num_labels = 2)

pipeline = textClassificationPipeline (modèle = modèle, tokenizer = tokenizer)

# Fonction d'assistance pour étiqueter le texte
Def prédire_hate_speech (texte):
    prédiction = pipeline (texte) [0] ['label']
    Retour 1 If Prediction == 'Toxic' else 0 # 1 pour toxique, 0 pour non toxique

Ici, nous utilisons la bibliothèque Transformers pour configurer le pipeline du modèle. Ensuite, nous définissons une fonction d'assistance pour prédire si le texte donné est toxique ou non toxique à l'aide du modèle Bert. Nous avons maintenant étiqueté des exemples pour alimenter notre modèle.

Convertir du texte en vecteurs à l'aide de Bert Embeddings

Comme notre classificateur ne fonctionnera pas avec les entrées de texte, celles-ci devraient d'abord être converties en une représentation vectorielle appropriée. Pour ce faire, nous utiliserons des incorporations de Bert pré-entraînées, qui convertiront notre texte en vecteurs qui pourront ensuite être transformés au modèle pour la formation.

 # Chargez le modèle Bert et le jetons pré-entraînés pour les intégres
Model_name = "Bert-Base-Snecald"
tokenizer = autotokenizer.from_pretrain (Model_name)
bert_model = automodel.from_pretraind (Model_name)
bert_model.eval ()  

# Fonction d'assistance pour obtenir des intégres Bert
def get_bert_embedding (texte):
    entrées = tokenizer (texte, return_tensers = 'pt', troncature = true, padding = true)
    avec torch.no_grad ():
        sorties = bert_model (** entrées)
    
    return sorties.last_hidden_state [:, 0 ,:]. Squeeze (). Numpy ()

Le code ci-dessus prend un morceau de texte, le tokenise à l'aide d'un tokenizer Bert, puis le passe à travers le modèle Bert pour extraire les incorporations de phrases. Le texte a maintenant été converti en vecteurs.

Diffusez les données Reddit en temps réel et entraînez le classificateur agressif passif-agressif

Nous sommes maintenant prêts à diffuser des commentaires en temps réel et à former notre classificateur pour détecter le discours de haine.

 # Fonction d'aide pour diffuser les commentaires à partir d'un subreddit
DEF Stream_Comments (Subreddit_name, Batch_Size = 100):
    subdreddit = reddit.subreddit (subdreddit_name)
    comment_stream = subdreddit.stream.comments ()
    
    lot = []
    pour commentaire dans comment_stream:
        essayer:
            # Nettoyez le texte entrant 
            comment_text = clean_text (comment.body)
            # Étiquetez le commentaire en utilisant le modèle Bert pré-entraîné
            Label = Predict_Hate_Speech (comment_text) 
            # Ajouter le texte et l'étiquette au lot actuel
            batch.append ((comment_text, étiquette))
            
            Si Len (lot)> = Batch_Size:
                rendement
                lot = []
                
        sauf exception comme e:
            print (f'error: {e} ')
 

# Spécifiez le nombre de tours de formation
Rounds = 10

# Spécifiez le subreddit
subdreddit_name = 'fitness'

# Initialiser le classificateur passif-agressif
CLF = PASSIVEAGGRESSIVECLASSIFIER (C = 0,1, perte = 'hinge', max_iter = 1, random_state = 37)


# Diffusion des commentaires et effectuer une formation incrémentielle
pour num_rounds, lot en énumération (stream_comments (subdreddit_name, batch_size = 100)):
    # Entraîner le classificateur pour un nombre souhaité de tours
    Si num_rounds == tours:
        casser
  
    # Séparez le texte et les étiquettes
    Batch_texts = [item [0] pour l'élément en lot]
    batch_labels = [item [1] pour l'élément en lot]
    
    # Convertissez le lot de textes en intégres Bert
    X_train_batch = np.array ([get_bert_embedding (texte) pour le texte dans batch_texts])
    y_train_batch = np.array (batch_labels)
    
    # Entraîner le modèle sur le lot actuel
    clf.partial_fit (x_train_batch, y_train_batch, classes = [0, 1])
    imprimer (f'Trainen sur le lot de {len (batch_texts)} échantillons. ')
    
imprimer («formation terminée»)

Dans le code ci-dessus, nous spécifions d'abord le Sandredit à partir duquel nous voulons diffuser des commentaires, puis initialiser notre classificateur PA avec 10 tours de formation. Nous diffusons ensuite des commentaires en temps réel. Pour chaque nouveau commentaire qui s'y trouve est d'abord nettoyé en supprimant les mots indésirables. Ensuite, il est étiqueté à l'aide du modèle Bert pré-entraîné et ajouté au lot actuel.

Nous initialisons notre classificateur passif-agressif en prenant C = 0,1 et Loss = 'Hinge' qui correspond à la version PA-I de l'algorithme. Pour chaque lot, nous formons notre classificateur à l'aide de la méthode `partial_fit () '. Cela permet au modèle d'apprendre progressivement à partir de chaque échantillon d'entraînement plutôt que de stocker le lot entier en mémoire avant le traitement. Ainsi, permettant au modèle de s'adapter constamment à de nouvelles informations, ce qui le rend idéal pour les applications en temps réel.

Évaluer les performances du modèle

J'utiliserai l'ensemble de données Toxic Toxgle Kaggle pour évaluer notre modèle. Cet ensemble de données contient plusieurs tweets qui sont classés comme toxiques ou non toxiques.

 # Télécharger les données de Kaggle
OD.Download ("https://www.kaggle.com/datasets/ashwiniyer176/toxic-tweets-dataset")
# Chargez les données
data = pd.read_csv ("toxic-tweets-dataset / finalBalancedDataset.csv", usecols = [1,2]) [["tweet", "toxicité"]]

# Séparez le texte et les étiquettes
test_data = data.sample (n = 100)
textes = test_data ['tweet']. Appliquer (clean_text)
libell = test_data ['toxicité']

# Convertir le texte en vecteurs
X_test = np.array ([get_bert_embedding (texte) pour le texte en textes])
y_test = np.array (étiquettes)

# Faire des prédictions
y_pred = clf.predict (x_test)

# Évaluer les performances du modèle
précision = précision_score (y_test, y_pred)
conf_matrix = confusion_matrix (y_test, y_pred)

Print ("Rapport de classification:")
print (classification_report (y_test, y_pred)))

# Tracer la matrice de confusion
Plt.Figure (FigSize = (7, 5))
sns.heatmap (conf_matrix, 
            annot = true, 
            fmt = 'd', 
            cmap = 'blues', 
            cbar = false, 
            xtickLabels = ["non toxique", "toxique"], 
            yTickLabels = ["non toxique", "toxique"])
            
plt.xLabel («Étiquettes prédites»)
plt.ylabel («True Labels»)
plt.title («Matrice de confusion»)
plt.show () 

Tout d'abord, nous avons chargé l'ensemble de tests et l'avons nettoyé avec la méthode `Clean_text` définie plus tôt. Le texte est ensuite converti en vecteurs à l'aide de Bert Embeddings. Enfin, nous faisons des prédictions sur l'ensemble de tests et évaluons les performances de notre modèle sur différentes mesures en utilisant le rapport de classification et la matrice de confusion.

Conclusion

Nous avons exploré la puissance des algorithmes d'apprentissage en ligne, en nous concentrant sur la capacité de l'algorithme passif-agressif à gérer efficacement les grands ensembles de données et à nous adapter aux données en temps réel sans nécessiter un recyclage complet. Et a également discuté du rôle de la perte de charnière, de l'hyperparamètre d'agressivité (C), et de la façon dont la régularisation aide à gérer le bruit et les valeurs aberrantes. Nous avons également examiné les applications et les limitations du monde réel avant de mettre en œuvre un modèle de détection de discours de haine pour Reddit en utilisant le classificateur passif-agressif. Merci d'avoir lu et j'attends avec impatience notre prochain tutoriel AI!

Questions fréquemment posées

Q1. Quel est le principe fondamental sous-jacent des algorithmes passifs-agressifs?

A. Le principe fondamental derrière l'algorithme agressif passif est de mettre à jour agressivement les poids lorsqu'une mauvaise prédiction est faite et de conserver passivement les poids apprises lorsqu'une prédiction correcte est faite.

Q2. Quel rôle le paramètre d'agressivité C joue-t-il dans l'algorithme PA?

A. Lorsque C est élevé, l'algorithme devient plus agressif, s'adaptant rapidement aux nouvelles données, ce qui entraîne un apprentissage plus rapide. Lorsque C est faible, l'algorithme devient moins agressif et fait des mises à jour plus petites. Cela réduit la probabilité de sur-ajustement à des échantillons bruyants, mais rend plus lent à s'adapter à de nouvelles instances.

Q3. Comment le classificateur passif-agressif est-il similaire à la machine de vecteur de support (SVM)?

A. Les deux visent à maximiser la marge entre la limite de décision et les points de données. Les deux utilisent la perte de charnière comme fonction de perte.

Q4. Quels sont les avantages des algorithmes d'apprentissage en ligne sur les algorithmes d'apprentissage par lots?

A. Les algorithmes d'apprentissage en ligne peuvent fonctionner avec d'énormes ensembles de données, n'ont aucune limitation de stockage et s'adapter facilement aux données changeantes rapidement sans avoir besoin de recyclage à partir de zéro.

Q5. Quels sont les scénarios du monde réel où des algorithmes agressifs passifs peuvent être utiles?

A. Les algorithmes passifs-agressifs peuvent être utilisés dans une variété d'applications, notamment le filtrage des spams, l'analyse des sentiments, la détection de la parole de haine, l'analyse boursière en temps réel et les systèmes de recommandation.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!