Kit de ferramentas de linguagem natural - substituição de palavras

O stemming e a lematização podem ser considerados um tipo de compressão linguística. No mesmo sentido, a substituição de palavras pode ser considerada como normalização de texto ou correção de erros.

Mas por que precisamos de substituição de palavras? Suponha que se falamos sobre tokenização, então ele está tendo problemas com contrações (como não consigo, não vou, etc.). Portanto, para lidar com essas questões, precisamos substituir palavras. Por exemplo, podemos substituir as contrações por suas formas expandidas.

Substituição de palavras usando expressão regular

Primeiro, vamos substituir palavras que correspondem à expressão regular. Mas, para isso, devemos ter um conhecimento básico das expressões regulares, bem como do módulo python re. No exemplo abaixo, estaremos substituindo a contração por suas formas expandidas (por exemplo, “não posso” será substituído por “não posso”), tudo isso usando expressões regulares.

Exemplo

Primeiro, importe o pacote necessário para trabalhar com expressões regulares.

import re
from nltk.corpus import wordnet

Em seguida, defina os padrões de substituição de sua escolha da seguinte forma -

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

Agora, crie uma classe que pode ser usada para substituir palavras -

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

Salve este programa python (digamos repRE.py) e execute-o no prompt de comando python. Após executá-lo, importe a classe REReplacer quando quiser substituir palavras. Vamos ver como.

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'

Exemplo de implementação completo

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

Agora, depois de salvar o programa acima e executá-lo, você pode importar a classe e usá-la da seguinte maneira -

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

Resultado

'I will not do it'

Substituição antes do processamento do texto

Uma das práticas comuns ao trabalhar com processamento de linguagem natural (PNL) é limpar o texto antes de processá-lo. Nesse sentido, também podemos usar nossoREReplacer classe criada acima no exemplo anterior, como uma etapa preliminar antes do processamento de texto, ou seja, tokenização.

Exemplo

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

Na receita Python acima, podemos entender facilmente a diferença entre a saída do tokenizer de palavra sem e com o uso de substituição de expressão regular.

Remoção de caracteres repetidos

Nós estritamente gramaticais em nossa linguagem cotidiana? Não, nós não somos. Por exemplo, às vezes escrevemos 'Hiiiiiiiiiiii Mohan' para enfatizar a palavra 'Hi'. Mas o sistema de computador não sabe que 'Hiiiiiiiiiiii' é uma variação da palavra “Oi”. No exemplo abaixo, estaremos criando uma classe chamadarep_word_removal que pode ser usado para remover as palavras repetidas.

Exemplo

Primeiro, importe o pacote necessário para trabalhar com expressões regulares

import re
from nltk.corpus import wordnet

Agora, crie uma classe que pode ser usada para remover as palavras repetidas -

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

Salve este programa python (digamos, removerepeat.py) e execute-o no prompt de comando do python. Depois de executá-lo, importeRep_word_removalclasse quando você deseja remover as palavras repetidas. Vamos ver como?

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

Exemplo de implementação completo

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

Agora, depois de salvar o programa acima e executá-lo, você pode importar a classe e usá-la da seguinte maneira -

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

Resultado

'Hi'