Boîte à outils en langage naturel - Remplacement de mots

La radicalisation et la lemmatisation peuvent être considérées comme une sorte de compression linguistique. Dans le même sens, le remplacement de mot peut être considéré comme une normalisation de texte ou une correction d'erreur.

Mais pourquoi avons-nous besoin d'un remplacement de mot? Supposons que si nous parlons de tokenisation, alors il y a des problèmes de contractions (comme ne peut pas, ne sera pas, etc.). Donc, pour gérer ces problèmes, nous avons besoin d'un remplacement de mot. Par exemple, nous pouvons remplacer les contractions par leurs formes développées.

Remplacement de mot à l'aide d'une expression régulière

Tout d'abord, nous allons remplacer les mots qui correspondent à l'expression régulière. Mais pour cela, nous devons avoir une compréhension de base des expressions régulières ainsi que du module python re. Dans l'exemple ci-dessous, nous remplacerons la contraction par leurs formes développées (par exemple «ne peut pas» sera remplacé par «ne peut pas»), tout cela en utilisant des expressions régulières.

Exemple

Tout d'abord, importez le package nécessaire pour travailler avec des expressions régulières.

import re
from nltk.corpus import wordnet

Ensuite, définissez les modèles de remplacement de votre choix comme suit -

R_patterns = [
   (r'won\'t', 'will not'),
   (r'can\'t', 'cannot'),
   (r'i\'m', 'i am'),
   r'(\w+)\'ll', '\g<1> will'),
   (r'(\w+)n\'t', '\g<1> not'),
   (r'(\w+)\'ve', '\g<1> have'),
   (r'(\w+)\'s', '\g<1> is'),
   (r'(\w+)\'re', '\g<1> are'),
]

Maintenant, créez une classe qui peut être utilisée pour remplacer des mots -

class REReplacer(object):
   def __init__(self, pattern = R_patterns):
      self.pattern = [(re.compile(regex), repl) for (regex, repl) in patterns]
   def replace(self, text):
      s = text
      for (pattern, repl) in self.pattern:
         s = re.sub(pattern, repl, s)
      return s

Enregistrez ce programme python (disons repRE.py) et exécutez-le à partir de l'invite de commande python. Après l'avoir exécuté, importez la classe REReplacer lorsque vous souhaitez remplacer des mots. Voyons comment.

from repRE import REReplacer
rep_word = REReplacer()
rep_word.replace("I won't do it")
Output:
'I will not do it'
rep_word.replace("I can’t do it")
Output:
'I cannot do it'

Exemple d'implémentation complet

import re
from nltk.corpus import wordnet
R_patterns = [
   (r'won\'t', 'will not'),
   (r'can\'t', 'cannot'),
   (r'i\'m', 'i am'),
   r'(\w+)\'ll', '\g<1> will'),
   (r'(\w+)n\'t', '\g<1> not'),
   (r'(\w+)\'ve', '\g<1> have'),
   (r'(\w+)\'s', '\g<1> is'),
   (r'(\w+)\'re', '\g<1> are'),
]
class REReplacer(object):
def __init__(self, patterns=R_patterns):
   self.patterns = [(re.compile(regex), repl) for (regex, repl) in patterns]
def replace(self, text):
   s = text
   for (pattern, repl) in self.patterns:
      s = re.sub(pattern, repl, s)
   return s

Maintenant, une fois que vous avez enregistré le programme ci-dessus et que vous l'avez exécuté, vous pouvez importer la classe et l'utiliser comme suit -

from replacerRE import REReplacer
rep_word = REReplacer()
rep_word.replace("I won't do it")

Production

'I will not do it'

Remplacement avant traitement de texte

L'une des pratiques courantes lorsque vous travaillez avec le traitement du langage naturel (NLP) consiste à nettoyer le texte avant le traitement de texte. Dans ce souci, nous pouvons également utiliser notreREReplacer classe créée ci-dessus dans l'exemple précédent, comme étape préliminaire avant le traitement de texte, c'est-à-dire la tokenisation.

Exemple

from nltk.tokenize import word_tokenize
from replacerRE import REReplacer
rep_word = REReplacer()
word_tokenize("I won't be able to do this now")
Output:
['I', 'wo', "n't", 'be', 'able', 'to', 'do', 'this', 'now']
word_tokenize(rep_word.replace("I won't be able to do this now"))
Output:
['I', 'will', 'not', 'be', 'able', 'to', 'do', 'this', 'now']

Dans la recette Python ci-dessus, nous pouvons facilement comprendre la différence entre la sortie du mot tokenizer sans et avec l'utilisation de l'expression régulière replace.

Suppression des caractères répétitifs

Sommes-nous strictement grammaticaux dans notre langage courant? Non nous ne sommes pas. Par exemple, nous écrivons parfois «Hiiiiiiiiiiii Mohan» pour souligner le mot «Hi». Mais le système informatique ne sait pas que «Hiiiiiiiiiiii» est une variante du mot «Salut». Dans l'exemple ci-dessous, nous allons créer une classe nomméerep_word_removal qui peut être utilisé pour supprimer les mots répétés.

Exemple

Tout d'abord, importez le package nécessaire pour travailler avec des expressions régulières

import re
from nltk.corpus import wordnet

Maintenant, créez une classe qui peut être utilisée pour supprimer les mots répétitifs -

class Rep_word_removal(object):
   def __init__(self):
      self.repeat_regexp = re.compile(r'(\w*)(\w)\2(\w*)')
      self.repl = r'\1\2\3'
   def replace(self, word):
      if wordnet.synsets(word):
      return word
   repl_word = self.repeat_regexp.sub(self.repl, word)
   if repl_word != word:
      return self.replace(repl_word)
   else:
      return repl_word

Enregistrez ce programme python (disons removerepeat.py) et exécutez-le à partir de l'invite de commande python. Après l'avoir exécuté, importezRep_word_removalclasse lorsque vous souhaitez supprimer les mots qui se répètent. Voyons comment?

from removalrepeat import Rep_word_removal
rep_word = Rep_word_removal()
rep_word.replace ("Hiiiiiiiiiiiiiiiiiiiii")
Output:
'Hi'
rep_word.replace("Hellooooooooooooooo")
Output:
'Hello'

Exemple d'implémentation complet

import re
from nltk.corpus import wordnet
class Rep_word_removal(object):
   def __init__(self):
      self.repeat_regexp = re.compile(r'(\w*)(\w)\2(\w*)')
      self.repl = r'\1\2\3'
   def replace(self, word):
      if wordnet.synsets(word):
         return word
   replace_word = self.repeat_regexp.sub(self.repl, word)
   if replace_word != word:
      return self.replace(replace_word)
   else:
      return replace_word

Maintenant, une fois que vous avez enregistré le programme ci-dessus et que vous l'avez exécuté, vous pouvez importer la classe et l'utiliser comme suit -

from removalrepeat import Rep_word_removal
rep_word = Rep_word_removal()
rep_word.replace ("Hiiiiiiiiiiiiiiiiiiiii")

Production

'Hi'