عاد TensorFlow إلى Google I/O في 14 مايو! سجل الان

تمت ترجمة هذه الصفحة بواسطة Cloud Translation API‏.

الشبكة العميقة والمتقاطعة (DCN)

عرض على TensorFlow.org

تشغيل في Google Colab

عرض المصدر على جيثب

تحميل دفتر

يوضح هذا البرنامج التعليمي كيفية استخدام Deep & Cross Network (DCN) لتعلم تقاطعات الميزات بشكل فعال.

خلفية

ما هي تقاطعات الميزات ولماذا هي مهمة؟ تخيل أننا نبني نظام توصية لبيع الخلاط للعملاء. ثم، العميل التاريخ شراء الماضي مثل purchased_bananas و purchased_cooking_books ، أو ميزات جغرافية، هي السمات واحدة. إذا كان أحد قد اشترى كل من الموز وكتب الطبخ، فإن هذا العميل أكثر عرضة انقر على خلاط الموصى بها. مزيج من purchased_bananas و purchased_cooking_books ما يشار إليها باسم الصليب الميزة، الذي يقدم معلومات تفاعل إضافية تتجاوز الميزات الفردية.

ما هي التحديات في تعلم ميزة التقاطع؟ في التطبيقات على نطاق الويب ، تكون البيانات في الغالب فئوية ، مما يؤدي إلى مساحة ميزة كبيرة ومتناثرة. غالبًا ما يتطلب تحديد تقاطعات الميزات الفعالة في هذا الإعداد هندسة ميزات يدوية أو بحثًا شاملاً. نماذج الإدراك الحسي متعدد الطبقات التقليدية (MLP) هي مقارب للوظائف العالمية ؛ ومع ذلك، فإنها لا يمكن تقريب بكفاءة حتى 2ND أو 3 النظام ميزة الصلبان [ 1 ، 2 ].

ما هي الشبكة العميقة والمتقاطعة (DCN)؟ تم تصميم DCN لتعلم الميزات المتقاطعة الواضحة والمحدودة بشكل أكثر فعالية. ويبدأ مع طبقة المدخلات (عادة طبقة التضمين)، تليها شبكة عبر تحتوي على طبقات متعددة عبر أن التفاعلات نماذج صريحة الميزة، ومن ثم يجمع مع شبكة العميقة التي نماذج التفاعلات ميزة ضمنية.

عبر الشبكة. هذا هو جوهر DCN. يطبق بشكل صريح تقاطع الميزات في كل طبقة ، وتزداد أعلى درجة متعددة الحدود مع عمق الطبقة. يظهر الشكل التالي \((i+1)\)-th طبقة الصليب.
شبكة عميقة. وهو عبارة عن مدرك متعدد الطبقات تقليدي متعدد الطبقات (MLP).

شبكة عميقة وشبكة عبر ثم يتم الجمع بين لتشكيل DCN [ 1 ]. بشكل عام ، يمكننا تكديس شبكة عميقة أعلى الشبكة المتقاطعة (بنية مكدسة) ؛ يمكننا أيضًا وضعها في شكل متوازي (بنية متوازية).

في ما يلي ، سنعرض أولاً ميزة DCN مع مثال لعبة ، ثم سنرشدك عبر بعض الطرق الشائعة لاستخدام DCN باستخدام مجموعة بيانات MovieLen-1M.

لنقم أولاً بتثبيت واستيراد الحزم الضرورية لهذا colab.

pip install -q tensorflow-recommenders
pip install -q --upgrade tensorflow-datasets

import pprint

%matplotlib inline
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable

import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds

import tensorflow_recommenders as tfrs

مثال لعبة

لتوضيح فوائد DCN ، دعنا نعمل من خلال مثال بسيط. لنفترض أن لدينا مجموعة بيانات حيث نحاول نمذجة احتمالية قيام العميل بالنقر فوق إعلان الخلاط ، بميزاته وتسميته الموضحة على النحو التالي.

