de Praveen Dubey

O introducere în B.ag of Words și cum să îl codificați în Python pentru NLP

O introducere in Bag of Words si cum sa o
Plăci de scrabble albe și negre pe suprafața neagră de Pixabay

Bag of Words (BOW) este o metodă de extragere a caracteristicilor din documente text. Aceste caracteristici pot fi utilizate pentru antrenarea algoritmilor de învățare automată. Creează un vocabular al tuturor cuvintelor unice care apar în toate documentele din setul de instruire.

În termeni simpli, este o colecție de cuvinte pentru a reprezenta o propoziție cu numărul de cuvinte și, în general, ignorând ordinea în care apar.

ARC este o abordare utilizată pe scară largă cu:

  1. Prelucrarea limbajului natural
  2. Recuperarea informațiilor din documente
  3. Clasificări ale documentelor

La un nivel ridicat, implică pașii următori.

O introducere in Bag of Words si cum sa o

Vectorii generați pot fi introduși în algoritmul dvs. de învățare automată.

Să începem cu un exemplu de înțeles luând câteva propoziții și generând vectori pentru acestea.

Luați în considerare cele două propoziții de mai jos.

1. "John likes to watch movies. Mary likes movies too."
2. "John also likes to watch football games."

Aceste două propoziții pot fi reprezentate și cu o colecție de cuvinte.

1. ['John', 'likes', 'to', 'watch', 'movies.', 'Mary', 'likes', 'movies', 'too.']
2. ['John', 'also', 'likes', 'to', 'watch', 'football', 'games']

În plus, pentru fiecare propoziție, eliminați mai multe apariții ale cuvântului și utilizați numărul de cuvinte pentru a reprezenta acest lucru.

1. {"John":1,"likes":2,"to":1,"watch":1,"movies":2,"Mary":1,"too":1}
2. {"John":1,"also":1,"likes":1,"to":1,"watch":1,"football":1,   "games":1}

Presupunând că aceste propoziții fac parte dintr-un document, mai jos este frecvența combinată a cuvintelor pentru întregul nostru document. Ambele propoziții sunt luate în considerare.

 {"John":2,"likes":3,"to":2,"watch":2,"movies":2,"Mary":1,"too":1,  "also":1,"football":1,"games":1}

Vocabularul de mai sus din toate cuvintele dintr-un document, cu numărul lor de cuvinte, va fi folosit pentru a crea vectorii pentru fiecare dintre propoziții.

Lungimea vectorului va fi întotdeauna egală cu dimensiunea vocabularului. În acest caz, lungimea vectorului este 11.

