Բնական լեզվի մշակման հիմունքներ

Ստեմինգ ընդդեմ լեմմատիզացիայի

Ե՛վ բխող, և՛ լեմմատիզացիան հեռացնում է շեղումը բառից: Այնուամենայնիվ, արմատավորումն առաջացնում է բառեր, որոնք չկան բառարանում, քանի որ այն չի օգտագործում խոսքի պիտակավորման որևէ մաս, բառապաշարներ և քերականական հարաբերություններ բառերի հետ, մինչդեռ. Լեմմատիզացիան քայլ առ քայլ օգտագործեք վերը նշված բոլոր գործընթացները և ստացեք ցանկալի բառ:

Լեմմատիզացիան ավելի դանդաղ է, բայց ավելի ճշգրիտ՝ ավելի նորմալացված կորպուս կառուցելիս:

Կան մի քանի Stemming մեթոդներ, բայց մենք պարզապես ցույց կտանք Porter Stemming-ի օրինակ այստեղ: Մեկ այլ հայտնի և ավելի ագրեսիվ ցողունային մոտեցում էLancaster Stemmingմոտեցումը: Սթեմինգի տարբեր մոտեցումների տարբերությունների մասին կխոսենք մեկ այլ հոդվածում։

Stop Words

Եկեք վերադառնանք երեխայի օրինակին: Այս սցենարում, եթե մենք սկսեինք չափազանց շատ եզակի բառեր արտասանել երեխայի առջև, նրան ավելի երկար կպահանջվեր կենտրոնանալու և հասկանալու համար, թե ինչպես կարելի է խոսել կարևոր բառեր, ինչպիսին է «մայրը»: Ուստի, ընդհանուր առմամբ, երեխայի առաջին բառերն այն բառերն են, որոնք ավելի հաճախ են կրկնվում և դրանք էական նշանակություն ունեն: Պատկերացրեք, որ երեխայի առաջին բառը «և» է, քանի որ այն շատ հաճախ է ասվում պատմություններում կամ «The» բառում: Որոշ իրական դեպքերում երեխան իրոք սովորեց «ոչ»-ը որպես առաջին բառերը, այնուամենայնիվ, ծնողներից շատերը կցանկանային, որ դա ավելի նշանակալից բառ լիներ, օրինակ՝ մոր կամ հոր տարբերակ:

Նմանապես, արհեստական ​​ցանցերի դեպքում մենք կցանկանայինք անել նույնը և հեռացնել բառերը, որոնք աննշան են, որպեսզի արհեստական ​​նեյրոնային ցանցերը կարողանան արագ հասկանալ կորպուսի նշանակալի բառերի իմաստը:

Կանգառ բառերը սովորական բառեր են, որոնք մեծ նշանակություն չեն տալիս տեքստին: Այս բառերը պետք է հեռացվեն նախնական մշակման փուլում, եթե ոչ, ապա դա աղմուկ է առաջացնում տեքստը մշակելիս:

Օրինակներ՝

• Շաղկապներ՝ համար, և, ոչ, բայց, կամ, դեռ, և այլն
• Հոդվածներ՝ a, an, the

NLTK-ն անգլերենի համար նախապես սահմանված կանգառ բառեր ունի, այն կարող է ներմուծվել stopwords.words («անգլերեն») միջոցով: Նշում.Չկա նախապես սահմանված ցուցակ, որը համաձայնեցված է բոլորի կողմից, և տարբեր գրադարաններ ունեն տարբեր թվով կանգառներ:

nltk.corpus ներմուծման կանգառ բառերից թույլ է տալիս ներմուծել կանգառների մոդուլը:

1. Tokenizer-ն օգտագործվում է տեքստից նշաններ ստանալու համար
2. Նշաններից ստոպ բառերը հանվում են:

Կոդի նմուշ.

import nltk 
from nltk import word_tokenize
from nltk.corpus import stopwords

stopwords=set(stopwords.words('english'))
text="We are having fun learning Artificial Intelligence."
tokens=word_tokenize(text)
print(tokens)

>> ['We', 'are', 'having', 'fun', 'learning', 'Artificial', 'Intelligence', '.']