الميزات / التسمية	وصف	نوع / نطاق القيمة
\(x_1\) = البلاد	البلد الذي يعيش فيه هذا العميل	كثافة العمليات في [0 ، 199]
\(x_2\) = الموز	# موز اشتراه العميل	كثافة العمليات في [0 ، 23]
\(x_3\) = كتب الطبخ	# كتب طبخ اشتراها العميل	كثافة العمليات في [0 ، 5]
\(y\)	احتمالية النقر فوق إعلان الخلاط	-

بعد ذلك ، ندع البيانات تتبع التوزيع الأساسي التالي:

\[y = f(x_1, x_2, x_3) = 0.1x_1 + 0.4x_2+0.7x_3 + 0.1x_1x_2+3.1x_2x_3+0.1x_3^2\]

حيث احتمال \(y\) يعتمد خطيا على حد سواء على ميزات \(x_i\)الصورة، ولكن أيضا على التفاعل المضاعف بين \(x_i\)الصورة. في حالتنا، لقلنا أن احتمال شراء خلاط (\(y\)) لا يعتمد فقط على شراء الموز (\(x_2\)) أو كتب الطبخ (\(x_3\))، ولكن أيضا على شراء الموز وكتب الطبخ معا (\(x_2x_3\)).

يمكننا إنشاء البيانات الخاصة بذلك على النحو التالي:

توليد البيانات التركيبية

علينا أولا تحديد \(f(x_1, x_2, x_3)\) كما هو موضح أعلاه.

def get_mixer_data(data_size=100_000, random_seed=42):
  # We need to fix the random seed
  # to make colab runs repeatable.
  rng = np.random.RandomState(random_seed)
  country = rng.randint(200, size=[data_size, 1]) / 200.
  bananas = rng.randint(24, size=[data_size, 1]) / 24.
  coockbooks = rng.randint(6, size=[data_size, 1]) / 6.

  x = np.concatenate([country, bananas, coockbooks], axis=1)

  # # Create 1st-order terms.
  y = 0.1 * country + 0.4 * bananas + 0.7 * coockbooks

  # Create 2nd-order cross terms.
  y += 0.1 * country * bananas + 3.1 * bananas * coockbooks + (
        0.1 * coockbooks * coockbooks)

  return x, y

دعونا ننشئ البيانات التي تتبع التوزيع ، ونقسم البيانات إلى 90٪ للتدريب و 10٪ للاختبار.

x, y = get_mixer_data()
num_train = 90000
train_x = x[:num_train]
train_y = y[:num_train]
eval_x = x[num_train:]
eval_y = y[num_train:]

بناء النموذج

سنقوم بتجربة كل من الشبكة المتقاطعة والشبكة العميقة لتوضيح الميزة التي يمكن أن تجلبها الشبكة المتقاطعة إلى المقترحين. نظرًا لأن البيانات التي أنشأناها للتو تحتوي فقط على تفاعلات ميزة من الدرجة الثانية ، فسيكون ذلك كافيًا للتوضيح بشبكة متقاطعة أحادية الطبقة. إذا أردنا تصميم تفاعلات ميزات ذات ترتيب أعلى ، فيمكننا تكديس طبقات متقاطعة متعددة واستخدام شبكة متعددة الطبقات عبر الشبكة. النموذجان اللذان سنبنيهما هما:

عبر الشبكة مع طبقة عرضية واحدة فقط ؛
شبكة عميقة مع طبقات ReLU أوسع وأعمق.

نقوم أولاً ببناء فئة نموذجية موحدة تكون خسارتها هي متوسط الخطأ التربيعي.

