ترنسفورمر در کراس و تنسرفلو

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
class TransformerEncoder(layers.Layer):
def __init__(self, embed_dim, dense_dim, num_heads, **kwargs):
super().__init__(**kwargs)
self.embed_dim = embed_dim #❶
self.dense_dim = dense_dim #❷
self.num_heads = num_heads #❸
self.attention = layers.MultiHeadAttention(
num_heads=num_heads, key_dim=embed_dim)
self.dense_proj = keras.Sequential(
[layers.Dense(dense_dim, activation="relu"),
layers.Dense(embed_dim),]
)
self.layernorm_1 = layers.LayerNormalization()
self.layernorm_2 = layers.LayerNormalization()
def call(self, inputs, mask=None): #❹
if mask is not None: #❺
mask = mask[:, tf.newaxis, :] #❺
attention_output = self.attention(
inputs, inputs, attention_mask=mask)
proj_input = self.layernorm_1(inputs + attention_output)
proj_output = self.dense_proj(proj_input)
return self.layernorm_2(proj_input + proj_output)
def get_config(self): #❻
config = super().get_config()
config.update({
"embed_dim": self.embed_dim,
"num_heads": self.num_heads,
"dense_dim": self.dense_dim,
})
return config

ذخیره‌سازی لایه‌های سفارشی

وقتی که لایه‌های سفارشی می‌نویسید، مطمئن شوید که متد get_config را پیاده‌سازی کنید: این کار امکان بازآفرینی (reinstantiate) لایه از دیکشنری تنظیمات (config dict) آن را فراهم می‌کند، که در زمان ذخیره و بارگذاری مدل مفید است. این متد باید یک دیکشنری پایتون را برگرداند که مقادیر آرگومان‌های سازنده‌ای که برای ایجاد لایه استفاده شده‌اند را شامل شود. تمام لایه‌های Keras می‌توانند به صورت زیر سریال‌سازی و دسیریال‌سازی شوند:

config = layer.get_config()
new_layer = layer.__class__.from_config(config) #1

❶ تنظیمات شامل مقادیر وزن‌ها نیستند، بنابراین تمام وزن‌های لایه از ابتدا مقداردهی اولیه می‌شوند.

برای مثال:

layer = PositionalEmbedding(sequence_length, input_dim, output_dim)
config = layer.get_config()
new_layer = PositionalEmbedding.from_config(config)

هنگام ذخیره یک مدل که شامل لایه‌های سفارشی است، فایل ذخیره شامل این دیکشنری‌های تنظیمات خواهد بود. هنگام بارگذاری مدل از فایل، باید کلاس‌های لایه سفارشی را به فرآیند بارگذاری ارائه دهید تا بتواند تنظیمات اشیاء را تفسیر کند:

model = keras.models.load_model(
filename, custom_objects={"PositionalEmbedding": PositionalEmbedding})

def layer_normalization(batch_of_sequences): ❶
mean = np.mean(batch_of_sequences, keepdims=True, axis=-1) ❷
variance = np.var(batch_of_sequences, keepdims=True, axis=-1) ❷
return (batch_of_sequences - mean) / variance

def batch_normalization(batch_of_images): ❶
mean = np.mean(batch_of_images, keepdims=True, axis=(0, 1, 2)) ❷
variance = np.var(batch_of_images, keepdims=True, axis=(0, 1, 2)) ❷
return (batch_of_images - mean) / variance

❶ شکل ورودی: (batch_size، height، width، channels)
❷ تجمیع داده‌ها بر روی محور batch (محور 0)، که تعاملات بین نمونه‌ها در یک batch را ایجاد می‌کند.

در حالی که BatchNormalization اطلاعات را از بسیاری از نمونه‌ها جمع‌آوری می‌کند تا آمار دقیقی برای میانگین‌ها و واریانس‌های ویژگی‌ها به دست آورد، LayerNormalization داده‌ها را در هر دنباله به صورت جداگانه تجمیع می‌کند، که برای داده‌های ترتیبی مناسب‌تر است.
حالا که ترنسفورمر انکودر (TransformerEncoder) خود را پیاده‌سازی کرده‌ایم، می‌توانیم از آن برای ساخت یک مدل طبقه‌بندی متن استفاده کنیم.

vocab_size = 20000
embed_dim = 256
num_heads = 2
dense_dim = 32
inputs = keras.Input(shape=(None,), dtype="int64")
x = layers.Embedding(vocab_size, embed_dim)(inputs)
x = TransformerEncoder(embed_dim, dense_dim, num_heads)(x)
x = layers.GlobalMaxPooling1D()(x) ❶
x = layers.Dropout(0.5)(x)
outputs = layers.Dense(1, activation="sigmoid")(x)
model = keras.Model(inputs, outputs)
model.compile(optimizer="rmsprop",
loss="binary_crossentropy",
metrics=["accuracy"])
model.summary()

