 Xem trên TensorFlow.org |  Chạy trong Google Colab |  Xem nguồn trên GitHub |  Tải xuống sổ ghi chép |
Hướng dẫn này trình bày cách sử dụng Deep & Cross Network (DCN) để tìm hiểu các điểm giao nhau giữa các tính năng một cách hiệu quả.
Lý lịch
Dấu gạch chéo đặc điểm là gì và tại sao chúng lại quan trọng? Hãy tưởng tượng rằng chúng tôi đang xây dựng một hệ thống giới thiệu để bán máy xay sinh tố cho khách hàng. Sau đó, lịch sử mua quá khứ của một khách hàng như purchased_bananas và purchased_cooking_books , hoặc đặc điểm địa lý, là tính năng duy nhất. Nếu ai mua cả chuối và những cuốn sách nấu ăn, sau đó khách hàng này sẽ nhiều khả năng nhấp chuột vào máy xay sinh tố khuyến cáo. Sự kết hợp của purchased_bananas và purchased_cooking_books được gọi là một tính năng chéo, cung cấp thông tin tương tác bổ sung ngoài các tính năng cá nhân.
Những thách thức trong việc học tập chéo các tính năng là gì? Trong các ứng dụng quy mô Web, dữ liệu chủ yếu là phân loại, dẫn đến không gian tính năng lớn và thưa thớt. Việc xác định các điểm giao nhau hiệu quả trong cài đặt này thường yêu cầu kỹ thuật tính năng thủ công hoặc tìm kiếm đầy đủ. Các mô hình perceptron nhiều lớp chuyển tiếp truyền thống (MLP) là các bộ xấp xỉ hàm phổ quát; Tuy nhiên, họ không thể gần đúng hiệu quả thánh giá tính năng thậm chí 2 hoặc 3 bậc [ 1 , 2 ].
Deep & Cross Network (DCN) là gì? DCN được thiết kế để tìm hiểu các tính năng chéo rõ ràng và có giới hạn hiệu quả hơn. Nó bắt đầu với một lớp đầu vào (thường là một lớp nhúng), tiếp theo là một mạng lưới chéo chứa nhiều lớp chéo rằng các tương tác mô hình rõ ràng tính năng, và sau đó kết hợp với một mạng lưới sâu rằng các mô hình tương tác năng tiềm ẩn.
- Mạng chéo. Đây là cốt lõi của DCN. Nó áp dụng một cách rõ ràng tính năng giao nhau ở mỗi lớp và mức độ đa thức cao nhất sẽ tăng theo độ sâu của lớp. Con số chương trình sau khi \((i+1)\)-thứ lớp chéo.
- Mạng sâu. Nó là một perceptron đa lớp truyền thẳng (MLP) truyền thống.
Mạng lưới sâu và mạng chéo sau đó được kết hợp để tạo thành DCN [ 1 ]. Thông thường, chúng ta có thể xếp chồng một mạng sâu lên trên mạng chéo (cấu trúc xếp chồng lên nhau); chúng ta cũng có thể đặt chúng song song (cấu trúc song song).
Trong phần sau, trước tiên chúng tôi sẽ chỉ ra lợi thế của DCN với một ví dụ đồ chơi, sau đó chúng tôi sẽ hướng dẫn bạn một số cách phổ biến để sử dụng DCN bằng cách sử dụng tập dữ liệu MovieLen-1M.
Đầu tiên chúng ta hãy cài đặt và nhập các gói cần thiết cho chuyên mục này.
pip install -q tensorflow-recommenderspip 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
Ví dụ đồ chơi
Để minh họa những lợi ích của DCN, chúng ta hãy làm việc qua một ví dụ đơn giản. Giả sử chúng ta có một tập dữ liệu trong đó chúng ta đang cố gắng lập mô hình khả năng khách hàng nhấp vào Quảng cáo máy xay sinh tố, với các tính năng và nhãn của nó được mô tả như sau.
| Tính năng / Nhãn | Sự miêu tả | Loại / Phạm vi giá trị |
|---|---|---|
| \(x_1\) = nước | đất nước mà khách hàng này sinh sống | Int trong [0, 199] |
| \(x_2\) = chuối | # chuối mà khách hàng đã mua | Int trong [0, 23] |
| \(x_3\) = sách dạy nấu ăn | # sách nấu ăn mà khách hàng đã mua | Int trong [0, 5] |
| \(y\) | khả năng nhấp vào Quảng cáo máy xay sinh tố | - |
Sau đó, chúng tôi để dữ liệu tuân theo phân phối cơ bản sau:
\[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\]
nơi khả năng \(y\) phụ thuộc tuyến tính cả về tính năng \(x_i\)'s, mà còn trên các tương tác giữa các chất nhân \(x_i\)' s. Trong trường hợp của chúng tôi, chúng tôi sẽ nói rằng khả năng mua một máy xay sinh tố (\(y\)) không chỉ phụ thuộc vào việc mua chuối (\(x_2\)) hoặc sách dạy nấu ăn (\(x_3\)), nhưng cũng mua chuối và sách dạy nấu ăn với nhau (\(x_2x_3\)).
Chúng tôi có thể tạo dữ liệu cho việc này như sau:
Tạo dữ liệu tổng hợp
Đầu tiên chúng ta xác định \(f(x_1, x_2, x_3)\) như đã mô tả ở trên.
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
Hãy tạo dữ liệu tuân theo phân phối và chia dữ liệu thành 90% để đào tạo và 10% để kiểm tra.
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:]
Xây dựng mô hình
Chúng tôi sẽ thử cả mạng chéo và mạng sâu để minh họa lợi thế mà mạng chéo có thể mang lại cho người giới thiệu. Vì dữ liệu chúng tôi vừa tạo chỉ chứa các tương tác tính năng bậc 2, nên sẽ đủ để minh họa bằng mạng chéo một lớp. Nếu chúng tôi muốn mô hình hóa các tương tác tính năng bậc cao hơn, chúng tôi có thể xếp chồng nhiều lớp chéo và sử dụng mạng chéo nhiều lớp. Hai mô hình chúng tôi sẽ xây dựng là:
- Mạng chéo chỉ với một lớp chéo;
- Mạng sâu với các lớp ReLU rộng hơn và sâu hơn.
Đầu tiên, chúng tôi xây dựng một lớp mô hình thống nhất có tổn thất là lỗi bình phương trung bình.
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,
)
Sau đó, chúng tôi chỉ định mạng chéo (với 1 lớp chéo có kích thước 3) và DNN dựa trên ReLU (với kích thước lớp [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")
])
)
Đào tạo người mẫu
Bây giờ chúng tôi đã có dữ liệu và mô hình sẵn sàng, chúng tôi sẽ đào tạo các mô hình. Đầu tiên, chúng tôi xáo trộn và phân lô dữ liệu để chuẩn bị cho việc đào tạo mô hình.
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)
Sau đó, chúng tôi xác định số kỷ nguyên cũng như tỷ lệ học tập.
epochs = 100
learning_rate = 0.4
Được rồi, mọi thứ đã sẵn sàng bây giờ và hãy biên dịch và đào tạo các mô hình. Bạn có thể thiết lập verbose=True nếu bạn muốn xem như thế nào tiến bộ mô hình.
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>
Đánh giá mô hình
Chúng tôi xác minh hiệu suất mô hình trên tập dữ liệu đánh giá và báo cáo Lỗi bình phương trung bình gốc (RMSE, càng thấp càng tốt).
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.
Chúng tôi thấy rằng các mạng chéo độ lớn đạt được giảm RMSE hơn một DNN ReLU-based, với các thông số cường độ ít hơn. Điều này đã gợi ý về tính hiệu quả của một mạng lưới chéo trong việc học tập các phép lai giữa các môn học.
Hiểu mô hình
Chúng tôi đã biết những điểm chéo tính năng nào là quan trọng trong dữ liệu của mình, sẽ rất thú vị khi kiểm tra xem liệu mô hình của chúng tôi có thực sự học được dấu chấm điểm quan trọng hay không. Điều này có thể được thực hiện bằng cách trực quan hóa ma trận trọng lượng đã học trong DCN. Trọng lượng \(W_{ij}\) đại diện cho tầm quan trọng học của sự tương tác giữa các tính năng \(x_i\) và \(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>
Màu tối hơn thể hiện sự tương tác học được mạnh mẽ hơn - trong trường hợp này, rõ ràng là mô hình đã học được rằng việc mua babana và sách dạy nấu ăn cùng nhau là rất quan trọng.
Nếu bạn đang quan tâm đến việc cố gắng ra dữ liệu tổng hợp phức tạp hơn, cảm thấy tự do để kiểm tra giấy này .
Ví dụ 1M của Movielens
Bây giờ chúng ta xem xét tính hiệu quả của DCN trên một tập dữ liệu thực tế: MovieLens 1M [ 3 ]. Movielens 1M là một tập dữ liệu phổ biến để nghiên cứu khuyến nghị. Nó dự đoán xếp hạng phim của người dùng dựa trên các tính năng liên quan đến người dùng và các tính năng liên quan đến phim. Chúng tôi sử dụng tập dữ liệu này để trình bày một số cách phổ biến để sử dụng DCN.
Xử lí dữ liệu
Thủ tục xử lý dữ liệu sau một thủ tục tương tự như hướng dẫn xếp hạng cơ bản .
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.
Tiếp theo, chúng tôi chia ngẫu nhiên dữ liệu thành 80% để đào tạo và 20% để thử nghiệm.
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)
Sau đó, chúng tôi tạo từ vựng cho từng tính năng.
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)))
Xây dựng mô hình
Kiến trúc mô hình mà chúng ta sẽ xây dựng bắt đầu bằng một lớp nhúng, lớp này được đưa vào một mạng chéo, theo sau là một mạng sâu. Kích thước nhúng được đặt thành 32 cho tất cả các tính năng. Bạn cũng có thể sử dụng các kích thước nhúng khác nhau cho các tính năng khác nhau.
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,
)
Đào tạo người mẫu
Chúng tôi xáo trộn, hàng loạt và lưu vào bộ nhớ cache dữ liệu đào tạo và kiểm tra.
cached_train = train.shuffle(100_000).batch(8192).cache()
cached_test = test.batch(4096).cache()
Hãy xác định một hàm chạy một mô hình nhiều lần và trả về giá trị trung bình và độ lệch chuẩn RMSE của mô hình trong nhiều lần chạy.
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}
Chúng tôi thiết lập một số siêu tham số cho các mô hình. Lưu ý rằng các siêu tham số này được đặt chung cho tất cả các kiểu máy nhằm mục đích trình diễn. Nếu bạn muốn đạt được hiệu suất tốt nhất cho từng mô hình hoặc tiến hành so sánh công bằng giữa các mô hình, thì chúng tôi khuyên bạn nên tinh chỉnh các siêu thông số. Hãy nhớ rằng kiến trúc mô hình và các lược đồ tối ưu hóa được kết hợp với nhau.
epochs = 8
learning_rate = 0.01
DCN (xếp chồng lên nhau). Đầu tiên chúng tôi đào tạo một mô hình DCN có cấu trúc xếp chồng lên nhau, tức là, các đầu vào được cấp cho một mạng chéo, sau đó là một mạng sâu.
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 hạng thấp. Để giảm chi phí đào tạo và phục vụ, chúng tôi sử dụng các kỹ thuật xếp hạng thấp để tính gần đúng ma trận trọng lượng DCN. Mức xếp hạng này được thông qua năm qua lập luận projection_dim ; một nhỏ projection_dim kết quả trong một chi phí thấp hơn. Lưu ý rằng projection_dim nhu cầu phải nhỏ hơn (kích thước đầu vào) / 2 để giảm chi phí. Trong thực tế, chúng tôi đã quan sát thấy việc sử dụng DCN hạng thấp với hạng (kích thước đầu vào) / 4 luôn bảo toàn độ chính xác của DCN hạng đầy đủ.
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. Chúng tôi đào tạo một mô hình DNN có cùng kích thước để làm tham chiếu.
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
Chúng tôi đánh giá mô hình trên dữ liệu thử nghiệm và báo cáo giá trị trung bình và độ lệch chuẩn trong số 5 lần chạy.
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
Chúng tôi thấy rằng DCN đạt được hiệu suất tốt hơn so với DNN cùng kích thước với các lớp ReLU. Hơn nữa, DCN cấp thấp có thể giảm các thông số trong khi vẫn duy trì độ chính xác.
Thêm trên DCN. Bên cạnh what've được chứng minh trên, có sáng tạo thêm nhiều cách nhưng thực tế hữu ích để sử dụng DCN [ 1 ].
DCN với một cấu trúc song song. Các đầu vào được cấp song song thành mạng chéo và mạng sâu.
Ghép các lớp chéo. Các đầu vào được nạp song song vào nhiều lớp chéo để thu thập các tính năng bổ sung.
Hiểu mô hình
Ma trận cân \(W\) trong DCN tiết lộ những gì tính năng vượt qua các mô hình đã học được là quan trọng. Nhớ lại rằng trong ví dụ đồ chơi trước, tầm quan trọng của sự tương tác giữa các \(i\)-thứ và \(j\)-thứ tính năng được chụp bởi (\(i, j\)) yếu tố -thứ của \(W\).
Có gì hơi khác một chút ở đây là các tính năng embeddings có kích thước 32 thay vì kích thước 1. Do đó, tầm quan trọng sẽ được đặc trưng bởi sự \((i, j)\)khối -thứ\(W_{i,j}\) đó là chiều 32 bởi 32. Trong phần tiếp theo, chúng tôi hình thành tiêu chuẩn Frobenius [ 4 ] \(||W_{i,j}||_F\) của mỗi khối, và một mức lớn hơn sẽ đề nghị tầm quan trọng cao hơn (giả sử embeddings của tính năng này là quy mô tương tự).
Bên cạnh định mức khối, chúng tôi cũng có thể hình dung toàn bộ ma trận hoặc giá trị trung bình / trung vị / tối đa của mỗi khối.
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>
Đó là tất cả cho chuyên mục này! Chúng tôi hy vọng rằng bạn thích học một số kiến thức cơ bản về DCN và các cách phổ biến để sử dụng nó. Nếu bạn đang quan tâm đến việc tìm hiểu thêm, bạn có thể kiểm tra hai giấy tờ liên quan: DCN-v1-giấy , DCN-v2-giấy .
Người giới thiệu
DCN V2: Cải thiện Sâu & Mạng Chéo và bài học thực tiễn cho việc học tập Web quy mô để Systems Rank .
Ruoxi Wang, Rakesh Shivanna, Derek Zhiyuan Cheng, Sagar Jain, Dong Lin, Lichan Hong, Ed Chi. (2020)
Sâu & Mạng Chéo cho Bấm dự đoán tin rao .
Ruoxi Wang, Bin Fu, Gang Fu, Mingliang Wang. (AdKDD 2017)