class Model(tfrs.Model):

  def __init__(self, model):
    super().__init__()
    self._model = model
    self._logit_layer = tf.keras.layers.Dense(1)

    self.task = tfrs.tasks.Ranking(
      loss=tf.keras.losses.MeanSquaredError(),
      metrics=[
        tf.keras.metrics.RootMeanSquaredError("RMSE")
      ]
    )

  def call(self, x):
    x = self._model(x)
    return self._logit_layer(x)

  def compute_loss(self, features, training=False):
    x, labels = features
    scores = self(x)

    return self.task(
        labels=labels,
        predictions=scores,
    )

بعد ذلك ، نحدد الشبكة المتقاطعة (بطبقة عرضية واحدة بالحجم 3) و DNN المستند إلى ReLU (بأحجام طبقات [512 ، 256 ، 128]):

crossnet = Model(tfrs.layers.dcn.Cross())
deepnet = Model(
    tf.keras.Sequential([
      tf.keras.layers.Dense(512, activation="relu"),
      tf.keras.layers.Dense(256, activation="relu"),
      tf.keras.layers.Dense(128, activation="relu")
    ])
)

تدريب نموذجي

الآن بعد أن أصبحت البيانات والنماذج جاهزة ، سنقوم بتدريب النماذج. نقوم أولاً بتبديل وتجميع البيانات للتحضير للتدريب على النموذج.

train_data = tf.data.Dataset.from_tensor_slices((train_x, train_y)).batch(1000)
eval_data = tf.data.Dataset.from_tensor_slices((eval_x, eval_y)).batch(1000)

ثم نحدد عدد الحقب وكذلك معدل التعلم.

epochs = 100
learning_rate = 0.4

حسنًا ، كل شيء جاهز الآن ودعنا نجمع النماذج وندربها. يمكنك تعيين verbose=True إذا كنت تريد أن ترى كيف تقدمات نموذج.

crossnet.compile(optimizer=tf.keras.optimizers.Adagrad(learning_rate))
crossnet.fit(train_data, epochs=epochs, verbose=False)

<keras.callbacks.History at 0x7f27d82ef390>

deepnet.compile(optimizer=tf.keras.optimizers.Adagrad(learning_rate))
deepnet.fit(train_data, epochs=epochs, verbose=False)

<keras.callbacks.History at 0x7f27d07a3dd0>

تقييم النموذج

نتحقق من أداء النموذج في مجموعة بيانات التقييم ونبلغ عن الخطأ التربيعي لمتوسط الجذر (RMSE ، كلما كان الانخفاض أفضل).

crossnet_result = crossnet.evaluate(eval_data, return_dict=True, verbose=False)
print(f"CrossNet(1 layer) RMSE is {crossnet_result['RMSE']:.4f} "
      f"using {crossnet.count_params()} parameters.")

deepnet_result = deepnet.evaluate(eval_data, return_dict=True, verbose=False)
print(f"DeepNet(large) RMSE is {deepnet_result['RMSE']:.4f} "
      f"using {deepnet.count_params()} parameters.")

CrossNet(1 layer) RMSE is 0.0011 using 16 parameters.
DeepNet(large) RMSE is 0.1258 using 166401 parameters.

ونحن نرى أن الشبكة عبر مقادير حققت تخفض RMSE من DNN أساس ReLU، مع مقادير أقل المعلمات. وقد أوحى هذا بكفاءة الشبكة المتقاطعة في تعلم التهجينات.

فهم النموذج

نحن نعلم بالفعل ما هي تقاطعات الميزات المهمة في بياناتنا ، سيكون من الممتع التحقق مما إذا كان نموذجنا قد تعلم بالفعل تقاطع الميزات المهم. يمكن القيام بذلك من خلال تصور مصفوفة الوزن المكتسبة في DCN. وزن \(W_{ij}\) يمثل أهمية علم التفاعل بين ميزة \(x_i\) و \(x_j\).

mat = crossnet._model._dense.kernel
features = ["country", "purchased_bananas", "purchased_cookbooks"]