text_without_stopwords=[w for w in tokens if not w  in stopwords]
print(text_without_stopwords)

# The word 'are' is removed
>> ['We', 'having', 'fun', 'learning', 'Artificial', 'Intelligence', '.']

Առանձնահատկությունների արդյունահանում

Տվյալներն այժմ բաժանված են ավելի փոքր նշանների, որոնք կարող են հեշտությամբ մշակվել, աղմուկը հանվում է տվյալներից և բառերը փոխակերպվել են իրենց ծագման ցողունին՝ կորպուսի չափը նվազեցնելու համար: Այնուամենայնիվ, համակարգիչը չի կարողանում հասկանալ բառերը: Դա նման է ռուսերեն սովորեցնել անգլերեն խոսողին ռուսերենով: Մենք պետք է փոխարկենք մարդկային նշանները մեքենայական ընթեռնելի թվերի, որպեսզի մեքենան կարողանա հասկանալ մարդու լեզուն:

Հետևաբար, մենք պետք է օգտագործենք որոշակի մեթոդ՝ նախքան դրանք մոդելավորելը, մեր փաստաթղթում բառերին կշիռներ հատկացնելու համար: Մենք գնում ենք առանձին բառերի թվային ներկայացման, քանի որ համակարգչի համար հեշտ է մշակել թվերը: Շատ դեպքերում մենք գնում ենք բառի կամ նշանի ներդրման:

Մենք առանձնացնում ենք առանձնահատկությունները տարբեր տեխնիկայի միջոցով և ձևավորում ենք Բառի ներկառուցումներ:

ՆՇՈՒՄ. Նախքան գործառույթների արդյունահանումը և բառերի ներկառուցումը ստեղծելը, մենք պետք է կատարենք նշանների ձևավորում և վերը թվարկված նախնական մշակման այլ քայլեր:

Բառի ներդրում

Բառի ներկառուցումը կամ բառի վեկտորը մոտեցում է, որով մենք ներկայացնում ենք փաստաթղթեր և բառեր: Այն սահմանվում է որպես թվային վեկտորային մուտքագրում, որը թույլ է տալիս նմանատիպ նշանակություն ունեցող բառերին ունենալ նույն ներկայացումը: Այն կարող է մոտավոր նշանակություն ունենալ և ներկայացնել բառը ավելի ցածր ծավալային տարածության մեջ:

Բառերի ներկառուցման բազմաթիվ մեթոդներ կան: Գոյություն ունեն երկու տեսակի վեկտորներ, որոնք կառուցված են՝ Sparse Embedding Vectors և Dense Embedding Vectors:

նոսր ներկառուցումներ

նոսր վեկտորի ներդրումը շատ մեծ չափման վեկտոր է (օրինակ՝ 100,000), որտեղ նրա մուտքերի միայն մի փոքր մասն է զրոյական չէ: Տեքստի որոնման ժամանակ նոսր վեկտորները սովորաբար ներկայացնում են տերմինի մակարդակի կարևորությունը փաստաթղթերի և հարցումների համար:

• Բառերի տոպրակ
• N-գրամ
• TF-IDF

Խիտ ներկառուցումներ

խիտ վեկտորի ներկառուցումը ֆիքսված չափերի վեկտոր է, սովորաբար 100–1000 միջակայքում, որտեղ յուրաքանչյուր մուտքագրում գրեթե միշտ զրոյական չէ: Տեքստի որոնման ժամանակ, օրինակ, նրանք կարող են ներկայացնել տեքստերի իմացած իմաստային նշանակությունը ML մոդելների կողմից, ինչպիսին է SBERT-ը:

• Word2vec
• Ձեռնոց (գլոբալ վեկտորներ)

Բառերի տոպրակ

Բառերի պարկը ներկայացնում է փաստաթղթում բառերի առաջացումը: Այստեղ մենք կհաշվեինք, թե քանի անգամ են եզակի բառերը առկա փաստաթղթում կամ եզակի հավաքածուում: Այս մոտեցումը փաստաթղթերից առանձնահատկություններ հանելու պարզ և ճկուն միջոց է:

# For two files: 
# Document1: [John likes to watch movies. Mary likes movies too.]
# Document2: [Mary also likes to watch football games.]

