Python for NLP: Word Embeddings for Deep Learning در Keras

این شانزدهمین مقاله از سری مقالات من است روی پایتون برای NLP. در مقاله قبلی خود توضیح دادم که چگونه می توان از تکنیک N-Grams برای توسعه یک پرکننده متن خودکار ساده در پایتون استفاده کرد. مدل N-Gram اساساً راهی برای تبدیل داده های متنی به شکل عددی است تا بتوان از آن توسط الگوریتم های آماری استفاده کرد.

قبل از N-Grams، مجموعه کلمات و رویکردهای TF-IDF را توضیح دادم، که می‌تواند برای تولید بردارهای ویژگی عددی از داده‌های متنی نیز استفاده شود. تاکنون از روش‌های یادگیری ماشینی برای انجام وظایف مختلف NLP مانند طبقه‌بندی متن، مدل‌سازی موضوع، تحلیل احساسات، خلاصه‌سازی متن و غیره استفاده می‌کنیم. در این مقاله بحث خود را در مورد تکنیک‌های یادگیری عمیق برای NLP آغاز می‌کنیم.

رویکردهای یادگیری عمیق شامل انواع مختلفی از شبکه های عصبی با اتصال متراکم هستند. این رویکردها برای حل چندین کار پیچیده مانند ماشین‌های خودران، تولید تصویر، تقسیم‌بندی تصویر و غیره کارآمد هستند. روش‌های یادگیری عمیق نیز برای کارهای NLP کاملاً کارآمد هستند.

در این مقاله، جاسازی کلمات را برای کارهای NLP که شامل یادگیری عمیق هستند، مطالعه می کنیم. خواهیم دید که چگونه می توان از جاسازی کلمات برای انجام وظایف طبقه بندی ساده با استفاده از شبکه عصبی عمیق در پایتون استفاده کرد. کتابخانه کراس.

مشکلات با رویکردهای بردار ویژگی رمزگذاری شده One-Hot

یک اشکال بالقوه با رویکردهای بردار ویژگی کدگذاری شده یکباره مانند N-Grams، کیسه کلمات و رویکرد TF-IDF این است که بردار ویژگی برای هر سند می تواند بزرگ باشد. به عنوان مثال، اگر نیم میلیون کلمه منحصر به فرد در مجموعه خود دارید و می خواهید جمله ای را نشان دهید که شامل 10 کلمه است، بردار ویژگی شما نیم میلیون بردار رمزگذاری شده تک بعدی خواهد بود که در آن تنها 10 نمایه دارای 1 خواهد بود. اتلاف فضا و افزایش نمایی پیچیدگی الگوریتم منجر به نفرین ابعاد.

جاسازی های کلمه

در جاسازی کلمه، هر کلمه به عنوان یک بردار متراکم n بعدی نشان داده می شود. کلماتی که مشابه هستند بردارهای مشابهی خواهند داشت. تکنیک های جاسازی کلمه مانند دستکش و Word2Vec ثابت کرده اند که برای تبدیل کلمات به بردارهای متراکم متناظر بسیار کارآمد هستند. اندازه برداری کوچک است و هیچ یک از شاخص های بردار در واقع خالی نیستند.

پیاده سازی جاسازی کلمه با مدل های متوالی Keras

کتابخانه Keras یکی از معروف ترین و پرکاربردترین کتابخانه های یادگیری عمیق برای پایتون است که ساخته شده است روی بالای TensorFlow.

Keras از دو نوع API پشتیبانی می کند: Sequential و Functional. در این بخش می بینیم که چگونه embedding های کلمه با Keras Sequential API استفاده می شود. در بخش بعدی روش پیاده سازی همان مدل از طریق API عملکردی Keras را توضیح خواهم داد.

برای پیاده سازی جاسازی کلمات، کتابخانه Keras حاوی لایه ای به نام است Embedding(). لایه embedding به شکل یک کلاس در Keras پیاده سازی می شود و معمولاً به عنوان اولین لایه در مدل متوالی برای وظایف NLP استفاده می شود.