plt.figure(figsize=(9,9))
im = plt.matshow(np.abs(mat.numpy()), cmap=plt.cm.Blues)
ax = plt.gca()
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes("right", size="5%", pad=0.05)
plt.colorbar(im, cax=cax)
cax.tick_params(labelsize=10) 
_ = ax.set_xticklabels([''] + features, rotation=45, fontsize=10)
_ = ax.set_yticklabels([''] + features, fontsize=10)

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:11: UserWarning: FixedFormatter should only be used together with FixedLocator
  # This is added back by InteractiveShellApp.init_path()
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: FixedFormatter should only be used together with FixedLocator
  if sys.path[0] == '':
<Figure size 648x648 with 0 Axes>

بي إن جي

تمثل الألوان الداكنة تفاعلات مكتسبة أقوى - في هذه الحالة ، من الواضح أن النموذج قد تعلم أن شراء كتب الطهي وكتب الطهي معًا أمر مهم.

إذا كنت مهتما في محاولة الخروج بيانات الاصطناعية أكثر تعقيدا، لا تتردد في سحب هذه الورقة .

مثال على Movielens 1M

نحن الآن دراسة فعالية DCN على مجموعة بيانات في العالم الحقيقي: Movielens 1M [ 3 ]. Movielens 1M هي مجموعة بيانات شائعة للبحث في التوصيات. يتنبأ بتصنيفات أفلام المستخدمين بالنظر إلى الميزات المتعلقة بالمستخدم والميزات المتعلقة بالفيلم. نستخدم مجموعة البيانات هذه لتوضيح بعض الطرق الشائعة لاستخدام DCN.

معالجة البيانات

إجراء معالجة البيانات في أعقاب إجراء مماثل باسم تعليمي رفيع المستوى الأساسي .

ratings = tfds.load("movie_lens/100k-ratings", split="train")
ratings = ratings.map(lambda x: {
    "movie_id": x["movie_id"],
    "user_id": x["user_id"],
    "user_rating": x["user_rating"],
    "user_gender": int(x["user_gender"]),
    "user_zip_code": x["user_zip_code"],
    "user_occupation_text": x["user_occupation_text"],
    "bucketized_user_age": int(x["bucketized_user_age"]),
})

WARNING:absl:The handle "movie_lens" for the MovieLens dataset is deprecated. Prefer using "movielens" instead.

بعد ذلك ، قمنا بتقسيم البيانات عشوائيًا إلى 80٪ للتدريب و 20٪ للاختبار.

tf.random.set_seed(42)
shuffled = ratings.shuffle(100_000, seed=42, reshuffle_each_iteration=False)

train = shuffled.take(80_000)
test = shuffled.skip(80_000).take(20_000)

بعد ذلك ، نقوم بإنشاء مفردات لكل ميزة.

feature_names = ["movie_id", "user_id", "user_gender", "user_zip_code",
                 "user_occupation_text", "bucketized_user_age"]

vocabularies = {}

for feature_name in feature_names:
  vocab = ratings.batch(1_000_000).map(lambda x: x[feature_name])
  vocabularies[feature_name] = np.unique(np.concatenate(list(vocab)))

بناء النموذج

تبدأ بنية النموذج التي سنبنيها بطبقة التضمين ، والتي يتم إدخالها في شبكة متقاطعة متبوعة بشبكة عميقة. تم تعيين بُعد التضمين على 32 لجميع الميزات. يمكنك أيضًا استخدام أحجام تضمين مختلفة لميزات مختلفة.