BoW1 = {"John":1,"likes":2,"to":1,"watch":1,"movies":2,"Mary":1,"too":1};
BoW2 = {"Mary":1,"also":1,"likes":1,"to":1,"watch":1,"football":1,"games":1};

Բառերի պարկը թքած ունի բառերի հերթականության վրա և ամբողջովին անտեսում է բառերի կամ նշանների հերթականությունը: Սա նշանակում է, որ այն կարող է օգտակար լինել միայն այն դեպքում, եթե մենք մտահոգված լինենք օգտագործվող բառերով, բայց ոչ բառերի օգտագործման հաջորդականությամբ:
Օրինակ. «Գեղեցիկ տեսք ունեմ» և «Գեղեցիկ տեսք ունեմ»-ը նույն վեկտորային ձևաչափն են լինելու «Բառերի տոպրակի» դեպքում:

Նախամշակման քայլ՝

Եկեք ներմուծենք բոլոր անհրաժեշտ գրադարանները NLTK-ից՝ կատարելու ավելի վաղ քննարկված նախնական մշակման տեխնիկան, ինչպիսիք են Tokenization, Normalization, Ignoring Stop բառերը: Բացի այդ, ստորև կոդում լեմմատիզացիա կատարելիս հատուկ նիշերը հանվում են և տեքստի մեծատառը փոխվում է փոքրի, որպեսզի կատարվի նույնական տառատեսակ ամբողջ տեքստի հետ:

Ներմուծեք անհրաժեշտ գրադարանները և բեռնեք տեքստը

Tensorflow մոտեցումը Վիքիպեդիայից.

# Make sure to install the necessary packages first
# pip install --upgrade pip
# pip install tensorflow
from tensorflow import keras
from typing import List
from keras.preprocessing.text import Tokenizer

sentence = ["John likes to watch movies. Mary likes movies too."]

def print_bow(sentence: List[str]) -> None:
    tokenizer = Tokenizer()
    tokenizer.fit_on_texts(sentence)
    sequences = tokenizer.texts_to_sequences(sentence)
    word_index = tokenizer.word_index 
    bow = {}
    for key in word_index:
        bow[key] = sequences[0].count(word_index[key])

    print(f"Bag of word sentence 1:\n{bow}")
    print(f"We found {len(word_index)} unique tokens.")

print_bow(sentence)

Արդյունք:

Bag of word sentence 1:
{'likes': 2, 'movies': 2, 'john': 1, 'to': 1, 'watch': 1, 'mary': 1, 'too': 1}
We found 7 unique tokens.

NLTK մոտեցման համար.

# Import Necessary Libraries from NLTK
import nltk
from nltk import word_tokenize
from nltk.stem import WordNetLemmatizer
from nltk.corpus import stopwords
# Defined Sample Corpus
text="I like this car. It has GPS navigation. It price also very cheap."
# Download & Define English Stopwords
nltk.download('stopwords')
stopwords=set(stopwords.words('english'))

Տեքստի նախնական մշակում և բառապաշար

Բառապաշարների հավաքումը կարող է իրականացվել երկու եղանակով. Իրականացման հեշտ միջոցը count vectorizer-ն է Scikit-learn-ից կամ հետևելով բոլոր նախնական մշակման քայլերին և վեկտորացնել այն:

Բառապաշարների հավաքածու առանց Count Vectorizer

# Define a list to store all vocabulary
L=[]
#Tokenization
tokens=word_tokenize(text)
#Remove Stop words
text_without_stopwords=[w for w in tokens if not w  in stopwords]
#Lemmatization
lemmatizer = nltk.stem.WordNetLemmatizer()
W=[lemmatizer.lemmatize(w.lower()) for w in text_without_stopwords if w!="."]
# Use "set" to get unique words and sort it in ascending order.
L=sorted(list(set(W)))
# print list
print(L)

Արդյունք:

print(L)
['also', 'car', 'cheap', 'gps', 'i', 'it', 'like', 'navigation', 'price']

Բառապաշարների հավաքածու Count Vectorizer-ով

from sklearn.feature_extraction.text import CountVectorizer
vectorizer=CountVectorizer()
vectorizer.fit(text)
vocabulary=vectorizer.get_feature_names()