لایه embedding را می توان برای انجام سه کار در Keras استفاده کرد:

• می توان از آن برای یادگیری جاسازی کلمات و ذخیره مدل به دست آمده استفاده کرد
• علاوه بر انجام وظایف NLP مانند طبقه بندی متن، تجزیه و تحلیل احساسات و غیره می توان از آن برای یادگیری واژه های embedding استفاده کرد.
• می توان از آن برای بارگذاری کلمات از قبل آموزش دیده و استفاده از آنها در مدل جدید استفاده کرد

در این مقاله کاربرد دوم و سوم لایه Embedding را خواهیم دید. مورد اول زیرمجموعه مورد استفاده دوم است.

بیایید ببینیم لایه embedding چگونه به نظر می رسد:

embedding_layer = Embedding(200, 32, input_length=50)

اولین پارامتر در لایه جاسازی، اندازه واژگان یا تعداد کل کلمات منحصر به فرد در یک مجموعه است. پارامتر دوم تعداد ابعاد هر بردار کلمه است. به عنوان مثال، اگر می خواهید هر بردار کلمه 32 بعد داشته باشد، 32 را به عنوان پارامتر دوم مشخص می کنید. و در نهایت پارامتر سوم طول جمله ورودی است.

خروجی کلمه embedding یک بردار دوبعدی است که در آن کلمات در ردیف ها نمایش داده می شوند، در حالی که ابعاد متناظر آنها در ستون ها ارائه می شود. در نهایت، اگر می خواهید لایه جاسازی کلمه خود را مستقیماً با لایه ای متراکم متصل کنید، ابتدا باید جاسازی های کلمه دو بعدی خود را به یک بعدی صاف کنید. این مفاهیم زمانی قابل درک تر می شوند که جاسازی کلمه را در عمل ببینیم.

تعبیه کلمات سفارشی

همانطور که قبلاً گفتم، Keras می‌تواند برای یادگیری جاسازی کلمات سفارشی یا برای بارگیری جاسازی‌های کلمات از پیش آموزش‌دیده استفاده شود. در این قسمت خواهیم دید که چگونه می توان از لایه Keras Embedding برای یادگیری جاسازی کلمات سفارشی استفاده کرد.

ما وظایف طبقه بندی متن ساده ای را انجام خواهیم داد که از جاسازی کلمات استفاده می کنند. برای دانلود کتابخانه های مورد نیاز اسکریپت زیر را اجرا کنید:

from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.embeddings import Embedding

بعد، باید مجموعه داده خود را تعریف کنیم. ما از یک مجموعه داده سفارشی بسیار ساده استفاده خواهیم کرد که حاوی نظرات بالای فیلم ها است. اسکریپت زیر مجموعه داده ما را ایجاد می کند:

corpus = (
    

    'This is an excellent movie',
    'The move was fantastic I like it',
    'You should watch it is brilliant',
    'Exceptionally good',
    'Wonderfully directed and executed I like it',
    'It's a fantastic series',
    'Never watched such a brilliant movie',
    'It is a Wonderful movie',

    # Negative Reviews

    "horrible acting",
    'waste of money',
    'pathetic picture',
    'It was very boring',
    'I did not like the movie',
    'The movie was horrible',
    'I will not recommend',
    'The acting is pathetic'
)

مجموعه ما دارای 8 بررسی مثبت و 8 بررسی منفی است. مرحله بعدی این است که یک مجموعه برچسب برای داده های خود ایجاد کنیم.

sentiments = array((1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0))

می بینید که 8 مورد اول در آرایه احساسات حاوی 1 است که با احساسات مثبت مطابقت دارد. 8 مورد آخر صفر هستند که با احساسات منفی مطابقت دارند.

قبلاً گفتیم که اولین پارامتر به Embedding() لایه، واژگان یا تعداد کلمات منحصر به فرد در مجموعه است. بیایید ابتدا تعداد کل کلمات موجود در مجموعه خود را پیدا کنیم:

from nltk.tokenize import word_tokenize

all_words = ()
for sent in corpus:
    tokenize_word = word_tokenize(sent)
    for word in tokenize_word:
        all_words.append(word)

در اسکریپت بالا، ما به سادگی هر جمله را در مجموعه خود تکرار می کنیم و سپس جمله را به کلمات تبدیل می کنیم. در مرحله بعد، لیست همه کلمات را تکرار می کنیم و کلمات را به آن اضافه می کنیم all_words فهرست پس از اجرای اسکریپت بالا، باید تمام کلمات موجود در آن را مشاهده کنید all_words فرهنگ لغت. با این حال، ما کلمات تکراری را نمی خواهیم.

ما می توانیم تمام کلمات منحصر به فرد را با ارسال لیست به لیست بازیابی کنیم set عملکرد، همانطور که در زیر نشان داده شده است.

unique_words = set(all_words)
print(len(unique_words))

در خروجی “45” را خواهید دید که تعداد کلمات منحصر به فرد در مجموعه ما است. یک بافر 5 به اندازه واژگان خود اضافه می کنیم و مقدار آن را تعیین می کنیم vocab_length تا 50

لایه Embedding انتظار دارد که کلمات به شکل عددی باشند. بنابراین، باید جملات موجود در مجموعه خود را به عدد تبدیل کنیم. یکی از راه های تبدیل متن به اعداد استفاده از one_hot تابع از keras.preprocessing.text کتابخانه تابع یک جمله و طول کل واژگان را می گیرد و جمله را به صورت عددی برمی گرداند.

embedded_sentences = (one_hot(sent, vocab_length) for sent in corpus)
print(embedded_sentences )

در اسکریپت بالا تمام جملات موجود در مجموعه خود را به شکل عددی تبدیل کرده و نمایش می دهیم روی را console. خروجی به شکل زیر است:

((31, 12, 31, 14, 9), (20, 3, 20, 16, 18, 45, 14), (16, 26, 29, 14, 12, 1), (16, 23), (32, 41, 13, 20, 18, 45, 14), (15, 28, 16, 43), (7, 9, 31, 28, 31, 9), (14, 12, 28, 46, 9), (4, 22), (5, 4, 9), (23, 46), (14, 20, 32, 14), (18, 1, 26, 45, 20, 9), (20, 9, 20, 4), (18, 8, 26, 34), (20, 22, 12, 23))

می بینید که اولین جمله ما شامل پنج کلمه بود، بنابراین در اولین مورد لیست پنج عدد صحیح داریم. همچنین توجه داشته باشید که آخرین کلمه جمله اول در اولین مورد لیست “فیلم” بود و در پنجمین مکان آرایه دو بعدی حاصل رقم 9 را داریم، به این معنی که “فیلم” به صورت 9 و غیره کدگذاری شده است. روی.

لایه جاسازی انتظار دارد جملات با اندازه یکسان باشند. با این حال، جملات رمزگذاری شده ما اندازه های مختلفی دارند. یکی از راه های یکنواخت کردن همه جملات این است که طول تمام جملات را افزایش داده و آن را با طول بزرگترین جمله برابر کنید. بیایید ابتدا بزرگترین جمله را در مجموعه خود پیدا کنیم و سپس طول تمام جملات را به طول بزرگترین جمله افزایش دهیم. برای انجام این کار، اسکریپت زیر را اجرا کنید:

word_count = lambda sentence: len(word_tokenize(sentence))
longest_sentence = max(corpus, key=word_count)
length_long_sentence = len(word_tokenize(longest_sentence))

در جمله بالا از عبارت لامبدا برای یافتن طول تمام جملات استفاده می کنیم. سپس از max تابعی برای برگرداندن طولانی ترین جمله. در نهایت طولانی ترین جمله به کلمات تبدیل می شود و تعداد کلمات با استفاده از آن شمارش می شود len تابع.