class DCN(tfrs.Model):

  def __init__(self, use_cross_layer, deep_layer_sizes, projection_dim=None):
    super().__init__()

    self.embedding_dimension = 32

    str_features = ["movie_id", "user_id", "user_zip_code",
                    "user_occupation_text"]
    int_features = ["user_gender", "bucketized_user_age"]

    self._all_features = str_features + int_features
    self._embeddings = {}

    # Compute embeddings for string features.
    for feature_name in str_features:
      vocabulary = vocabularies[feature_name]
      self._embeddings[feature_name] = tf.keras.Sequential(
          [tf.keras.layers.StringLookup(
              vocabulary=vocabulary, mask_token=None),
           tf.keras.layers.Embedding(len(vocabulary) + 1,
                                     self.embedding_dimension)
    ])

    # Compute embeddings for int features.
    for feature_name in int_features:
      vocabulary = vocabularies[feature_name]
      self._embeddings[feature_name] = tf.keras.Sequential(
          [tf.keras.layers.IntegerLookup(
              vocabulary=vocabulary, mask_value=None),
           tf.keras.layers.Embedding(len(vocabulary) + 1,
                                     self.embedding_dimension)
    ])

    if use_cross_layer:
      self._cross_layer = tfrs.layers.dcn.Cross(
          projection_dim=projection_dim,
          kernel_initializer="glorot_uniform")
    else:
      self._cross_layer = None

    self._deep_layers = [tf.keras.layers.Dense(layer_size, activation="relu")
      for layer_size in deep_layer_sizes]

    self._logit_layer = tf.keras.layers.Dense(1)

    self.task = tfrs.tasks.Ranking(
      loss=tf.keras.losses.MeanSquaredError(),
      metrics=[tf.keras.metrics.RootMeanSquaredError("RMSE")]
    )

  def call(self, features):
    # Concatenate embeddings
    embeddings = []
    for feature_name in self._all_features:
      embedding_fn = self._embeddings[feature_name]
      embeddings.append(embedding_fn(features[feature_name]))

    x = tf.concat(embeddings, axis=1)

    # Build Cross Network
    if self._cross_layer is not None:
      x = self._cross_layer(x)

    # Build Deep Network
    for deep_layer in self._deep_layers:
      x = deep_layer(x)

    return self._logit_layer(x)

  def compute_loss(self, features, training=False):
    labels = features.pop("user_rating")
    scores = self(features)
    return self.task(
        labels=labels,
        predictions=scores,
    )

تدريب نموذجي

نقوم بترتيب بيانات التدريب والاختبار عشوائيًا وتجميعها وتخزينها مؤقتًا.

cached_train = train.shuffle(100_000).batch(8192).cache()
cached_test = test.batch(4096).cache()

دعنا نحدد دالة تقوم بتشغيل نموذج عدة مرات وإرجاع متوسط RMSE للنموذج والانحراف المعياري من عدة عمليات تشغيل.

def run_models(use_cross_layer, deep_layer_sizes, projection_dim=None, num_runs=5):
  models = []
  rmses = []

  for i in range(num_runs):
    model = DCN(use_cross_layer=use_cross_layer,
                deep_layer_sizes=deep_layer_sizes,
                projection_dim=projection_dim)
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate))
    models.append(model)

    model.fit(cached_train, epochs=epochs, verbose=False)
    metrics = model.evaluate(cached_test, return_dict=True)
    rmses.append(metrics["RMSE"])

  mean, stdv = np.average(rmses), np.std(rmses)

  return {"model": models, "mean": mean, "stdv": stdv}

قمنا بتعيين بعض المعلمات الفائقة للنماذج. لاحظ أن هذه المعلمات المفرطة يتم تعيينها عالميًا لجميع النماذج لغرض العرض التوضيحي. إذا كنت ترغب في الحصول على أفضل أداء لكل نموذج ، أو إجراء مقارنة عادلة بين النماذج ، فإننا نقترح عليك ضبط المعلمات الفائقة. تذكر أن بنية النموذج وخطط التحسين متشابكة.

epochs = 8
learning_rate = 0.01

DCN (مكدس). نقوم أولاً بتدريب نموذج DCN بهيكل مكدس ، أي يتم تغذية المدخلات إلى شبكة متقاطعة متبوعة بشبكة عميقة.

dcn_result = run_models(use_cross_layer=True,
                        deep_layer_sizes=[192, 192])