❶ از آنجا که ترنسفورمر انکودر (TransformerEncoder) دنباله‌های کامل را برمی‌گرداند، ما نیاز داریم که هر دنباله را به یک بردار منفرد برای طبقه‌بندی از طریق یک لایه تجمیع (global pooling layer) کاهش دهیم.

بیایید آن را آموزش دهیم. به دقت 87.5٪ در تست می‌رسد. (فعلا عالی نیست!)

callbacks = [
keras.callbacks.ModelCheckpoint("transformer_encoder.keras",
save_best_only=True)
]
model.fit(int_train_ds, validation_data=int_val_ds, epochs=20,
callbacks=callbacks)
model = keras.models.load_model(
"transformer_encoder.keras",
custom_objects={"TransformerEncoder": TransformerEncoder}) ❶
print(f"Test acc: {model.evaluate(int_test_ds)[1]:.3f}")

❶ کلاس سفارشی ترنسفورمر انکودر (TransformerEncoder) را به فرآیند لود مدل ارائه دهید.

در این نقطه، ممکن است شروع به احساس ناراحتی کنید. چیزی اینجا درست نیست. می‌توانید بگویید چیست؟
این بخش ظاهراً درباره “مدل‌های ترتیبی” است. من با تاکید بر اهمیت ترتیب کلمات شروع کردم. گفتم که ترنسفورمر یک معماری پردازش دنباله‌ای است که در اصل برای ترجمه ماشینی توسعه داده شده است. و با این حال… ترنسفورمر انکودری که شما در عمل دیدید اصلاً یک مدل ترتیبی نبود. متوجه شدید؟ این مدل از لایه‌های چگالی (dense layers) تشکیل شده که توکن‌های دنباله را به طور مستقل از یکدیگر پردازش می‌کنند، و یک لایه توجه (attention layer) که توکن‌ها را به صورت یک مجموعه در نظر می‌گیرد. شما می‌توانید ترتیب توکن‌ها در یک دنباله را تغییر دهید و همچنان همان نمرات توجه زوجی (pairwise attention scores) و همان نمایش‌های با زمینه آگاه (context-aware representations) را دریافت کنید. اگر شما کلمات هر نقد فیلم را کاملاً به هم بزنید، مدل متوجه نخواهد شد و همچنان دقیقاً همان دقت را خواهد داشت. خود توجه (Self-attention) یک مکانیزم پردازش مجموعه‌ای است که بر روی روابط بین زوج‌های عناصر دنباله تمرکز دارد (به شکل زیر نگاه کنید) —این مکانیزم نسبت به این که این عناصر در ابتدا، انتها یا وسط یک دنباله قرار دارند، بی‌توجه است. پس چرا می‌گوییم که ترنسفورمر یک مدل ترتیبی است؟ و چگونه ممکن است برای ترجمه ماشینی خوب باشد اگر به ترتیب کلمات توجهی ندارد؟

class PositionalEmbedding(layers.Layer):
def __init__(self, sequence_length, input_dim, output_dim, **kwargs): ❶
super().__init__(**kwargs)
self.token_embeddings = layers.Embedding( ❷
input_dim=input_dim, output_dim=output_dim)
self.position_embeddings = layers.Embedding(
input_dim=sequence_length, output_dim=output_dim) ❸
self.sequence_length = sequence_length
self.input_dim = input_dim
self.output_dim = output_dim
def call(self, inputs):
length = tf.shape(inputs)[-1]
positions = tf.range(start=0, limit=length, delta=1)
embedded_tokens = self.token_embeddings(inputs)
embedded_positions = self.position_embeddings(positions)
return embedded_tokens + embedded_positions ❹
def compute_mask(self, inputs, mask=None): ❺
return tf.math.not_equal(inputs, 0) ❺
def get_config(self): ❻
config = super().get_config()
config.update({
"output_dim": self.output_dim,
"sequence_length": self.sequence_length,
"input_dim": self.input_dim,
})
return config

❶ یک نقطه ضعف از جاسازی موقعیتی این است که طول دنباله باید از پیش معلوم باشد.
❷ یک لایه Embedding برای شاخص‌های توکن آماده کنید.
❸ و یک لایه دیگر برای موقعیت‌های توکن‌ها
❹ هر دو بردار جاسازی را با هم اضافه کنید.
❺ مانند لایه Embedding، این لایه باید قادر باشد تا یک ماسک تولید کند تا بتوانیم صفرهای پر کننده را در ورودی‌ها نادیده بگیریم. متد compute_mask به طور خودکار توسط چارچوب فراخوانی خواهد شد، و ماسک به لایه بعدی منتقل خواهد شد.
❻ سریال‌سازی را پیاده‌سازی کنید تا بتوانیم مدل را ذخیره کنیم.

شما از این لایه PositionEmbedding به همان روشی که از یک لایه Embedding معمولی استفاده می‌کنید. بیایید آن را در عمل ببینیم!