بعد برای اینکه همه جملات با اندازه یکسان باشند، به اندیس های خالی که در نتیجه افزایش طول جمله ایجاد می شوند، صفر اضافه می کنیم. برای اضافه کردن صفرها در انتهای جملات، می توانیم از عبارت استفاده کنیم pad_sequences روش. پارامتر اول لیستی از جملات رمزگذاری شده با اندازه های نابرابر، پارامتر دوم اندازه طولانی ترین جمله یا شاخص padding است، در حالی که آخرین پارامتر است. padding جایی که شما مشخص می کنید post برای اضافه کردن بالشتک در پایان جملات.

اسکریپت زیر را اجرا کنید:

padded_sentences = pad_sequences(embedded_sentences, length_long_sentence, padding='post')
print(padded_sentences)

در خروجی باید جملاتی با padding ببینید.

((31 12 31 14  9  0  0)
 (20  3 20 16 18 45 14)
 (16 26 29 14 12  1  0)
 (16 23  0  0  0  0  0)
 (32 41 13 20 18 45 14)
 (15 28 16 43  0  0  0)
 ( 7  9 31 28 31  9  0)
 (14 12 28 46  9  0  0)
 ( 4 22  0  0  0  0  0)
 ( 5  4  9  0  0  0  0)
 (23 46  0  0  0  0  0)
 (14 20 32 14  0  0  0)
 (18  1 26 45 20  9  0)
 (20  9 20  4  0  0  0)
 (18  8 26 34  0  0  0)
 (20 22 12 23  0  0  0))

می توانید صفرها را در انتهای جملات پر شده ببینید.

اکنون ما همه چیزهایی را که برای ایجاد یک مدل طبقه بندی احساسات با استفاده از جاسازی کلمات نیاز داریم، داریم.

ما یک مدل طبقه بندی متن بسیار ساده با یک لایه جاسازی و بدون لایه های پنهان ایجاد خواهیم کرد. به اسکریپت زیر نگاه کنید:

model = Sequential()
model.add(Embedding(vocab_length, 20, input_length=length_long_sentence))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))

در اسکریپت بالا، a را ایجاد می کنیم Sequential مدل کنید و اضافه کنید Embedding لایه به عنوان اولین لایه به مدل. طول واژگان توسط علامت مشخص می شود vocab_length پارامتر. بعد هر بردار کلمه 20 خواهد بود و input_length طول طولانی ترین جمله خواهد بود که 7 است. بعد، the Embedding لایه صاف می شود تا بتوان مستقیماً با لایه متصل متراکم استفاده کرد. از آنجایی که این یک مشکل طبقه بندی باینری است، ما از آن استفاده می کنیم sigmoid به عنوان تابع ضرر در لایه متراکم عمل می کند.

در ادامه مدل و را کامپایل می کنیم print خلاصه مدل ما، همانطور که در زیر نشان داده شده است:

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=('acc'))
print(model.summary())

خلاصه مدل به شرح زیر است:

Layer (type)                 Output Shape              Param #
=================================================================
embedding_1 (Embedding)      (None, 7, 20)             1000
_________________________________________________________________
flatten_1 (Flatten)          (None, 140)               0
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 141
=================================================================
Total params: 1,141
Trainable params: 1,141
Non-trainable params: 0

می بینید که لایه اول دارای 1000 پارامتر قابل آموزش است. این به این دلیل است که اندازه واژگان ما 50 است و هر کلمه به عنوان یک بردار 20 بعدی ارائه می شود. از این رو تعداد کل پارامترهای قابل آموزش 1000 خواهد بود. به طور مشابه، خروجی از لایه جاسازی یک جمله با 7 کلمه خواهد بود که در آن هر کلمه با یک بردار 20 بعدی نشان داده می شود. با این حال، هنگامی که خروجی دو بعدی مسطح می شود، یک بردار 140 بعدی (7×20) دریافت می کنیم. بردار مسطح مستقیماً به لایه متراکمی که حاوی 1 نورون است متصل است.

حالا بیایید مدل را آموزش دهیم روی داده های ما با استفاده از fit روش، همانطور که در زیر نشان داده شده است:

model.fit(padded_sentences, sentiments, epochs=100, verbose=1)

این مدل برای 100 دوره آموزش داده خواهد شد.

ما مدل را با استفاده از همان پیکره آموزش و آزمایش خواهیم کرد. اسکریپت زیر را برای ارزیابی عملکرد مدل اجرا کنید روی مجموعه ما:

loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))

در خروجی خواهید دید که دقت مدل 1.00 یعنی 100 درصد است.

توجه داشته باشید: در برنامه های کاربردی دنیای واقعی، مجموعه های آموزش و تست باید متفاوت باشند. هنگامی که طبقه بندی متن را انجام می دهیم، نمونه ای از آن را خواهیم دید روی برخی از داده های دنیای واقعی در مقاله آینده.

بارگیری جاسازی‌های کلمه از پیش آموزش‌دیده

در بخش قبل تعبیه کلمات سفارشی را آموزش دادیم. با این حال، ما همچنین می‌توانیم از تعبیه‌های کلمات از پیش آموزش‌دیده نیز استفاده کنیم.

چندین نوع جاسازی کلمه از پیش آموزش دیده وجود دارد، با این حال ما از جاسازی کلمه GloVe از Stanford NLP استفاده خواهیم کرد زیرا معروف ترین و رایج ترین است. کلمه embeddings را می توان از اینجا دانلود کرد این لینک.

کوچکترین فایل “Glove.6B.zip” نام دارد. حجم فایل 822 مگابایت است. این فایل شامل بردارهای کلمه 50، 100، 200 و 300 بعدی برای 400 هزار کلمه است. ما از بردار 100 بعدی استفاده خواهیم کرد.

این process کاملا مشابه است اول باید import کتابخانه های مورد نیاز:

from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.embeddings import Embedding

بعد، ما باید مجموعه خود را به دنبال برچسب ها ایجاد کنیم.

corpus = (
    

    'This is an excellent movie',
    'The move was fantastic I like it',
    'You should watch it is brilliant',
    'Exceptionally good',
    'Wonderfully directed and executed I like it',
    'It's a fantastic series',
    'Never watched such a brilliant movie',
    'It is a Wonderful movie',

    # Negative Reviews

    "horrible acting",
    'waste of money',
    'pathetic picture',
    'It was very boring',
    'I did not like the movie',
    'The movie was horrible',
    'I will not recommend',
    'The acting is pathetic'
)

sentiments = array((1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0))

در بخش آخر از one_hot تابع تبدیل متن به بردار روش دیگر استفاده از Tokenizer تابع از keras.preprocessing.text کتابخانه

شما به سادگی باید مجموعه خود را به آن منتقل کنید Tokenizer‘s fit_on_text روش.

word_tokenizer = Tokenizer()
word_tokenizer.fit_on_texts(corpus)

برای به دست آوردن تعداد کلمات منحصر به فرد در متن، به سادگی می توانید طول آن را بشمارید word_index فرهنگ لغت از word_tokenizer هدف – شی. به یاد داشته باشید که 1 را با اندازه واژگان اضافه کنید. این برای ذخیره ابعاد برای کلماتی است که هیچ جاسازی کلمه ای از قبل آموزش دیده برای آنها وجود ندارد.

vocab_length = len(word_tokenizer.word_index) + 1

در نهایت، برای تبدیل جملات به همتای عددی خود، با شماره تماس بگیرید texts_to_sequences عملکرد و آن را به کل بدنه منتقل کنید.

embedded_sentences = word_tokenizer.texts_to_sequences(corpus)
print(embedded_sentences)

در خروجی جملات را به شکل عددی مشاهده خواهید کرد:

((14, 3, 15, 16, 1), (4, 17, 6, 9, 5, 7, 2), (18, 19, 20, 2, 3, 21), (22, 23), (24, 25, 26, 27, 5, 7, 2), (28, 8, 9, 29), (30, 31, 32, 8, 33, 1), (2, 3, 8, 34, 1), (10, 11), (35, 36, 37), (12, 38), (2, 6, 39, 40), (5, 41, 13, 7, 4, 1), (4, 1, 6, 10), (5, 42, 13, 43), (4, 11, 3, 12))