WARNING:tensorflow:mask_value is deprecated, use mask_token instead.
WARNING:tensorflow:mask_value is deprecated, use mask_token instead.
5/5 [==============================] - 3s 24ms/step - RMSE: 0.9312 - loss: 0.8674 - regularization_loss: 0.0000e+00 - total_loss: 0.8674
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9339 - loss: 0.8726 - regularization_loss: 0.0000e+00 - total_loss: 0.8726
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9326 - loss: 0.8703 - regularization_loss: 0.0000e+00 - total_loss: 0.8703
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9351 - loss: 0.8752 - regularization_loss: 0.0000e+00 - total_loss: 0.8752
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9339 - loss: 0.8729 - regularization_loss: 0.0000e+00 - total_loss: 0.8729

رتبة منخفضة DCN. لتقليل تكلفة التدريب والخدمة ، نستخدم تقنيات الرتبة المنخفضة لتقريب مصفوفات الوزن DCN. يتم تمرير رتبة في طريق حجة projection_dim . أصغر projection_dim النتائج في أقل تكلفة. علما بأن projection_dim يحتاج إلى أن يكون أقل من (حجم المدخلات) / 2 للحد من التكاليف. من الناحية العملية ، لاحظنا استخدام DCN منخفض الرتبة مع رتبة (حجم إدخال) / 4 حافظ باستمرار على دقة DCN كامل الرتبة.

dcn_lr_result = run_models(use_cross_layer=True,
                           projection_dim=20,
                           deep_layer_sizes=[192, 192])

5/5 [==============================] - 0s 3ms/step - RMSE: 0.9307 - loss: 0.8669 - regularization_loss: 0.0000e+00 - total_loss: 0.8669
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9312 - loss: 0.8668 - regularization_loss: 0.0000e+00 - total_loss: 0.8668
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9303 - loss: 0.8666 - regularization_loss: 0.0000e+00 - total_loss: 0.8666
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9337 - loss: 0.8723 - regularization_loss: 0.0000e+00 - total_loss: 0.8723
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9300 - loss: 0.8657 - regularization_loss: 0.0000e+00 - total_loss: 0.8657

DNN. نقوم بتدريب نموذج DNN بنفس الحجم كمرجع.

dnn_result = run_models(use_cross_layer=False,
                        deep_layer_sizes=[192, 192, 192])

5/5 [==============================] - 0s 3ms/step - RMSE: 0.9462 - loss: 0.8989 - regularization_loss: 0.0000e+00 - total_loss: 0.8989
5/5 [==============================] - 0s 4ms/step - RMSE: 0.9352 - loss: 0.8765 - regularization_loss: 0.0000e+00 - total_loss: 0.8765
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9393 - loss: 0.8840 - regularization_loss: 0.0000e+00 - total_loss: 0.8840
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9362 - loss: 0.8772 - regularization_loss: 0.0000e+00 - total_loss: 0.8772
5/5 [==============================] - 0s 3ms/step - RMSE: 0.9377 - loss: 0.8798 - regularization_loss: 0.0000e+00 - total_loss: 0.8798

نقوم بتقييم النموذج بناءً على بيانات الاختبار والإبلاغ عن المتوسط والانحراف المعياري من 5 عمليات تشغيل.

print("DCN            RMSE mean: {:.4f}, stdv: {:.4f}".format(
    dcn_result["mean"], dcn_result["stdv"]))
print("DCN (low-rank) RMSE mean: {:.4f}, stdv: {:.4f}".format(
    dcn_lr_result["mean"], dcn_lr_result["stdv"]))
print("DNN            RMSE mean: {:.4f}, stdv: {:.4f}".format(
    dnn_result["mean"], dnn_result["stdv"]))

DCN            RMSE mean: 0.9333, stdv: 0.0013
DCN (low-rank) RMSE mean: 0.9312, stdv: 0.0013
DNN            RMSE mean: 0.9389, stdv: 0.0039

