از طریق منوی جستجو مطلب مورد نظر خود در وبلاگ را به سرعت پیدا کنید
سرفصلهای مطلب
این بیست و سومین مقاله از سری مقالات من است روی پایتون برای NLP. در مقاله قبلی این مجموعه روش انجام ترجمه ماشین عصبی با استفاده از آن را توضیح دادم معماری seq2seq با کتابخانه Keras پایتون برای یادگیری عمیق.
در این مقاله به مطالعه خواهیم پرداخت برت، که مخفف آن است نمایش رمزگذار دو طرفه از ترانسفورماتورها و کاربرد آن در طبقه بندی متن. BERT یک تکنیک نمایش متن مانند جاسازی ورد است. اگر هیچ ایده ای از روش کار جاسازی کلمات ندارید، به مقاله من نگاهی بیندازید روی جاسازی کلمات
مانند جاسازی کلمات، BERT نیز یک تکنیک نمایش متن است که تلفیقی از انواع الگوریتم های پیشرفته یادگیری عمیق، مانند رمزگذار دو طرفه LSTM و Transformers است. BERT توسط محققان Google در سال 2018 توسعه داده شد و ثابت شده است که برای انواع وظایف پردازش زبان طبیعی مانند طبقه بندی متن، خلاصه سازی متن، تولید متن و غیره پیشرفته است. گوگل اعلام کرد که BERT به عنوان بخش اصلی الگوریتم جستجوی آنها برای درک بهتر پرس و جوها استفاده می شود.
در این مقاله به جزئیات ریاضی روش پیاده سازی BERT نمی پردازیم، زیرا منابع زیادی در حال حاضر به صورت آنلاین در دسترس هستند. در عوض خواهیم دید که چگونه می توان طبقه بندی متن را با استفاده از توکنایزر BERT انجام داد. در این مقاله خواهید دید که چگونه می توان از BERT Tokenizer برای ایجاد مدل طبقه بندی متن استفاده کرد. در مقاله بعدی توضیح خواهم داد که چگونه می توان از BERT Tokenizer به همراه لایه تعبیه شده BERT برای ایجاد مدل های NLP حتی کارآمدتر استفاده کرد.
توجه داشته باشید: تمامی اسکریپت های این مقاله با استفاده از تست شده اند گوگل کولب محیط، با زمان اجرا پایتون روی GPU تنظیم شده است.
مجموعه داده
مجموعه داده های مورد استفاده در این مقاله را می توان از اینجا دانلود کرد این لینک کاگل.
اگر مجموعه داده را دانلود کنید و فایل فشرده را استخراج کنید، یک فایل CSV خواهید دید. این فایل شامل 50000 رکورد و دو ستون است: بررسی و احساس. ستون بررسی حاوی متنی برای بررسی و ستون احساسات حاوی احساسات برای بررسی است. ستون احساس می تواند دو مقدار داشته باشد یعنی “مثبت” و “منفی” که مشکل ما را به یک مشکل طبقه بندی باینری تبدیل می کند.
ما قبلاً در مقاله قبلی تجزیه و تحلیل احساساتی این مجموعه داده را انجام داده ایم که در آن به حداکثر دقت 92٪ دست یافته ایم. روی مجموعه آموزشی از طریق word یک تکنیک جاسازی و شبکه عصبی کانولوشنال. در مجموعه تست حداکثر دقت به دست آمده با استفاده از کلمه embedding و LSTM منفرد با 128 گره 85.40٪ بود. بیایید ببینیم آیا می‌توانیم با استفاده از نمایش BERT به دقت بهتری دست پیدا کنیم.
نصب و وارد کردن کتابخانه های مورد نیاز
قبل از اینکه بتوانید بروید و از نمایش متن BERT استفاده کنید، باید BERT را برای TensorFlow 2.0 نصب کنید. موارد زیر را اجرا کنید pip دستورات روی شما terminal برای نصب BERT برای TensorFlow 2.0.
!pip install bert-for-tf2
!pip install sentencepiece
در مرحله بعد، باید مطمئن شوید که TensorFlow 2.0 را اجرا می کنید. Google Colab، به طور پیش فرض، اسکریپت شما را اجرا نمی کند روی TensorFlow 2.0. بنابراین، برای اطمینان از اینکه اسکریپت خود را از طریق TensorFlow 2.0 اجرا می کنید، اسکریپت زیر را اجرا کنید:
try:
%tensorflow_version 2.x
except Exception:
pass
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.keras import layers
import bert
در اسکریپت فوق، علاوه بر TensorFlow 2.0، ما نیز import tensorflow_hub، که اساساً مکانی است که در آن می توانید تمام مدل های از پیش ساخته شده و از پیش آموزش داده شده توسعه یافته در TensorFlow را پیدا کنید. ما یک مدل BERT داخلی را از هاب TF وارد و استفاده خواهیم کرد. در نهایت، اگر در خروجی خروجی زیر را مشاهده کردید، بهتر است بروید:
TensorFlow 2.x selected.
وارد کردن و پیش پردازش مجموعه داده
اسکریپت زیر مجموعه داده را با استفاده از read_csv() روش چارچوب داده پانداها اسکریپت همچنین شکل مجموعه داده را چاپ می کند.
movie_reviews = pd.read_csv("/content/drive/My Drive/Colab Datasets/IMDB Dataset.csv")
movie_reviews.isnull().values.any()
movie_reviews.shape
خروجی
(50000, 2)
خروجی نشان می دهد که مجموعه داده ما 50000 سطر و 2 ستون دارد.
در مرحله بعد، داده های خود را برای حذف هر گونه علامت گذاری و کاراکترهای خاص از قبل پردازش می کنیم. برای انجام این کار، تابعی را تعریف می کنیم که یک بررسی متن خام را به عنوان ورودی می گیرد و بررسی متن پاک شده مربوطه را برمی گرداند.
def preprocess_text(sen):
sentence = remove_tags(sen)
sentence = re.sub('(^a-zA-Z)', ' ', sentence)
sentence = re.sub(r"\s+(a-zA-Z)\s+", ' ', sentence)
sentence = re.sub(r'\s+', ' ', sentence)
return sentence
TAG_RE = re.compile(r'<(^>)+>')
def remove_tags(text):
return TAG_RE.sub('', text)
اسکریپت زیر تمام بررسی های متن را پاک می کند:
reviews = ()
sentences = list(movie_reviews('review'))
for sen in sentences:
reviews.append(preprocess_text(sen))
مجموعه داده ما شامل دو ستون است که از اسکریپت زیر قابل تأیید است:
print(movie_reviews.columns.values)
خروجی:
('review' 'sentiment')
را review ستون حاوی متن است در حالی که sentiment ستون حاوی احساسات است. ستون احساسات حاوی مقادیری به شکل متن است. اسکریپت زیر مقادیر منحصر به فرد را در sentiment ستون:
movie_reviews.sentiment.unique()
خروجی:
array(('positive', 'negative'), dtype=object)
می توانید ببینید که ستون احساس شامل دو مقدار منحصر به فرد است positive و negative. الگوریتم های یادگیری عمیق با اعداد کار می کنند. از آنجایی که ما فقط دو مقدار منحصر به فرد در خروجی داریم، می توانیم آنها را به 1 و 0 تبدیل کنیم. اسکریپت زیر جایگزین می شود. positive احساسات توسط 1 و احساسات منفی توسط 0.
y = movie_reviews('sentiment')
y = np.array(list(map(lambda x: 1 if x=="positive" else 0, y)))
در حال حاضر reviews متغیر شامل بررسی های متنی است در حالی که y متغیر حاوی برچسب های مربوطه است. بیایید به طور تصادفی print بازنگری.
print(reviews(10))
خروجی:
Phil the Alien is one of those quirky films where the humour is based around the oddness of everything rather than actual punchlines At first it was very odd and pretty funny but as the movie progressed didn find the jokes or oddness funny anymore Its low budget film thats never problem in itself there were some pretty interesting characters but eventually just lost interest imagine this film would appeal to stoner who is currently partaking For something similar but better try Brother from another planet
به وضوح یک بررسی منفی به نظر می رسد. بیایید با چاپ مقدار برچسب مربوطه آن را تأیید کنیم:
print(y(10))
خروجی:
0
خروجی 0 تایید می کند که یک بررسی منفی است. ما اکنون داده‌های خود را از قبل پردازش کرده‌ایم و اکنون آماده هستیم تا از داده‌های متنی خود، نمایش BERT ایجاد کنیم.
ایجاد توکنایزر BERT
برای استفاده از تعبیه‌های متن BERT به عنوان ورودی برای آموزش مدل طبقه‌بندی متن، باید مرورهای متن خود را نشانه‌گذاری کنیم. Tokenization به تقسیم یک جمله به کلمات جداگانه اشاره دارد. برای توکن کردن متن خود، از توکنایزر BERT استفاده خواهیم کرد. به اسکریپت زیر نگاه کنید:
BertTokenizer = bert.bert_tokenization.FullTokenizer
bert_layer = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1",
trainable=False)
vocabulary_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
to_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = BertTokenizer(vocabulary_file, to_lower_case)
در اسکریپت بالا ابتدا یک شی از the ایجاد می کنیم FullTokenizer کلاس از bert.bert_tokenization مدول. سپس، با وارد کردن مدل BERT از یک لایه تعبیه‌کننده BERT ایجاد می‌کنیم hub.KerasLayer. را trainable پارامتر تنظیم شده است False، به این معنی که ما تعبیه BERT را آموزش نخواهیم داد. در خط بعدی، یک فایل واژگان BERT به شکل یک آرایه numpy ایجاد می کنیم. سپس متن را با حروف کوچک تنظیم می کنیم و در نهایت ما را پاس می کنیم vocabulary_file و to_lower_case متغیرها به BertTokenizer هدف – شی.
لازم به ذکر است که در این مقاله فقط از BERT Tokenizer استفاده خواهیم کرد. در مقاله بعدی از BERT Embeddings به همراه توکنایزر استفاده خواهیم کرد.
اکنون بیایید ببینیم که آیا توکنایزر BERT ما واقعاً کار می کند یا خیر. برای انجام این کار، مانند شکل زیر، یک جمله تصادفی را نشانه گذاری می کنیم:
tokenizer.tokenize("don't be so judgmental")
خروجی:
('don', "'", 't', 'be', 'so', 'judgment', '##al')
می بینید که متن با موفقیت توکن شده است. همچنین می توانید شناسه توکن ها را با استفاده از convert_tokens_to_ids() از شی توکن ساز. به اسکریپت زیر نگاه کنید:
tokenizer.convert_tokens_to_ids(tokenizer.tokenize("dont be so judgmental"))
خروجی:
(2123, 2102, 2022, 2061, 8689, 2389)
اکنون تابعی تعریف می‌شود که یک بررسی متنی را می‌پذیرد و شناسه‌های کلمات رمزگذاری‌شده در بررسی را برمی‌گرداند. اسکریپت زیر را اجرا کنید:
def tokenize_reviews(text_reviews):
return tokenizer.convert_tokens_to_ids(tokenizer.tokenize(text_reviews))
و اسکریپت زیر را اجرا کنید تا در واقع تمام بررسی ها در مجموعه داده ورودی را نشانه گذاری کنید:
tokenized_reviews = (tokenize_reviews(review) for review in reviews)
آماده سازی داده ها برای آموزش
بررسی‌های موجود در مجموعه داده ما طول‌های متفاوتی دارند. برخی از بررسی ها بسیار کوچک هستند در حالی که برخی دیگر بسیار طولانی هستند. برای آموزش مدل، جملات ورودی باید دارای طول مساوی باشند. برای ایجاد جملات با طول مساوی، یکی از راه‌ها این است که جملات کوتاه‌تر را با ۰ ثانیه اضافه کنید. با این حال، این می تواند منجر به یک ماتریس پراکنده حاوی تعداد زیادی 0 شود. راه دیگر این است که جملات را در هر دسته اضافه کنید. از آنجایی که ما مدل را به صورت دسته‌ای آموزش خواهیم داد، می‌توانیم بسته به طول طولانی‌ترین جمله، جملات درون دسته آموزشی را به صورت محلی اضافه کنیم. برای این کار ابتدا باید طول هر جمله را پیدا کنیم.
اسکریپت زیر فهرستی از لیست‌ها را ایجاد می‌کند که در آن هر فهرست فرعی شامل بررسی نشانه‌گذاری شده، برچسب بررسی و طول بررسی است:
reviews_with_len = ((review, y(i), len(review))
for i, review in enumerate(tokenized_reviews))
در مجموعه داده ما، نیمه اول بررسی ها مثبت هستند در حالی که نیمه آخر حاوی نظرات منفی هستند. بنابراین، برای داشتن نظرات مثبت و منفی در دسته های آموزشی، باید نظرات را به هم بزنیم. اسکریپت زیر داده ها را به طور تصادفی به هم می زند:
random.shuffle(reviews_with_len)
هنگامی که داده ها به هم ریخته شدند، داده ها را بر اساس طول بررسی ها مرتب می کنیم. برای انجام این کار، ما از sort() تابع لیست است و به آن می گوید که می خواهیم لیست را با توجه به سومین مورد در فهرست فرعی یعنی طول بررسی مرتب کنیم.
reviews_with_len.sort(key=lambda x: x(2))
وقتی مرورها بر اساس طول مرتب شدند، می‌توانیم ویژگی length را از همه مرورها حذف کنیم. برای این کار اسکریپت زیر را اجرا کنید:
sorted_reviews_labels = ((review_lab(0), review_lab(1)) for review_lab in reviews_with_len)
هنگامی که بررسی ها مرتب شدند، مجموعه داده را به گونه ای تبدیل می کنیم که بتوان از آن برای آموزش مدل های TensorFlow 2.0 استفاده کرد. کد زیر را اجرا کنید تا مجموعه داده مرتب شده را به شکل مجموعه داده ورودی مطابق با TensorFlow 2.0 تبدیل کنید.
processed_dataset = tf.data.Dataset.from_generator(lambda: sorted_reviews_labels, output_types=(tf.int32, tf.int32))
در نهایت، اکنون می‌توانیم مجموعه داده‌های خود را برای هر دسته اضافه کنیم. اندازه دسته ای که قرار است از آن استفاده کنیم 32 است که به این معنی است که پس از پردازش 32 بررسی، وزن شبکه عصبی به روز می شود. برای تکمیل نظرات به صورت محلی با توجه به دسته‌ها، موارد زیر را اجرا کنید:
BATCH_SIZE = 32
batched_dataset = processed_dataset.padded_batch(BATCH_SIZE, padded_shapes=((None, ), ()))
اجازه دهید print دسته اول و ببینید که چگونه padding روی آن اعمال شده است:
next(iter(batched_dataset))
خروجی:
(<tf.Tensor: shape=(32, 21), dtype=int32, numpy=
array((( 2054, 5896, 2054, 2466, 2054, 6752, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0),
( 3078, 5436, 3078, 3257, 3532, 7613, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0),
( 3191, 1996, 2338, 5293, 1996, 3185, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0),
( 2062, 23873, 3993, 2062, 11259, 2172, 2172, 2062, 14888,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0),
( 1045, 2876, 9278, 1402, 2028, 2130, 2006, 7922, 12635,
2305, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0),
......
( 7244, 2092, 2856, 10828, 1997, 10904, 2402, 2472, 3135,
2293, 2466, 2007, 10958, 8428, 10102, 1999, 1996, 4281,
4276, 3773, 0),
( 2005, 5760, 7788, 4393, 8808, 2498, 2064, 12826, 2000,
1996, 11056, 3152, 3811, 16755, 2169, 1998, 2296, 2028,
1997, 2068, 0),
( 2307, 3185, 2926, 1996, 2189, 3802, 2696, 2508, 2012,
2197, 1402, 8847, 6702, 2043, 2017, 2031, 2633, 2179,
2008, 2569, 2619),
( 2028, 1997, 1996, 4569, 15580, 2102, 5691, 2081, 1999,
3522, 2086, 2204, 23191, 5436, 1998, 11813, 6370, 2191,
1402, 2028, 4438),
( 1402, 3185, 2097, 2467, 2022, 5934, 1998, 3185, 4438,
2004, 2146, 2004, 2045, 1403, 2145, 2111, 2040, 6170,
3153, 1998, 2552)), dtype=int32)>,
<tf.Tensor: shape=(32,), dtype=int32, numpy=
array((0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 0, 1, 0, 1, 1, 0, 1, 1), dtype=int32)>)
خروجی بالا پنج بررسی اول و پنج بررسی آخر را نشان می دهد. از پنج مرور آخر، می بینید که تعداد کل کلمات در بزرگترین جمله 21 بوده است. بنابراین، در پنج مرور اول، 0 ها در انتهای جمله ها اضافه می شوند تا طول کل آنها نیز 21 باشد. برای دسته بعدی بسته به اندازه بزرگترین جمله در دسته متفاوت خواهد بود.
هنگامی که ما padding را به مجموعه داده خود اعمال کردیم، گام بعدی این است که مجموعه داده را به مجموعه های آزمایشی و آموزشی تقسیم کنیم. با کمک کد زیر می توانیم این کار را انجام دهیم:
TOTAL_BATCHES = math.ceil(len(sorted_reviews_labels) / BATCH_SIZE)
TEST_BATCHES = TOTAL_BATCHES // 10
batched_dataset.shuffle(TOTAL_BATCHES)
test_data = batched_dataset.take(TEST_BATCHES)
train_data = batched_dataset.skip(TEST_BATCHES)
در کد بالا ابتدا تعداد کل دسته ها را با تقسیم کل رکوردها بر 32 می یابیم. سپس 10% از داده ها برای آزمایش کنار گذاشته می شوند. برای این کار از take() روش از batched_dataset() برای ذخیره 10 درصد از داده ها در test_data متغیر. داده های باقی مانده در ذخیره می شود train_data شی برای آموزش با استفاده از skip() روش.
مجموعه داده آماده شده است و اکنون ما آماده هستیم تا مدل طبقه بندی متن خود را ایجاد کنیم.
ایجاد مدل
اکنون همه ما آماده ایم تا مدل خود را بسازیم. برای انجام این کار، کلاسی به نام ایجاد می کنیم TEXT_MODEL که از ارث می برد tf.keras.Model کلاس در داخل کلاس ما لایه های مدل خود را تعریف می کنیم. مدل ما از سه لایه شبکه عصبی کانولوشن تشکیل شده است. می توانید به جای آن از لایه های LSTM استفاده کنید و همچنین می توانید تعداد لایه ها را کم یا زیاد کنید. من تعداد و انواع لایه ها را از آن کپی کرده ام همکاری گوگل SuperDataScience notebook و به نظر می‌رسد که این معماری برای مجموعه بررسی‌های فیلم IMDB نیز به خوبی کار می‌کند.
حال بیایید کلاس مدل را ایجاد کنیم:
class TEXT_MODEL(tf.keras.Model):
def __init__(self,
vocabulary_size,
embedding_dimensions=128,
cnn_filters=50,
dnn_units=512,
model_output_classes=2,
dropout_rate=0.1,
training=False,
name="text_model"):
super(TEXT_MODEL, self).__init__(name=name)
self.embedding = layers.Embedding(vocabulary_size,
embedding_dimensions)
self.cnn_layer1 = layers.Conv1D(filters=cnn_filters,
kernel_size=2,
padding="valid",
activation="relu")
self.cnn_layer2 = layers.Conv1D(filters=cnn_filters,
kernel_size=3,
padding="valid",
activation="relu")
self.cnn_layer3 = layers.Conv1D(filters=cnn_filters,
kernel_size=4,
padding="valid",
activation="relu")
self.pool = layers.GlobalMaxPool1D()
self.dense_1 = layers.Dense(units=dnn_units, activation="relu")
self.dropout = layers.Dropout(rate=dropout_rate)
if model_output_classes == 2:
self.last_dense = layers.Dense(units=1,
activation="sigmoid")
else:
self.last_dense = layers.Dense(units=model_output_classes,
activation="softmax")
def call(self, inputs, training):
l = self.embedding(inputs)
l_1 = self.cnn_layer1(l)
l_1 = self.pool(l_1)
l_2 = self.cnn_layer2(l)
l_2 = self.pool(l_2)
l_3 = self.cnn_layer3(l)
l_3 = self.pool(l_3)
concatenated = tf.concat((l_1, l_2, l_3), axis=-1)
concatenated = self.dense_1(concatenated)
concatenated = self.dropout(concatenated, training)
model_output = self.last_dense(concatenated)
return model_output
اسکریپت فوق بسیار ساده است. در سازنده کلاس، برخی از ویژگی ها را با مقادیر پیش فرض مقداردهی اولیه می کنیم. این مقادیر بعدا جایگزین خواهند شد روی توسط مقادیر ارسال شده زمانی که شیء از TEXT_MODEL کلاس ایجاد می شود.
سپس، سه لایه شبکه عصبی کانولوشنال با مقادیر کرنل یا فیلتر به ترتیب 2، 3 و 4 مقداردهی اولیه شده اند. در صورت تمایل می توانید اندازه فیلترها را تغییر دهید.
بعد، در داخل call() تابع، ادغام حداکثر جهانی برای خروجی هر یک از لایه شبکه عصبی کانولوشن اعمال می شود. در نهایت، سه لایه شبکه عصبی کانولوشنال به هم متصل شده و خروجی آنها به اولین شبکه عصبی متصل متراکم تغذیه می شود. دومین شبکه عصبی متصل متراکم برای پیش‌بینی احساسات خروجی استفاده می‌شود، زیرا فقط شامل 2 کلاس است. اگر کلاس های بیشتری در خروجی دارید، می توانید آن را به روز کنید output_classes بر این اساس متغیر است.
حال بیایید مقادیر پارامترهای hyper مدل خود را تعریف کنیم.
VOCAB_LENGTH = len(tokenizer.vocab)
EMB_DIM = 200
CNN_FILTERS = 100
DNN_UNITS = 256
OUTPUT_CLASSES = 2
DROPOUT_RATE = 0.2
NB_EPOCHS = 5
بعد، باید یک شی از the ایجاد کنیم TEXT_MODEL کلاس و مقادیر پارامترهای hyper را که در مرحله آخر تعریف کردیم به سازنده the ارسال کنید TEXT_MODEL کلاس
text_model = TEXT_MODEL(vocabulary_size=VOCAB_LENGTH,
embedding_dimensions=EMB_DIM,
cnn_filters=CNN_FILTERS,
dnn_units=DNN_UNITS,
model_output_classes=OUTPUT_CLASSES,
dropout_rate=DROPOUT_RATE)
قبل از اینکه واقعاً بتوانیم مدل را آموزش دهیم، باید آن را کامپایل کنیم. اسکریپت زیر مدل را کامپایل می کند:
if OUTPUT_CLASSES == 2:
text_model.compile(loss="binary_crossentropy",
optimizer="adam",
metrics=("accuracy"))
else:
text_model.compile(loss="sparse_categorical_crossentropy",
optimizer="adam",
metrics=("sparse_categorical_accuracy"))
در نهایت برای آموزش مدل خود، می توانیم از آن استفاده کنیم fit روش کلاس مدل
text_model.fit(train_data, epochs=NB_EPOCHS)
این هم نتیجه بعد از 5 دوره:
Epoch 1/5
1407/1407 (==============================) - 381s 271ms/step - loss: 0.3037 - accuracy: 0.8661
Epoch 2/5
1407/1407 (==============================) - 381s 271ms/step - loss: 0.1341 - accuracy: 0.9521
Epoch 3/5
1407/1407 (==============================) - 383s 272ms/step - loss: 0.0732 - accuracy: 0.9742
Epoch 4/5
1407/1407 (==============================) - 381s 271ms/step - loss: 0.0376 - accuracy: 0.9865
Epoch 5/5
1407/1407 (==============================) - 383s 272ms/step - loss: 0.0193 - accuracy: 0.9931
<tensorflow.python.keras.callbacks.History at 0x7f5f65690048>
می توانید ببینید که ما دقت 99.31٪ را دریافت کردیم روی مجموعه آموزشی
حال بیایید عملکرد مدل خود را ارزیابی کنیم روی مجموعه تست:
results = text_model.evaluate(test_dataset)
print(results)
خروجی:
156/Unknown - 4s 28ms/step - loss: 0.4428 - accuracy: 0.8926(0.442786190037926, 0.8926282)
از خروجی، می توانیم متوجه شویم که دقت 89.26٪ را به دست آورده ایم. روی مجموعه تست
نتیجه
در این مقاله دیدید که چگونه می‌توانیم از BERT Tokenizer برای ایجاد جاسازی‌های کلمه استفاده کنیم که می‌توان از آنها برای انجام طبقه‌بندی متن استفاده کرد. ما آنالیز احساساتی نقدهای فیلم IMDB را انجام دادیم و به دقت 89.26٪ رسیدیم. روی مجموعه تست در این مقاله از تعبیه‌های BERT استفاده نکردیم، ما فقط از BERT Tokenizer برای توکن کردن کلمات استفاده کردیم. در مقاله بعدی خواهید دید که چگونه می توان از BERT Tokenizer به همراه BERT Embeddings برای انجام طبقه بندی متن استفاده کرد.
(برچسب‌ها به ترجمه)# python
منتشر شده در 1403-01-18 10:14:03
