Natural Language Toolkit - Sostituzione delle parole

Lo stemming e la lemmatizzazione possono essere considerati una sorta di compressione linguistica. Allo stesso modo, la sostituzione delle parole può essere considerata come normalizzazione del testo o correzione degli errori.

Ma perché avevamo bisogno della sostituzione delle parole? Supponiamo che se parliamo di tokenizzazione, allora sta avendo problemi con le contrazioni (come non posso, non voglio, ecc.). Quindi, per gestire tali problemi, abbiamo bisogno della sostituzione delle parole. Ad esempio, possiamo sostituire le contrazioni con le loro forme espanse.

Sostituzione di parole utilizzando espressioni regolari

Innanzitutto, sostituiremo le parole che corrispondono all'espressione regolare. Ma per questo dobbiamo avere una conoscenza di base delle espressioni regolari e del modulo re python. Nell'esempio seguente, sostituiremo la contrazione con le loro forme espanse (ad esempio "non posso" sarà sostituito con "non posso"), tutto questo utilizzando espressioni regolari.

Esempio

Per prima cosa, importa il pacchetto necessario re per lavorare con le espressioni regolari.

import re
from nltk.corpus import wordnet

Successivamente, definisci i modelli di sostituzione di tua scelta come segue:

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

Ora, crea una classe che può essere utilizzata per sostituire le parole:

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

Salva questo programma python (ad esempio repRE.py) ed eseguilo dal prompt dei comandi di python. Dopo averlo eseguito, importa la classe REReplacer quando vuoi sostituire le parole. Vediamo come.

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'

Esempio di implementazione 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

Ora, una volta salvato il programma sopra ed eseguito, puoi importare la classe e usarla come segue:

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

Produzione

'I will not do it'

Sostituzione prima dell'elaborazione del testo

Una delle pratiche comuni quando si lavora con l'elaborazione del linguaggio naturale (PNL) è quella di ripulire il testo prima dell'elaborazione del testo. In questa preoccupazione possiamo anche usare il nostroREReplacer classe creata sopra nell'esempio precedente, come passaggio preliminare prima dell'elaborazione del testo, ovvero la tokenizzazione.

Esempio

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

Nella ricetta Python sopra, possiamo facilmente capire la differenza tra l'output di word tokenizer senza e con l'uso di sostituzione di espressioni regolari.

Rimozione di caratteri ripetuti

Siamo rigorosamente grammaticali nella nostra lingua di tutti i giorni? No non siamo. Ad esempio, a volte scriviamo "Hiiiiiiiiiiii Mohan" per enfatizzare la parola "Ciao". Ma il sistema informatico non sa che "Hiiiiiiiiiiii" è una variazione della parola "Hi". Nell'esempio seguente, creeremo una classe denominatarep_word_removal che può essere utilizzato per rimuovere le parole ripetute.

Esempio

Per prima cosa, importa il pacchetto necessario re per lavorare con le espressioni regolari

import re
from nltk.corpus import wordnet

Ora, crea una classe che può essere utilizzata per rimuovere le parole ripetute:

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

Salva questo programma python (ad esempio removalrepeat.py) ed eseguilo dal prompt dei comandi di python. Dopo averlo eseguito, importaRep_word_removalclasse quando si desidera rimuovere le parole ripetute. Vediamo come?

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

Esempio di implementazione 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

Ora, una volta salvato il programma sopra ed eseguito, puoi importare la classe e usarla come segue:

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

Produzione

'Hi'