نرى أن DCN حققت أداءً أفضل من DNN بالحجم نفسه مع طبقات ReLU. علاوة على ذلك ، كان DCN منخفض الرتبة قادرًا على تقليل المعلمات مع الحفاظ على الدقة.

المزيد عن DCN. وإلى جانب what've ثبت أعلاه، هناك طرق أكثر إبداعا ولكنها مفيدة عمليا للاستفادة DCN [ 1 ].

DCN مع هيكل مواز. يتم تغذية المدخلات بالتوازي مع شبكة متقاطعة وشبكة عميقة.
تسلسل الطبقات المتقاطعة. يتم تغذية المدخلات بالتوازي مع طبقات عرضية متعددة لالتقاط تقاطعات المعالم التكميلية.

اليسار: DCN مع هيكل مواز. اليمين: وصل طبقات الصليب.

فهم النموذج

الوزن مصفوفة \(W\) في DCN يكشف ما يعبر ميزة نموذج علمت أن تكون مهمة. أذكر أنه في لعبة المثال السابق، على أهمية التفاعل بين \(i\)-th و \(j\)يتم التقاطها -th يتميز بها (\(i, j\)) عنصر -th من \(W\).

ما هو مختلف قليلا هنا هو أن التضمينات ميزة ذات حجم 32 بدلا من حجم 1. وبالتالي، سوف تتميز الأهمية التي \((i, j)\)كتلة -th\(W_{i,j}\) وهو من البعد 32 من 32. في ما يلي، ونحن تصور القاعدة فروبينوس [ 4 ] \(||W_{i,j}||_F\) كل كتلة، وقاعدة أكبر أن أقترح أهمية أعلى (على افتراض التضمينات الميزات: عبارة عن جداول مماثلة).

إلى جانب قاعدة الكتلة ، يمكننا أيضًا تصور المصفوفة بأكملها ، أو القيمة المتوسطة / المتوسطة / القصوى لكل كتلة.

model = dcn_result["model"][0]
mat = model._cross_layer._dense.kernel
features = model._all_features

block_norm = np.ones([len(features), len(features)])

dim = model.embedding_dimension

# Compute the norms of the blocks.
for i in range(len(features)):
  for j in range(len(features)):
    block = mat[i * dim:(i + 1) * dim,
                j * dim:(j + 1) * dim]
    block_norm[i,j] = np.linalg.norm(block, ord="fro")

plt.figure(figsize=(9,9))
im = plt.matshow(block_norm, cmap=plt.cm.Blues)
ax = plt.gca()
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes("right", size="5%", pad=0.05)
plt.colorbar(im, cax=cax)
cax.tick_params(labelsize=10) 
_ = ax.set_xticklabels([""] + features, rotation=45, ha="left", fontsize=10)
_ = ax.set_yticklabels([""] + features, fontsize=10)

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:23: UserWarning: FixedFormatter should only be used together with FixedLocator
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:24: UserWarning: FixedFormatter should only be used together with FixedLocator
<Figure size 648x648 with 0 Axes>

بي إن جي

هذا كل شيء لهذا الكولاب! نأمل أن تكون قد استمتعت بتعلم بعض أساسيات DCN والطرق الشائعة لاستخدامها. إذا كنت مهتما بمعرفة المزيد، هل يمكن أن تحقق من ورقتين ذات الصلة: DCN-V1 ورقة ، DCN-V2 ورقة .

مراجع

DCN V2: تحسين ديب والصليب شبكة والدروس العملية للتعلم على شبكة الإنترنت على نطاق ولأنظمة الرتبة .
Ruoxi Wang، Rakesh Shivanna، Derek Zhiyuan Cheng، Sagar Jain، Dong Lin، Lichan Hong، Ed Chi. (2020)

ديب والصليب شبكة انقر التوقعات الإعلان .
Ruoxi Wang، Bin Fu، Gang Fu، Mingliang Wang. (AdKDD 2017)