Արդյունք:

print(vocabulary)
['also', 'car', 'cheap', 'gps', 'it', 'like', 'navigation', 'price']

Վեկտորատոր

Հաջորդը մենք պետք է փոխարկենք տեքստը վեկտորի: Ամենապարզ մեթոդը 1-ով և 0-ով բառերի առկայությունը բառի բացակայության դեպքում նշելն է: Դրա համար մենք պետք է իրականացնենք Count Vectorizer:

Առանց հաշվառման վեկտորատորի

Ստուգեք, թե արդյոք բառը առկա է փաստաթղթում, եթե այո, կցեք 1-ը, թե այլապես կցեք 0-ը:

bag_of_words=[]
bag=[]
for x,doc in enumerate(text):
    bag=[]
    w_temp=[lemmatizer.lemmatize(w.lower()) for w in doc]
    for w in L:
        if w in w_temp:
            bag.append(1)
        else:
            bag.append(0)
    bag_of_words.append(bag)

Count Vectorizer-ով

from nltk import sent_tokenize
vectorizer=CountVectorizer()
documents=sent_tokenize(text)
X=vectorizer.fit_transform(documents)

Արդյունք:

print(X.toarray())
[[0 1 0 0 0 1 0 0 1 0 0]
 [0 0 1 1 1 0 0 0 0 1 0]
 [1 0 0 0 1 0 1 1 0 0 1]]

Ավելի լավ ըմբռնում.

import pandas as pd
pd.DataFrame(X.toarray(), columns = vectorizer.get_feature_names())

Դիտարկենք 1-ին նախադասությունը «Ինձ դուր է գալիս այս մեքենան»: Այժմ դիտարկեք վեկտորը, որը տրված է count vectorizer-ով, որտեղ էլ նախադասության բառերը (այսինքն՝ «I», «like», «this», «car») այն նշում են որպես 1, բացի նրանից, որ այն նշվում է որպես 0:

N-գրամ

Ինչպես նշվեց, բառերի պարկը հաշվի չի առնում հերթականությունը։ Այս խնդիրը լուծելու համար մենք կարող ենք օգտագործել n-գրամներ, որոնք թույլ կտան մեզ վերցնել փաստաթղթում բառերի կամ նշանների կամ նշանների շարունակական հաջորդականություն: Տեխնիկական առումով դրանք կարող են սահմանվել որպես փաստաթղթի տարրերի հարևան հաջորդականություններ։

import re

def generate_ngrams(s, n):
    # Convert to lowercases
    s = s.lower()
    
    # Replace all none alphanumeric characters with spaces
    s = re.sub(r'[^a-zA-Z0-9\s]', ' ', s)
    
    # Break sentence in the token, remove empty tokens
    tokens = [token for token in s.split(" ") if token != ""]
    
    # Use the zip function to help us generate n-grams
    # Concatentate the tokens into ngrams and return
    ngrams = zip(*[token[i:] for i in range(n)])
    return [" ".join(ngram) for ngram in ngrams]

# For bigram model (2-gram) model
sentence = ["John","likes","to","watch","movies","Mary","likes","movies","too"]

print(generate_ngrams(sentence, 2))

#Output
>> [ "John likes", "likes to", "to watch", "watch movies", 
     "Mary likes", "likes movies","movies too"]

Ինչպես տեսնում ենք վերևում, վեկտորային մատրիցայի տարրերի մեծ մասը կլինի 0, որը չի ավելացնում որևէ տեղեկատվություն, բայց վերցնում է արժեքավոր հիշողության տարածք: Ենթադրենք, մենք ունենք 1000 փաստաթղթերի հավաքածու, որը բաղկացած է ընդհանուր առմամբ 5000 եզակի բառից: Շատ միամիտ ձևով մենք կարող ենք պարզապես հաշվել յուրաքանչյուր փաստաթղթում յուրաքանչյուր բառի առաջացման թիվը, այնուհետև յուրաքանչյուր բառը ներկայացնել այս 1000-չափ վեկտորով: Սա հենց այն է, ինչ վերևում ցուցադրված է տերմինային փաստաթուղթմատրիցան:

Նմանապես, դիտարկեք 5000 եզակի բառերով տեքստի մեծ կորպուս: Այժմ վերցրեք որոշակի չափի պատուհան և յուրաքանչյուր բառային զույգի համար մենք հաշվում ենք, թե քանի անգամ է այն հայտնվում պատուհանում: Այս հաշվարկները կազմում են տերմինային մատրիցա, որը նաև կոչվում է համատեղեցման մատրիցորն այս դեպքում կլինի 5000x5000 մատրիցա (շատ բջիջներով 0, եթե պատուհանի չափը համեմատաբար է։ փոքր).

TF-IDF

Ժամկետի հաճախականությունըսահմանվում է որպես փաստաթղթում բառի հայտնվելու քանակի թիվը՝ բաժանված փաստաթղթում առկա բառերի ընդհանուր թվի վրա

Փաստաթղթերի հակադարձ հաճախականությունը սահմանվում է որպես փաստաթղթերի ընդհանուր թվի գրանցամատյան՝ բաժանված բառը պարունակող փաստաթղթերի թվի վրա: Ստորև բերված բանաձևերում 1-ը կարող է ներառել կամ չներառել, դա կախված է ձեր ցանկությունից: Դա պարզապես ստանդարտացման համար է:

TF-IDF-ը սահմանվում է որպես ժամկետային հաճախականության և փաստաթղթի հակադարձ հաճախականության արտադրյալ

TF_IDF հաշվարկի օրինակ

Ենթադրենք, որ 10000 բառանոց փաստաթղթում «համակարգ» բառը հայտնվում է 6 անգամ։ Հաշվե՞լ TF-ն:

Հետևաբար՝ TF=0.006

Ենթադրենք, որ 10000 փաստաթղթում «համակարգ» բառը հայտնվում է 60 անգամ։ Հաշվե՞լ IDF-ն:

Հետևաբար, IDF = 2,21

TF-IDF=0.006 * 2.21 = 0.0132

TfidfVetorizer-ը Scikit-learn-ից թույլ է տալիս կիրառել TF-IDF բառերի ներդրման տեխնիկա:

Կոդի նմուշ՝

#Defined the same text which is defined for Countvectorizer
text="I like this car. It has GPS navigation. It price also very cheap"
#Importing NLTK package and functions
import nltk
from nltk import sent_tokenize
#Extract documents from text(corpus)
sentences=sent_tokenize(text)
#Extracted documents
print(sentences)
['I like this car.', 'It has GPS navigation.', 'It price also very cheap']
#Importing Sklearn TF-IDF Vectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
#Define TF-IDF
tf_idf_vectorizer = TfidfVectorizer()
#Extract Vectors for sentences
X = tf_idf_vectorizer.fit_transform(sentences)
#import pandas to create dataframe for better understanding
import pandas as pd
pd.DataFrame(X.toarray(), columns = tf_idf_vectorizer.get_feature_names())

Արդյունք:

Word2vec

Word2vec ալգորիթմը օգտագործում է նեյրոնային ցանցի մոդել՝ տեքստի մեծ կորպուսից բառերի ասոցիացիաներ սովորելու համար: Ուսուցանվելուց հետո նման մոդելը կարող է հայտնաբերել հոմանիշ բառեր կամ առաջարկել լրացուցիչ բառեր մասնակի նախադասության համար: Այն կանխատեսում է վեկտորները միայն հաշվի առնելով կանխատեսող բառի տեղական համատեղությունը: Բառի կանխատեսումը տեղի է ունենում պատուհանի չափի միջակայքը դիտելով:

Word2vec-ն իր մուտքն է ընդունում տեքստի մեծ կորպուսը և արտադրում է վեկտորային տարածություն, ընդ որում կորպուսի յուրաքանչյուր եզակի բառին հատկացվում է համապատասխան վեկտոր բացատում: Word2vec-ն օգտագործում է երկու ճարտարապետություններից որևէ մեկը՝ CBOW կամ շարունակական Skip-Gram:

