Zestaw narzędzi języka naturalnego - zamiana słów

Stemming i lematyzacja mogą być traktowane jako rodzaj kompresji językowej. W tym samym sensie zamianę słów można traktować jako normalizację tekstu lub korektę błędów.

Ale dlaczego potrzebowaliśmy zamiany słów? Załóżmy, że jeśli mówimy o tokenizacji, oznacza to, że występują problemy ze skurczami (np. Nie mogę, nie chce, itp.). Tak więc, aby poradzić sobie z takimi problemami, potrzebujemy zamiany słów. Na przykład możemy zastąpić skurcze ich rozszerzonymi formami.

Zamiana słów za pomocą wyrażenia regularnego

Najpierw zamienimy słowa pasujące do wyrażenia regularnego. Ale do tego musimy mieć podstawową wiedzę na temat wyrażeń regularnych, a także modułu Python re. W poniższym przykładzie zastąpimy skrócenie ich rozszerzonymi formami (np. „Nie mogę” zostanie zastąpione „nie może”), a wszystko to za pomocą wyrażeń regularnych.

Przykład

Najpierw zaimportuj niezbędny pakiet do pracy z wyrażeniami regularnymi.

import re
from nltk.corpus import wordnet

Następnie zdefiniuj wybrane wzorce zastępcze w następujący sposób -

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

Teraz utwórz klasę, której można użyć do zamiany słów -

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

Zapisz ten program w Pythonie (powiedzmy repRE.py) i uruchom go z wiersza poleceń Pythona. Po uruchomieniu zaimportuj klasę REReplacer, jeśli chcesz zamienić słowa. Zobaczmy, jak to zrobić.

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'

Kompletny przykład wdrożenia

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

Teraz, po zapisaniu powyższego programu i uruchomieniu go, możesz zaimportować klasę i używać jej w następujący sposób -

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

Wynik

'I will not do it'

Wymiana przed przetwarzaniem tekstu

Jedną z powszechnych praktyk podczas pracy z przetwarzaniem języka naturalnego (NLP) jest czyszczenie tekstu przed jego przetworzeniem. W tym względzie możemy również skorzystać z naszegoREReplacer klasę utworzoną powyżej w poprzednim przykładzie, jako wstępny krok przed przetwarzaniem tekstu, czyli tokenizacją.

Przykład

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

W powyższej recepturze Pythona możemy łatwo zrozumieć różnicę między wyjściem tokenizera słów bez i przy użyciu zastępowania wyrażeń regularnych.

Usunięcie powtarzających się znaków

Czy w naszym codziennym języku posługujemy się ściśle gramatyką? Nie, nie jesteśmy. Na przykład czasami piszemy „Hiiiiiiiiiiii Mohan”, aby podkreślić słowo „Cześć”. Ale system komputerowy nie wie, że „Hiiiiiiiiiiii” jest odmianą słowa „Hi”. W poniższym przykładzie utworzymy klasę o nazwierep_word_removal których można użyć do usunięcia powtarzających się słów.

Przykład

Najpierw zaimportuj niezbędny pakiet do pracy z wyrażeniami regularnymi

import re
from nltk.corpus import wordnet

Teraz utwórz klasę, której można użyć do usuwania powtarzających się słów -

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

Zapisz ten program w języku Python (powiedzmy removerepeat.py) i uruchom go z wiersza poleceń Pythona. Po uruchomieniu zaimportujRep_word_removalklasy, gdy chcesz usunąć powtarzające się słowa. Zobaczmy jak?

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

Kompletny przykład wdrożenia

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

Teraz, po zapisaniu powyższego programu i uruchomieniu go, możesz zaimportować klasę i używać jej w następujący sposób -

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

Wynik

'Hi'