مرحله بعدی یافتن تعداد کلمات در طولانی ترین جمله و سپس اعمال padding برای جملاتی است که طول های کوتاه تر از طول طولانی ترین جمله دارند.

from nltk.tokenize import word_tokenize

word_count = lambda sentence: len(word_tokenize(sentence))
longest_sentence = max(corpus, key=word_count)
length_long_sentence = len(word_tokenize(longest_sentence))

padded_sentences = pad_sequences(embedded_sentences, length_long_sentence, padding='post')

print(padded_sentences)

جملات پر شده به این صورت است:

((14  3 15 16  1  0  0)
 ( 4 17  6  9  5  7  2)
 (18 19 20  2  3 21  0)
 (22 23  0  0  0  0  0)
 (24 25 26 27  5  7  2)
 (28  8  9 29  0  0  0)
 (30 31 32  8 33  1  0)
 ( 2  3  8 34  1  0  0)
 (10 11  0  0  0  0  0)
 (35 36 37  0  0  0  0)
 (12 38  0  0  0  0  0)
 ( 2  6 39 40  0  0  0)
 ( 5 41 13  7  4  1  0)
 ( 4  1  6 10  0  0  0)
 ( 5 42 13 43  0  0  0)
 ( 4 11  3 12  0  0  0))

ما جملات خود را به دنباله‌ای از اعداد تبدیل کرده‌ایم. مرحله بعدی بارگذاری جاسازی های کلمه GloVe و سپس ایجاد ماتریس جاسازی ما است که حاوی کلمات موجود در مجموعه ما و مقادیر مربوط به آنها از جاسازی های GloVe است. اسکریپت زیر را اجرا کنید:

from numpy import array
from numpy import asarray
from numpy import zeros

embeddings_dictionary = dict()
glove_file = open('E:/Datasets/Word Embeddings/glove.6B.100d.txt', encoding="utf8")

در اسکریپت بالا، علاوه بر بارگذاری تعبیه‌های GloVe، چند کتابخانه را نیز وارد کردیم. در بخش بعدی شاهد استفاده از این کتابخانه ها خواهیم بود. در اینجا، توجه کنید که ما را بارگذاری کردیم glove.6B.100d.txt فایل. این فایل شامل 100 تعبیه کلمه بعدی است. ما همچنین یک فرهنگ لغت خالی ایجاد کردیم که جاسازی های کلمه ما را ذخیره می کند.

اگر فایل را باز کنید، در ابتدای هر خط یک کلمه خواهید دید که با مجموعه ای از 100 عدد همراه است. اعداد بردار 100 بعدی کلمه را در ابتدای هر خط تشکیل می دهند.

ما یک فرهنگ لغت ایجاد خواهیم کرد که حاوی کلمات به عنوان کلید و 100 بردار بعدی مربوطه به عنوان مقادیر، در قالب یک آرایه باشد. اسکریپت زیر را اجرا کنید:

for line in glove_file:
    records = line.split()
    word = records(0)
    vector_dimensions = asarray(records(1:), dtype='float32')
    embeddings_dictionary (word) = vector_dimensions

glove_file.close()

لغت نامه embeddings_dictionary اکنون حاوی کلمات و جاسازی‌های GloVe مربوط به همه کلمات است.

ما فقط برای کلماتی که در مجموعه ما وجود دارند، کلمه embeddings را می خواهیم. ما یک آرایه دو بعدی NumPy از 44 ردیف (اندازه واژگان) ردیف و 100 ستون ایجاد خواهیم کرد. آرایه در ابتدا حاوی صفر خواهد بود. آرایه به عنوان نامگذاری خواهد شد embedding_matrix

در مرحله بعد، با عبور از هر کلمه در مجموعه خود تکرار می کنیم word_tokenizer.word_index فرهنگ لغت که حاوی کلمات ما و نمایه مربوط به آنها است.