CBOW-ում (Բառերի շարունակական պարկ) մենք փորձում ենք գուշակել բառը՝ շրջելով բազմաթիվ բառեր, մինչդեռ Skip-Gram-ում մենք փորձում ենք համատեքստային բառերը մոդելավորել տվյալ բառով: Ստորև բերված ճարտարապետությունը նույնն է ցույց տալիս:

Word2Vec-ում նմանատիպ բառերը ավելի մոտ են գտնվում վեկտորային տարածության մեջ: Բառերի վեկտորների վրա թվաբանական գործողությունները կարող են իմաստային հարաբերություններ առաջացնել:

Օրինակ՝ «արքա» — «տղամարդ» + «կին» =» «թագուհի»

GloVe (գլոբալ վեկտորներ)

GloVe-ն չվերահսկվող ուսուցման ալգորիթմ է՝ բառերը վեկտորներով ներկայացնելու համար: Այն ավելի լավ է ֆիքսում բառ-բառ համակցությունները ամբողջ կորպուսում, քան word2vec-ը: Այլ կերպ ասած, այն ստեղծում է համընդհանուր համակեցության մատրիցա՝ գնահատելով կորպուսում այլ բառերի հավանականությունը:

Ինչու՞ է Glove-ն ավելի լավ, քան Word2vec-ը:

Երկու մոդելներն էլ սկզբունքորեն նույնն են, նրանք վեկտորներ են սովորում համակցվածից: Այնուամենայնիվ, Word2vec-ը կանխատեսող մոդել է, իսկ GloVe-ը՝ հաշվի վրա հիմնված մոդել: GloVe-ի առավելությունն այն է, որ, ի տարբերություն Word2vec-ի, GloVe-ն չի հիմնվում միայն տեղական վիճակագրության վրա, այլ ներառում է գլոբալ վիճակագրություն՝ բառերի վեկտորներ ստանալու համար: Glove-ում ավելի հեշտ է ավելի շատ տվյալներ պատրաստել, քան word2vec-ը:

Երկու փաստաթղթերի միջև նմանության հաշվարկ

Երկու փաստաթղթերի նմանությունը երկու փաստաթղթերիհարեւան հաջորդականությունների հատումն էհարեւան հաջորդականությունների միավորման վրա: Այս սահմանումը նույնական է Jaccard գործակիցին, որը նկարագրում է նմուշների հավաքածուների նմանությունն ու բազմազանությունը:

Երկու փաստաթղթերի նմանությունը հաշվարկելու մյուս եղանակն է Կոսինուսի նմանությունը:

Կոսինուսի նմանությունը չափիչ է, որն օգտագործվում է չափելու համար, թե որքանով են նման փաստաթղթերը` անկախ դրանց չափից: Մաթեմատիկորեն այն հաշվարկում է բազմաչափ տարածության մեջ նախագծված երկու վեկտորների միջև անկյան կոսինուսը:

import numpy as np

def cosine_similarity(x, y):
    
    # Ensure length of x and y are the same
    if len(x) != len(y) :
        return None
    
    # Compute the dot product between x and y
    dot_product = np.dot(x, y)
    
    # Compute the L2 norms (magnitudes) of x and y
    magnitude_x = np.sqrt(np.sum(x**2)) 
    magnitude_y = np.sqrt(np.sum(y**2))
    
    # Compute the cosine similarity
    cosine_similarity = dot_product / (magnitude_x * magnitude_y)
    
    return cosine_similarity

Եզրակացություն

Վերջապես, մենք ներկայացրեցինք նախնական մշակման բոլոր քայլերը և տարբեր եղանակներ՝ ինչպես նոսր, այնպես էլ խիտ ներդիրներ կառուցելու համար: Հետագա հոդվածներում մենք ավելի խորը կփորենք այս քայլերից յուրաքանչյուրի և այն մասին, թե ինչպես են տրանսֆորմատորները փոխել խաղը:

Ավելին, մենք կխոսենք նաև այն մասին, թե ինչպես է GPT-ի և լեզվական մեծ մոդելների կողմից ներառված ուժեղացման ուսուցումը առանցքային տեղաշարժ առաջացրել: Սա հանգեցրեց մեքենայական ուսուցման համայնքում ավելի քան երբևէ ուշադրություն դարձնելու բնական լեզվի մշակմանը:

Հավելված