结构化数据学习与TabTransformer
作者: Khalid Salama
创建日期: 2022/01/18
最后修改日期: 2022/01/18
描述: 使用上下文嵌入进行结构化数据分类。
介绍
本示例演示如何使用 TabTransformer进行结构化数据分类，这是一个用于监督学习和半监督学习的深度表格数据建模架构。 TabTransformer基于自注意力的变换器构建。 变换器层将类别特征的嵌入转化为强大的上下文嵌入，以实现更高的预测准确性。
设置
import keras
from keras import layers
from keras import ops
import math
import numpy as np
import pandas as pd
from tensorflow import data as tf_data
import matplotlib.pyplot as plt
from functools import partial
准备数据
本示例使用 美国人口普查收入数据集， 该数据集由 加州大学欧文分校机器学习库提供。 任务是二分类， 以预测一个人是否可能年收入超过50,000美元。
该数据集包括48,842个实例和14个输入特征：5个数值特征和9个类别特征。
首先，让我们从UCI机器学习库加载数据集到Pandas DataFrame中：
CSV_HEADER = [
"age",
"workclass",
"fnlwgt",
"education",
"education_num",
"marital_status",
"occupation",
"relationship",
"race",
"gender",
"capital_gain",
"capital_loss",
"hours_per_week",
"native_country",
"income_bracket",
]
train_data_url = (
"https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
)
train_data = pd.read_csv(train_data_url, header=None, names=CSV_HEADER)
test_data_url = (
"https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"
)
test_data = pd.read_csv(test_data_url, header=None, names=CSV_HEADER)
print(f"Train dataset shape: {train_data.shape}")
print(f"Test dataset shape: {test_data.shape}")
训练数据集形状: (32561, 15)
测试数据集形状: (16282, 15)
移除第一条记录（因为它不是有效的数据示例）并删除类标签中的末尾“点”。
test_data = test_data[1:]
test_data.income_bracket = test_data.income_bracket.apply(
lambda value: value.replace(".", "")
)
现在我们将训练数据和测试数据存储在单独的CSV文件中。
train_data_file = "train_data.csv"
test_data_file = "test_data.csv"
train_data.to_csv(train_data_file, index=False, header=False)
test_data.to_csv(test_data_file, index=False, header=False)
定义数据集元数据
在这里，我们定义数据集的元数据，这将有助于读取和解析 数据为输入特征，并根据特征类型对输入特征进行编码。
数值特征名称的列表。
NUMERIC_FEATURE_NAMES = [ "age", "education_num", "capital_gain", "capital_loss", "hours_per_week", ]
分类特征及其词汇的字典。
CATEGORICAL_FEATURES_WITH_VOCABULARY = { "workclass": sorted(list(train_data["workclass"].unique())), "education": sorted(list(train_data["education"].unique())), "marital_status": sorted(list(train_data["marital_status"].unique())), "occupation": sorted(list(train_data["occupation"].unique())), "relationship": sorted(list(train_data["relationship"].unique())), "race": sorted(list(train_data["race"].unique())), "gender": sorted(list(train_data["gender"].unique())), "native_country": sorted(list(train_data["native_country"].unique())), }
用作实例权重的列名称。
WEIGHT_COLUMN_NAME = "fnlwgt"
分类特征名称的列表。
CATEGORICAL_FEATURE_NAMES = list(CATEGORICAL_FEATURES_WITH_VOCABULARY.keys())
所有输入特征的列表。
FEATURE_NAMES = NUMERIC_FEATURE_NAMES + CATEGORICAL_FEATURE_NAMES
每个特征的列默认值列表。
COLUMN_DEFAULTS = [ [0.0] if feature_name in NUMERIC_FEATURE_NAMES + [WEIGHT_COLUMN_NAME] else ["NA"] for feature_name in CSV_HEADER ]
目标特征的名称。
TARGET_FEATURE_NAME = "income_bracket"
目标特征标签的列表。
TARGET_LABELS = [" <=50K", " >50K"]
配置超参数
超参数包括模型架构和训练配置。
LEARNING_RATE = 0.001
WEIGHT_DECAY = 0.0001
DROPOUT_RATE = 0.2
BATCH_SIZE = 265
NUM_EPOCHS = 15
NUM_TRANSFORMER_BLOCKS = 3 # transformer块的数量。
NUM_HEADS = 4 # 注意力头的数量。
EMBEDDING_DIMS = 16 # 分类特征的嵌入维度。
MLP_HIDDEN_UNITS_FACTORS = [
2,
1,
] # MLP隐藏层单元，作为输入数量的因子。
NUM_MLP_BLOCKS = 2 # 基线模型中MLP块的数量。
实现数据读取管道
我们定义一个输入函数来读取和解析文件，然后将特征和标签转换为一个tf.data.Dataset用于训练或评估。
target_label_lookup = layers.StringLookup(
vocabulary=TARGET_LABELS, mask_token=None, num_oov_indices=0
)
def prepare_example(features, target):
target_index = target_label_lookup(target)
weights = features.pop(WEIGHT_COLUMN_NAME)
return features, target_index, weights
lookup_dict = {}
for feature_name in CATEGORICAL_FEATURE_NAMES:
vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[feature_name]
# 创建一个查找，将字符串值转换为整数索引。
# 由于我们不使用掩码标记，也不期望任何超出词汇表外的
# (oov) 标记，因此我们将mask_token设置为None，num_oov_indices设置为0。
lookup = layers.StringLookup(
vocabulary=vocabulary, mask_token=None, num_oov_indices=0
)
lookup_dict[feature_name] = lookup
def encode_categorical(batch_x, batch_y, weights):
for feature_name in CATEGORICAL_FEATURE_NAMES:
batch_x[feature_name] = lookup_dict[feature_name](batch_x[feature_name])
return batch_x, batch_y, weights
def get_dataset_from_csv(csv_file_path, batch_size=128, shuffle=False):
dataset = (
tf_data.experimental.make_csv_dataset(
csv_file_path,
batch_size=batch_size,
column_names=CSV_HEADER,
column_defaults=COLUMN_DEFAULTS,
label_name=TARGET_FEATURE_NAME,
num_epochs=1,
header=False,
na_value="?",
shuffle=shuffle,
)
.map(prepare_example, num_parallel_calls=tf_data.AUTOTUNE, deterministic=False)
.map(encode_categorical)
)
return dataset.cache()
实现训练和评估过程
def run_experiment(
model,
train_data_file,
test_data_file,
num_epochs,
learning_rate,
weight_decay,
batch_size,
):
optimizer = keras.optimizers.AdamW(
learning_rate=learning_rate, weight_decay=weight_decay
)
model.compile(
optimizer=optimizer,
loss=keras.losses.BinaryCrossentropy(),
metrics=[keras.metrics.BinaryAccuracy(name="accuracy")],
)
train_dataset = get_dataset_from_csv(train_data_file, batch_size, shuffle=True)
validation_dataset = get_dataset_from_csv(test_data_file, batch_size)
print("开始训练模型...")
history = model.fit(
train_dataset, epochs=num_epochs, validation_data=validation_dataset
)
print("模型训练完成")
_, accuracy = model.evaluate(validation_dataset, verbose=0)
print(f"验证准确率: {round(accuracy * 100, 2)}%")
return history
创建模型输入
现在，定义模型的输入为字典，其中键为特征名称，值为具有相应特征形状和数据类型的 keras.layers.Input 张量。
def create_model_inputs():
inputs = {}
for feature_name in FEATURE_NAMES:
if feature_name in NUMERIC_FEATURE_NAMES:
inputs[feature_name] = layers.Input(
name=feature_name, shape=(), dtype="float32"
)
else:
inputs[feature_name] = layers.Input(
name=feature_name, shape=(), dtype="int32"
)
return inputs
编码特征
encode_inputs方法返回encoded_categorical_feature_list和numerical_feature_list。
我们将分类特征编码为嵌入，对于所有特征使用固定的embedding_dims，无论其词汇表大小。这是Transformer模型所要求的。
def encode_inputs(inputs, embedding_dims):
encoded_categorical_feature_list = []
numerical_feature_list = []
for feature_name in inputs:
if feature_name in CATEGORICAL_FEATURE_NAMES:
vocabulary = CATEGORICAL_FEATURES_WITH_VOCABULARY[feature_name]
# 创建查找表将字符串值转换为整数索引。
# 由于我们既不使用掩码令牌，也不期待任何词汇外
# (oov) 令牌，因此我们将 mask_token 设置为 None，num_oov_indices 设置为 0。
# 将字符串输入值转换为整数索引。
# 创建具有指定维度的嵌入层。
embedding = layers.Embedding(
input_dim=len(vocabulary), output_dim=embedding_dims
)
# 将索引值转换为嵌入表示。
encoded_categorical_feature = embedding(inputs[feature_name])
encoded_categorical_feature_list.append(encoded_categorical_feature)
else:
# 直接使用数值特征。
numerical_feature = ops.expand_dims(inputs[feature_name], -1)
numerical_feature_list.append(numerical_feature)
return encoded_categorical_feature_list, numerical_feature_list
实现一个MLP块
def create_mlp(hidden_units, dropout_rate, activation, normalization_layer, name=None):
mlp_layers = []
for units in hidden_units:
mlp_layers.append(normalization_layer())
mlp_layers.append(layers.Dense(units, activation=activation))
mlp_layers.append(layers.Dropout(dropout_rate))
return keras.Sequential(mlp_layers, name=name)
实验1：基线模型
在第一个实验中，我们创建一个简单的多层前馈网络。
def create_baseline_model(
embedding_dims, num_mlp_blocks, mlp_hidden_units_factors, dropout_rate
):
# 创建模型输入。
inputs = create_model_inputs()
# 编码特征。
encoded_categorical_feature_list, numerical_feature_list = encode_inputs(
inputs, embedding_dims
)
# 连接所有特征。
features = layers.concatenate(
encoded_categorical_feature_list + numerical_feature_list
)
# 计算前馈层单元。
feedforward_units = [features.shape[-1]]
# 创建几个带有跳过连接的前馈层。
for layer_idx in range(num_mlp_blocks):
features = create_mlp(
hidden_units=feedforward_units,
dropout_rate=dropout_rate,
activation=keras.activations.gelu,
normalization_layer=layers.LayerNormalization,
name=f"feedforward_{layer_idx}",
)(features)
# 计算MLP隐藏单元。
mlp_hidden_units = [
factor * features.shape[-1] for factor in mlp_hidden_units_factors
]
# 创建最终的MLP。
features = create_mlp(
hidden_units=mlp_hidden_units,
dropout_rate=dropout_rate,
activation=keras.activations.selu,
normalization_layer=layers.BatchNormalization,
name="MLP",
)(features)
# 添加一个sigmoid作为二元分类器。
outputs = layers.Dense(units=1, activation="sigmoid", name="sigmoid")(features)
model = keras.Model(inputs=inputs, outputs=outputs)
return model
baseline_model = create_baseline_model(
embedding_dims=EMBEDDING_DIMS,
num_mlp_blocks=NUM_MLP_BLOCKS,
mlp_hidden_units_factors=MLP_HIDDEN_UNITS_FACTORS,
dropout_rate=DROPOUT_RATE,
)
print("总模型权重:", baseline_model.count_params())
keras.utils.plot_model(baseline_model, show_shapes=True, rankdir="LR")
本机上可能存在NVIDIA GPU，但未安装CUDA支持的jaxlib。回退到cpu。
总模型权重: 110693
让我们训练和评估基线模型：
history = run_experiment(
model=baseline_model,
train_data_file=train_data_file,
test_data_file=test_data_file,
num_epochs=NUM_EPOCHS,
learning_rate=LEARNING_RATE,
weight_decay=WEIGHT_DECAY,
batch_size=BATCH_SIZE,
)
开始训练模型...
第 1 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 13s 70ms/步 - 准确率: 0.6912 - 损失: 127137.3984 - 验证准确率: 0.7623 - 验证损失: 96156.1875
第 2 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.7626 - 损失: 102946.6797 - 验证准确率: 0.7699 - 验证损失: 77236.8828
第 3 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.7738 - 损失: 82999.3281 - 验证准确率: 0.8154 - 验证损失: 70085.9609
第 4 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.7981 - 损失: 75569.4375 - 验证准确率: 0.8111 - 验证损失: 69759.5547
第 5 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8006 - 损失: 74234.1641 - 验证准确率: 0.7968 - 验证损失: 71532.2422
第 6 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8074 - 损失: 71770.2891 - 验证准确率: 0.8082 - 验证损失: 69105.5078
第 7 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8118 - 损失: 70526.6797 - 验证准确率: 0.8094 - 验证损失: 68746.7891
第 8 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8110 - 损失: 70309.3750 - 验证准确率: 0.8132 - 验证损失: 68305.1328
第 9 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8143 - 损失: 69896.9141 - 验证准确率: 0.8046 - 验证损失: 70013.1016
第 10 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8124 - 损失: 69885.8281 - 验证准确率: 0.8037 - 验证损失: 70305.7969
第 11 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8131 - 损失: 69193.8203 - 验证准确率: 0.8075 - 验证损失: 69615.5547
第 12 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8148 - 损失: 68933.5703 - 验证准确率: 0.7997 - 验证损失: 70789.2422
第 13 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8146 - 损失: 68929.5078 - 验证准确率: 0.8104 - 验证损失: 68525.1016
第 14 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 3s 26ms/步 - 准确率: 0.8174 - 损失: 68447.2500 - 验证准确率: 0.8119 - 验证损失: 68787.0078
第 15 轮/15
123/123 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/步 - 准确率: 0.8184 - 损失: 68346.5391 - 验证准确率: 0.8143 - 验证损失: 68101.9531
模型训练结束
验证准确率: 81.43%
实验2：TabTransformer
TabTransformer架构的工作原理如下：
- 所有的类别特征都被编码为嵌入，使用相同的
embedding_dims。 这意味着每个类别特征中的每个值都有其自己的嵌入向量。 - 为每个类别特征添加一个列嵌入，让每个类别特征都有一个嵌入向量（逐点相加）。
- 嵌入的类别特征被输入到一堆Transformer块中。 每个Transformer块由一个多头自注意力层和一个前馈层组成。
- 最后一个Transformer层的输出，即类别特征的上下文嵌入， 与输入的数值特征连接在一起，并输入到最后的MLP块。
- 在模型末尾应用一个
softmax分类器。
论文在附录：实验与模型细节部分讨论了列嵌入的加法和连接。 下图展示了TabTransformer的架构，来自于论文中。
def create_tabtransformer_classifier(
num_transformer_blocks,
num_heads,
embedding_dims,
mlp_hidden_units_factors,
dropout_rate,
use_column_embedding=False,
):
# 创建模型输入。
inputs = create_model_inputs()
# 编码特征。
encoded_categorical_feature_list, numerical_feature_list = encode_inputs(
inputs, embedding_dims
)
# 堆叠分类特征嵌入到 Transformer 中。
encoded_categorical_features = ops.stack(encoded_categorical_feature_list, axis=1)
# 连接数值特征。
numerical_features = layers.concatenate(numerical_feature_list)
# 将列嵌入添加到分类特征嵌入中。
if use_column_embedding:
num_columns = encoded_categorical_features.shape[1]
column_embedding = layers.Embedding(
input_dim=num_columns, output_dim=embedding_dims
)
column_indices = ops.arange(start=0, stop=num_columns, step=1)
encoded_categorical_features = encoded_categorical_features + column_embedding(
column_indices
)
# 创建多个 Transformer 块的层。
for block_idx in range(num_transformer_blocks):
# 创建一个多头注意力层。
attention_output = layers.MultiHeadAttention(
num_heads=num_heads,
key_dim=embedding_dims,
dropout=dropout_rate,
name=f"multihead_attention_{block_idx}",
)(encoded_categorical_features, encoded_categorical_features)
# 跳过连接 1。
x = layers.Add(name=f"skip_connection1_{block_idx}")(
[attention_output, encoded_categorical_features]
)
# 层归一化 1。
x = layers.LayerNormalization(name=f"layer_norm1_{block_idx}", epsilon=1e-6)(x)
# 前馈。
feedforward_output = create_mlp(
hidden_units=[embedding_dims],
dropout_rate=dropout_rate,
activation=keras.activations.gelu,
normalization_layer=partial(
layers.LayerNormalization, epsilon=1e-6
), # 使用 partial 提供关键字参数
name=f"feedforward_{block_idx}",
)(x)
# 跳过连接 2。
x = layers.Add(name=f"skip_connection2_{block_idx}")([feedforward_output, x])
# 层归一化 2。
encoded_categorical_features = layers.LayerNormalization(
name=f"layer_norm2_{block_idx}", epsilon=1e-6
)(x)
# 扁平化分类特征的“上下文化”嵌入。
categorical_features = layers.Flatten()(encoded_categorical_features)
# 对数值特征应用层归一化。
numerical_features = layers.LayerNormalization(epsilon=1e-6)(numerical_features)
# 为最终的 MLP 块准备输入。
features = layers.concatenate([categorical_features, numerical_features])
# 计算 MLP 隐藏单元。
mlp_hidden_units = [
factor * features.shape[-1] for factor in mlp_hidden_units_factors
]
# 创建最终的 MLP。
features = create_mlp(
hidden_units=mlp_hidden_units,
dropout_rate=dropout_rate,
activation=keras.activations.selu,
normalization_layer=layers.BatchNormalization,
name="MLP",
)(features)
# 添加 sigmoid 作为二分类器。
outputs = layers.Dense(units=1, activation="sigmoid", name="sigmoid")(features)
model = keras.Model(inputs=inputs, outputs=outputs)
return model
tabtransformer_model = create_tabtransformer_classifier(
num_transformer_blocks=NUM_TRANSFORMER_BLOCKS,
num_heads=NUM_HEADS,
embedding_dims=EMBEDDING_DIMS,
mlp_hidden_units_factors=MLP_HIDDEN_UNITS_FACTORS,
dropout_rate=DROPOUT_RATE,
)
print("总模型权重:", tabtransformer_model.count_params())
keras.utils.plot_model(tabtransformer_model, show_shapes=True, rankdir="LR")
总模型权重： 88543
让我们训练和评估 TabTransformer 模型：
history = run_experiment(
model=tabtransformer_model,
train_data_file=train_data_file,
test_data_file=test_data_file,
num_epochs=NUM_EPOCHS,
learning_rate=LEARNING_RATE,
weight_decay=WEIGHT_DECAY,
batch_size=BATCH_SIZE,
)
开始训练模型...
第 1/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 46s 272ms/步 - 准确率: 0.7504 - 损失: 103329.7578 - 验证准确率: 0.7637 - 验证损失: 122401.2188
第 2/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 8s 62ms/步 - 准确率: 0.8033 - 损失: 79797.0469 - 验证准确率: 0.7712 - 验证损失: 97510.0000
第 3/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8202 - 损失: 73736.2500 - 验证准确率: 0.8037 - 验证损失: 79687.8906
第 4/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8247 - 损失: 70282.2031 - 验证准确率: 0.8355 - 验证损失: 64703.9453
第 5/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8317 - 损失: 67661.8906 - 验证准确率: 0.8427 - 验证损失: 64015.5156
第 6/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8333 - 损失: 67486.6562 - 验证准确率: 0.8402 - 验证损失: 65543.7188
第 7/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8359 - 损失: 66328.3516 - 验证准确率: 0.8360 - 验证损失: 68744.6484
第 8/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8354 - 损失: 66040.3906 - 验证准确率: 0.8209 - 验证损失: 72937.5703
第 9/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8376 - 损失: 65606.2344 - 验证准确率: 0.8298 - 验证损失: 72673.2031
第 10/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8395 - 损失: 65170.4375 - 验证准确率: 0.8259 - 验证损失: 70717.4922
第 11/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 8s 62ms/步 - 准确率: 0.8395 - 损失: 65003.5820 - 验证准确率: 0.8481 - 验证损失: 62421.4102
第 12/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 12s 94ms/步 - 准确率: 0.8396 - 损失: 64860.1797 - 验证准确率: 0.8482 - 验证损失: 63217.3516
第 13/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 6s 52ms/步 - 准确率: 0.8412 - 损失: 64597.3945 - 验证准确率: 0.8256 - 验证损失: 71274.4609
第 14/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 11s 94ms/步 - 准确率: 0.8419 - 损失: 63789.4688 - 验证准确率: 0.8473 - 验证损失: 63099.7422
第 15/15 轮
123/123 ━━━━━━━━━━━━━━━━━━━━ 11s 94ms/步 - 准确率: 0.8427 - 损失: 63856.9531 - 验证准确率: 0.8459 - 验证损失: 64541.9688
模型训练完成
验证准确率: 84.59%
TabTransformer 模型实现了 ~85% 的验证准确率。 请注意，在默认参数配置下，基线和 TabTransformer 具有相似的可训练权重数量：分别为 109,629 和 92,151，两者使用相同的训练超参数。
结论
TabTransformer 在表格数据上显著超越了 MLP 和最近的深度网络，同时匹配树结构集成模型的性能。 TabTransformer 可以通过使用带标签示例的端到端监督训练进行学习。 对于带标签示例较少而无标签示例较多的场景，可以采用预训练程序，利用无标签数据训练 Transformer 层。 然后，使用带标签数据微调预训练的 Transformer 层及顶部 MLP 层。