هر کلمه به عنوان یک کلید به embedding_dictionary برای بازیابی بردار 100 بعدی مربوط به کلمه. سپس بردار 100 بعدی در شاخص مربوط به کلمه در ذخیره می شود embedding_matrix. به اسکریپت زیر نگاه کنید:

embedding_matrix = zeros((vocab_length, 100))
for word, index in word_tokenizer.word_index.items():
    embedding_vector = embeddings_dictionary.get(word)
    if embedding_vector is not None:
        embedding_matrix(index) = embedding_vector

ما embedding_matrix اکنون شامل جاسازی‌های کلمه از پیش آموزش‌دیده برای کلمات موجود در مجموعه ما است.

اکنون ما آماده هستیم تا مدل متوالی خود را ایجاد کنیم. به اسکریپت زیر نگاه کنید:

model = Sequential()
embedding_layer = Embedding(vocab_length, 100, weights=(embedding_matrix), input_length=length_long_sentence, trainable=False)
model.add(embedding_layer)
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))

اسکریپت به جز لایه embedding ثابت می ماند. در اینجا در لایه embedding، اولین پارامتر اندازه واژگان است. پارامتر دوم بعد برداری بردار خروجی است. از آنجایی که ما از جاسازی‌های کلمه از پیش آموزش‌دیده‌شده‌ای استفاده می‌کنیم که حاوی 100 بردار بعدی است، بعد برداری را روی 100 قرار می‌دهیم.

یکی دیگر از ویژگی های بسیار مهم از Embedding() لایه ای که در قسمت آخر استفاده نکردیم است weights. شما می توانید ماتریس تعبیه شده از قبل آموزش دیده خود را به عنوان وزن های پیش فرض در اختیار قرار دهید weights پارامتر. و از آنجایی که ما لایه embedding را آموزش نمی دهیم، trainable ویژگی تنظیم شده است False.

بیایید مدل خود را جمع آوری کنیم و خلاصه مدل خود را ببینیم:

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=('acc'))
print(model.summary())

ما دوباره استفاده می کنیم adam به عنوان بهینه ساز برای به حداقل رساندن ضرر. تابع ضرر مورد استفاده است binary_crossentropy. و ما می خواهیم نتایج را در قالب دقت ببینیم acc به عنوان مقدار ارسال شده است metrics صفت.

خلاصه مدل به شرح زیر است:

Layer (type)                 Output Shape              Param #
=================================================================
embedding_1 (Embedding)      (None, 7, 100)            4400
_________________________________________________________________
flatten_1 (Flatten)          (None, 700)               0
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 701
=================================================================
Total params: 5,101
Trainable params: 701
Non-trainable params: 4,400
_________________________________________________________________

می بینید که از آنجایی که ما 44 کلمه در واژگان خود داریم و هر کلمه به صورت یک بردار 100 بعدی نمایش داده می شود، تعداد پارامترهای لایه embedding برابر خواهد بود. 44 x 100 = 4400. خروجی لایه embedding یک وکتور دو بعدی با 7 ردیف (1 برای هر کلمه در جمله) و 100 ستون خواهد بود. خروجی از لایه تعبیه شده صاف می شود تا بتوان از آن با لایه متراکم استفاده کرد. در نهایت از لایه متراکم برای پیش بینی استفاده می شود.

اسکریپت زیر را برای آموزش الگوریتم ها اجرا کنید:

model.fit(padded_sentences, sentiments, epochs=100, verbose=1)

پس از آموزش الگوریتم، اسکریپت زیر را برای ارزیابی عملکرد الگوریتم اجرا کنید.

loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))

در خروجی باید ببینید که دقت 1000 یعنی 100 درصد است.

جاسازی کلمه با Keras Functional API