Pentru a reprezenta propozițiile noastre originale într-un vector, fiecare vector este inițializat cu toate zerourile – [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Aceasta este urmată de iterație și comparație cu fiecare cuvânt din vocabularul nostru și creșterea valorii vectorului dacă propoziția are acel cuvânt.

John likes to watch movies. Mary likes movies too.[1, 2, 1, 1, 2, 1, 1, 0, 0, 0]
John also likes to watch football games.[1, 1, 1, 1, 0, 0, 0, 1, 1, 1]

De exemplu, în propoziția 1 cuvântul likes apare în poziția a doua și apare de două ori. Deci, al doilea element al vectorului nostru pentru propoziția 1 va fi 2: [1, 2, 1, 1, 2, 1, 1, 0, 0, 0]

Vectorul este întotdeauna proporțional cu dimensiunea vocabularului nostru.

Un document mare în care vocabularul generat este uriaș poate duce la un vector cu o mulțime de valori 0. Aceasta se numește a vector rar. Vectorii puțini necesită mai multă memorie și resurse de calcul la modelare. Numărul mare de poziții sau dimensiuni poate face procesul de modelare foarte dificil pentru algoritmii tradiționali.

Codificarea algoritmului nostru BOW

Intrarea în codul nostru va fi mai multe propoziții, iar ieșirea va fi vectorii.

Matricea de intrare este următoarea:

["Joe waited for the train", "The train was late", "Mary and Samantha took the bus",
"I looked for Mary and Samantha at the bus station",
"Mary and Samantha arrived at the bus station early but waited until noon for the bus"]

Pasul 1: Tokenizați o propoziție

Vom începe prin eliminarea cuvintelor opuse din propoziții.

Cuvinte cheie sunt cuvinte care nu conțin suficientă semnificație pentru a fi utilizate fără algoritmul nostru. Nu am vrea ca aceste cuvinte să ocupe spațiu în baza noastră de date sau să ocupe un timp valoros de procesare. Pentru aceasta, le putem elimina cu ușurință stocând o listă de cuvinte pe care le considerați cuvinte de oprire.

Tokenizarea este actul de a sparge o secvență de șiruri în bucăți, cum ar fi cuvinte, cuvinte cheie, fraze, simboluri și alte elemente numite jetoane. Jetoanele pot fi cuvinte individuale, fraze sau chiar propoziții întregi. În procesul de tokenizare, unele caractere precum semnele de punctuație sunt eliminate.

def word_extraction(sentence):    ignore = ['a', "the", "is"]    words = re.sub("[^w]", " ",  sentence).split()    cleaned_text = [w.lower() for w in words if w not in ignore]    return cleaned_text

Pentru o implementare mai robustă a cuvintelor stop, puteți utiliza python nltk bibliotecă. Are un set de cuvinte predefinite pe limbă. Iată un exemplu:

import nltkfrom nltk.corpus import stopwords set(stopwords.words('english'))

Pasul 2: aplicați tokenizarea tuturor propozițiilor

def tokenize(sentences):    words = []    for sentence in sentences:        w = word_extraction(sentence)        words.extend(w)            words = sorted(list(set(words)))    return words

Metoda itera toate propozițiile și adaugă cuvântul extras într-o matrice.

Rezultatul acestei metode va fi:

['and', 'arrived', 'at', 'bus', 'but', 'early', 'for', 'i', 'joe', 'late', 'looked', 'mary', 'noon', 'samantha', 'station', 'the', 'took', 'train', 'until', 'waited', 'was']

Pasul 3: Construiește vocabular și generează vectori

Utilizați metodele definite în pașii 1 și 2 pentru a crea vocabularul documentului și a extrage cuvintele din propoziții.

def generate_bow(allsentences):        vocab = tokenize(allsentences)    print("Word List for Document n{0} n".format(vocab));
for sentence in allsentences:        words = word_extraction(sentence)        bag_vector = numpy.zeros(len(vocab))        for w in words:            for i,word in enumerate(vocab):                if word == w:                     bag_vector[i] += 1                            print("{0}n{1}n".format(sentence,numpy.array(bag_vector)))

Iată introducerea și execuția definite a codului nostru:

allsentences = ["Joe waited for the train train", "The train was late", "Mary and Samantha took the bus",
"I looked for Mary and Samantha at the bus station",
"Mary and Samantha arrived at the bus station early but waited until noon for the bus"]
generate_bow(allsentences)

Vectorii de ieșire pentru fiecare dintre propoziții sunt:

Output:
Joe waited for the train train[0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 2. 0. 1. 0.]
The train was late[0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1.]
Mary and Samantha took the bus[1. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0.]
I looked for Mary and Samantha at the bus station[1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0.]
Mary and Samantha arrived at the bus station early but waited until noon for the bus[1. 1. 1. 2. 1. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 0. 0. 0. 1. 1. 0.]

După cum puteți vedea, fiecare propoziție a fost comparată cu lista noastră de cuvinte generate la Pasul 1. Pe baza comparației, valoarea elementului vector poate fi mărită. Acești vectori pot fi utilizați în algoritmi ML pentru clasificarea și predicțiile documentelor.

Ne-am scris codul și am generat vectori, dar acum să înțelegem mai mult sacul de cuvinte.

Prezentări despre sacul de cuvinte

Modelul BOW are în vedere numai dacă un cuvânt cunoscut apare sau nu într-un document. Nu-i pasă de sens, context și ordine în care apar.

Acest lucru oferă o perspectivă asupra faptului că documentele similare vor avea un număr de cuvinte similar unul cu celălalt. Cu alte cuvinte, cu cât cuvintele din două documente sunt mai asemănătoare, cu atât documentele pot fi mai asemănătoare.

Limitări ale ARCULUI

  1. Sens semantic: abordarea de bază BOW nu ia în considerare semnificația cuvântului din document. Ignoră complet contextul în care este folosit. Același cuvânt poate fi folosit în mai multe locuri pe baza contextului sau a cuvintelor din apropiere.
  2. Dimensiunea vectorului: Pentru un document mare, dimensiunea vectorului poate fi imensă, rezultând o mulțime de calcul și timp. Poate fi necesar să ignorați cuvintele pe baza relevanței pentru cazul dvs. de utilizare.

Aceasta a fost o mică introducere a metodei BOW. Codul a arătat cum funcționează la un nivel scăzut. Există mult mai multe de înțeles despre BOW. De exemplu, în loc să ne împărțim propoziția într-un singur cuvânt (1 gram), puteți împărți în perechea de două cuvinte (bi-gram sau 2-gram). Uneori, reprezentarea bi-gram pare să fie mult mai bună decât utilizarea unui gram. Acestea pot fi adesea reprezentate folosind notația N-gram. Am enumerat câteva lucrări de cercetare în secțiunea de resurse pentru cunoștințe mai aprofundate.

Nu trebuie să codificați ARC ori de câte ori aveți nevoie. Face deja parte din multe cadre disponibile, cum ar fi CountVectorizer în știința tehnică.

Codul nostru anterior poate fi înlocuit cu:

from sklearn.feature_extraction.text import CountVectorizervectorizer = CountVectorizer()X = vectorizer.fit_transform(allsentences)print(X.toarray())

Este întotdeauna bine să înțelegeți cum funcționează bibliotecile din cadre și să înțelegeți metodele din spatele lor. Cu cât înțelegeți mai bine conceptele, cu atât puteți folosi mai bine cadrele.

Vă mulțumim că ați citit articolul. Codul afișat este disponibil pe pagina mea GitHub.

Poți să mă urmărești mai departe Mediu, Stare de nervozitate, și LinkedIn, Pentru orice întrebări, puteți să mă contactați prin e-mail (praveend806 [at] gmail [dot] com).

Resurse pentru a citi mai multe despre sacul de cuvinte

  1. Wikipedia-ARC
  2. Înțelegerea modelului Bag-of-Words: un cadru statistic
  3. Modele și aplicații pentru păstrarea semanticii Bag-of-Words