Natural Language Toolkit - Wortersetzung

Stemming und Lemmatisierung können als eine Art sprachliche Kompression betrachtet werden. Im gleichen Sinne kann das Ersetzen von Wörtern als Textnormalisierung oder Fehlerkorrektur angesehen werden.

Aber warum brauchten wir einen Wortersatz? Angenommen, wenn wir über Tokenisierung sprechen, dann gibt es Probleme mit Kontraktionen (wie kann nicht, wird nicht usw.). Um solche Probleme zu lösen, müssen wir also ein Wort ersetzen. Zum Beispiel können wir Kontraktionen durch ihre erweiterten Formen ersetzen.

Wortersetzung mit regulären Ausdrücken

Zuerst werden wir Wörter ersetzen, die dem regulären Ausdruck entsprechen. Dafür müssen wir jedoch ein grundlegendes Verständnis der regulären Ausdrücke sowie des Python-Re-Moduls haben. Im folgenden Beispiel werden wir die Kontraktion durch ihre erweiterten Formen ersetzen (z. B. wird "nicht" durch "nicht" ersetzt), und dies alles durch die Verwendung regulärer Ausdrücke.

Beispiel

Importieren Sie zunächst das erforderliche Paket, um mit regulären Ausdrücken zu arbeiten.

import re
from nltk.corpus import wordnet

Definieren Sie als Nächstes die Ersatzmuster Ihrer Wahl wie folgt:

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'),
]

Erstellen Sie jetzt eine Klasse, die zum Ersetzen von Wörtern verwendet werden kann -

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

Speichern Sie dieses Python-Programm (z. B. repRE.py) und führen Sie es an der Python-Eingabeaufforderung aus. Importieren Sie nach dem Ausführen die REReplacer-Klasse, wenn Sie Wörter ersetzen möchten. Mal sehen wie.

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'

Vollständiges Implementierungsbeispiel

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

Nachdem Sie das obige Programm gespeichert und ausgeführt haben, können Sie die Klasse importieren und wie folgt verwenden:

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

Ausgabe

'I will not do it'

Ersatz vor der Textverarbeitung

Eine der gängigen Methoden bei der Arbeit mit der Verarbeitung natürlicher Sprache (NLP) besteht darin, den Text vor der Textverarbeitung zu bereinigen. In diesem Zusammenhang können wir auch unsere verwendenREReplacer Klasse, die oben im vorherigen Beispiel erstellt wurde, als vorläufiger Schritt vor der Textverarbeitung, dh Tokenisierung.

Beispiel

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']

Im obigen Python-Rezept können wir den Unterschied zwischen der Ausgabe des Wort-Tokenizers ohne und mit dem Ersetzen durch reguläre Ausdrücke leicht verstehen.

Entfernen von sich wiederholenden Zeichen

Sind wir in unserer Alltagssprache streng grammatikalisch? Nein, wir sind nicht. Zum Beispiel schreiben wir manchmal 'Hiiiiiiiiiiii Mohan', um das Wort 'Hi' hervorzuheben. Das Computersystem weiß jedoch nicht, dass 'Hiiiiiiiiiiii' eine Variation des Wortes "Hi" ist. Im folgenden Beispiel erstellen wir eine Klasse mit dem Namenrep_word_removal Dies kann zum Entfernen der sich wiederholenden Wörter verwendet werden.

Beispiel

Importieren Sie zunächst das erforderliche Paket, um mit regulären Ausdrücken zu arbeiten

import re
from nltk.corpus import wordnet

Erstellen Sie jetzt eine Klasse, mit der Sie die sich wiederholenden Wörter entfernen können.

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

Speichern Sie dieses Python-Programm (z. B. removerepeat.py) und führen Sie es an der Python-Eingabeaufforderung aus. Nach dem Ausführen importierenRep_word_removalKlasse, wenn Sie die sich wiederholenden Wörter entfernen möchten. Mal sehen wie?

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

Vollständiges Implementierungsbeispiel

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

Nachdem Sie das obige Programm gespeichert und ausgeführt haben, können Sie die Klasse importieren und wie folgt verwenden:

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

Ausgabe

'Hi'