در بخش آخر، دیدیم که چگونه می توان از جاسازی کلمات با API متوالی Keras استفاده کرد. در حالی که API متوالی نقطه شروع خوبی برای مبتدیان است، زیرا به شما اجازه می دهد تا به سرعت مدل های یادگیری عمیق ایجاد کنید، دانستن روش عملکرد Keras Functional API بسیار مهم است. اکثر مدل های پیشرفته یادگیری عمیق که شامل ورودی ها و خروجی های متعدد هستند از Functional API استفاده می کنند.

در این بخش، خواهیم دید که چگونه می توانیم یک لایه embedding را با Keras Functional API پیاده سازی کنیم.

بقیه فیلمنامه مانند قسمت قبلی باقی می ماند. تنها تغییر در توسعه یک مدل یادگیری عمیق خواهد بود. بیایید همان مدل یادگیری عمیق را که در بخش آخر با Keras Functional API پیاده سازی کردیم، پیاده سازی کنیم.

from keras.models import Model
from keras.layers import Input

deep_inputs = Input(shape=(length_long_sentence,))
embedding = Embedding(vocab_length, 100, weights=(embedding_matrix), input_length=length_long_sentence, trainable=False)(deep_inputs) 
flatten = Flatten()(embedding)
hidden = Dense(1, activation='sigmoid')(flatten)
model = Model(inputs=deep_inputs, outputs=hidden)

در Keras Functional API، باید لایه ورودی را به طور جداگانه قبل از لایه embedding تعریف کنید. در لایه ورودی باید به سادگی طول بردار ورودی را رد کنید. برای تعیین لایه قبلی به عنوان ورودی لایه بعدی، لایه قبلی به عنوان پارامتر در داخل پرانتز، در انتهای لایه بعدی ارسال می شود.

به عنوان مثال، در اسکریپت بالا، می توانید آن را ببینید deep_inputs به عنوان یک پارامتر در انتهای لایه embedding ارسال می شود. به همین ترتیب، embedding به عنوان ورودی در پایان ارسال می شود Flatten() لایه و غیره روی.

در نهایت، در Model()، باید لایه ورودی و لایه خروجی نهایی را رد کنید.

حال بیایید مدل را جمع آوری کنیم و نگاهی به خلاصه مدل بیندازیم.

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=('acc'))
print(model.summary())

خروجی به شکل زیر است:

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 7)                 0
_________________________________________________________________
embedding_1 (Embedding)      (None, 7, 100)            4400
_________________________________________________________________
flatten_1 (Flatten)          (None, 700)               0
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 701
=================================================================
Total params: 5,101
Trainable params: 701
Non-trainable params: 4,400

در خلاصه مدل، می توانید لایه ورودی را به عنوان یک لایه جداگانه قبل از لایه embedding ببینید. بقیه مدل ها به همان شکل باقی می مانند.

در نهایت، process برای برازش و ارزیابی مدل مشابه مدل مورد استفاده در Sequential API است:

model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)

print('Accuracy: %f' % (accuracy*100))

در خروجی دقت 1000 یعنی 100 درصد را مشاهده خواهید کرد.

نتیجه

برای استفاده از داده های متنی به عنوان ورودی مدل یادگیری عمیق، باید متن را به عدد تبدیل کنیم. با این حال، بر خلاف مدل‌های یادگیری ماشینی، عبور بردارهای پراکنده در اندازه‌های بزرگ می‌تواند تا حد زیادی بر مدل‌های یادگیری عمیق تأثیر بگذارد. بنابراین، باید متن خود را به بردارهای متراکم کوچک تبدیل کنیم. جاسازی کلمه به ما کمک می کند متن را به بردارهای متراکم تبدیل کنیم.

در این مقاله دیدیم که چگونه جاسازی کلمات را می توان با کتابخانه یادگیری عمیق Keras پیاده سازی کرد. ما جاسازی‌های کلمه سفارشی را پیاده‌سازی کردیم و همچنین از جاسازی‌های کلمه از پیش آموزش‌دیده برای حل وظایف طبقه‌بندی ساده استفاده کردیم. در نهایت، روش پیاده‌سازی جاسازی کلمه با Keras Functional API را نیز دیدیم.