FeatureSpace 高级用例
作者： Dimitre Oliveira
创建日期 2023/07/01
上次修改日期 2023/07/01
描述：如何将 FeatureSpace 用于高级预处理用例。
简介
此示例是 使用 FeatureSpace 进行结构化数据分类 代码示例的扩展，我们将在此基础上扩展它，以涵盖 [keras.utils.FeatureSpace](/api/utils/feature_space#featurespace-class) 预处理工具的更复杂用例，例如特征哈希、特征交叉、处理缺失值以及将 Keras 预处理层 与 FeatureSpace 集成。
总体任务仍然是使用包含数值特征、整数类别特征和字符串类别特征的数据进行结构化数据分类（也称为表格数据分类）。
数据集
我们的数据集 由一家葡萄牙银行机构提供。它是一个包含 4119 行的 CSV 文件。每行包含基于电话呼叫的营销活动的信息，每列描述客户的一个属性。我们使用这些特征来预测客户是否（“是”）订阅了产品（银行定期存款）。
以下是每个特征的描述
| 列名 | 描述 | 特征类型 |
|---|---|---|
| 年龄 | 客户的年龄 | 数值型 |
| 职业 | 工作类型 | 类别型 |
| 婚姻状况 | 婚姻状况 | 类别型 |
| 教育程度 | 客户的教育水平 | 类别型 |
| 违约 | 是否有信用违约？ | 类别型 |
| 住房 | 是否有住房贷款？ | 类别型 |
| 贷款 | 是否有个人贷款？ | 类别型 |
| 联系方式 | 联系沟通类型 | 类别型 |
| 月份 | 去年联系的月份 | 类别型 |
| 星期几 | 去年联系的星期几 | 类别型 |
| 时长 | 上次联系的时长（秒） | 数值型 |
| 活动次数 | 在此活动中针对此客户执行的联系次数 | 数值型 |
| 上次联系天数 | 客户上次从之前的活动中被联系后经过的天数 | 数值型 |
| 先前联系次数 | 在此活动之前针对此客户执行的联系次数 | 数值型 |
| 先前活动结果 | 先前营销活动的结果 | 类别型 |
| 就业变化率 | 就业变化率 | 数值型 |
| 消费者物价指数 | 消费者物价指数 | 数值型 |
| 消费者信心指数 | 消费者信心指数 | 数值型 |
| 3个月欧元利率 | 3个月欧元利率 | 数值型 |
| 雇员人数 | 雇员人数 | 数值型 |
| Y | 客户是否订阅了定期存款？ | 目标 |
关于特征 duration 的重要说明：此属性极大地影响输出目标（例如，如果 duration=0 则 y='no'）。但是，在进行电话呼叫之前，时长是未知的。此外，在呼叫结束后，y 显而易见。因此，此输入仅应包含用于基准测试目的，如果目的是构建一个现实的预测模型，则应将其丢弃。出于这个原因，我们将删除它。
设置
import os
os.environ["KERAS_BACKEND"] = "tensorflow"
import keras
from keras.utils import FeatureSpace
import pandas as pd
import tensorflow as tf
from pathlib import Path
from zipfile import ZipFile
加载数据
让我们下载数据并将其加载到 Pandas 数据框中。
data_url = "https://archive.ics.uci.edu/static/public/222/bank+marketing.zip"
data_zipped_path = keras.utils.get_file("bank_marketing.zip", data_url, extract=True)
keras_datasets_path = Path(data_zipped_path).parents[0]
with ZipFile(f"{keras_datasets_path}/bank-additional.zip", "r") as zip:
# Extract files
zip.extractall(path=keras_datasets_path)
dataframe = pd.read_csv(
f"{keras_datasets_path}/bank-additional/bank-additional.csv", sep=";"
)
我们将创建一个新的特征 previously_contacted 以能够演示一些有用的预处理技术，此特征基于 pdays。根据数据集信息，如果 pdays = 999，则表示客户以前从未被联系过，因此让我们创建一个特征来捕获这一点。
# Droping `duration` to avoid target leak
dataframe.drop("duration", axis=1, inplace=True)
# Creating the new feature `previously_contacted`
dataframe["previously_contacted"] = dataframe["pdays"].map(
lambda x: 0 if x == 999 else 1
)
数据集包含 4119 个样本，每个样本有 21 列（20 个特征加上目标标签），以下是几个样本的预览。
print(f"Dataframe shape: {dataframe.shape}")
print(dataframe.head())
Dataframe shape: (4119, 21)
age job marital education default housing loan \
0 30 blue-collar married basic.9y no yes no
1 39 services single high.school no no no
2 25 services married high.school no yes no
3 38 services married basic.9y no unknown unknown
4 47 admin. married university.degree no yes no
contact month day_of_week ... pdays previous poutcome \
0 cellular may fri ... 999 0 nonexistent
1 telephone may fri ... 999 0 nonexistent
2 telephone jun wed ... 999 0 nonexistent
3 telephone jun fri ... 999 0 nonexistent
4 cellular nov mon ... 999 0 nonexistent
emp.var.rate cons.price.idx cons.conf.idx euribor3m nr.employed y \
0 -1.8 92.893 -46.2 1.313 5099.1 no
1 1.1 93.994 -36.4 4.855 5191.0 no
2 1.4 94.465 -41.8 4.962 5228.1 no
3 1.4 94.465 -41.8 4.959 5228.1 no
4 -0.1 93.200 -42.0 4.191 5195.8 no
previously_contacted
0 0
1 0
2 0
3 0
4 0
[5 rows x 21 columns]
列“y”表示客户是否订阅了定期存款。
训练/验证集分割
让我们将数据分割成训练集和验证集。
valid_dataframe = dataframe.sample(frac=0.2, random_state=0)
train_dataframe = dataframe.drop(valid_dataframe.index)
print(
f"Using {len(train_dataframe)} samples for training and "
f"{len(valid_dataframe)} for validation"
)
Using 3295 samples for training and 824 for validation
生成 TF 数据集
让我们为每个数据框生成 [tf.data.Dataset](https://tensorflowcn.cn/api_docs/python/tf/data/Dataset) 对象，由于我们的目标列 y 是一个字符串，我们还需要将其编码为整数，以便能够使用它来训练我们的模型。为此，我们将创建一个 StringLookup 层，它将字符串“no”和“yes”分别映射到“0”和“1”。
label_lookup = keras.layers.StringLookup(
# the order here is important since the first index will be encoded as 0
vocabulary=["no", "yes"],
num_oov_indices=0,
)
def encode_label(x, y):
encoded_y = label_lookup(y)
return x, encoded_y
def dataframe_to_dataset(dataframe):
dataframe = dataframe.copy()
labels = dataframe.pop("y")
ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
ds = ds.map(encode_label, num_parallel_calls=tf.data.AUTOTUNE)
ds = ds.shuffle(buffer_size=len(dataframe))
return ds
train_ds = dataframe_to_dataset(train_dataframe)
valid_ds = dataframe_to_dataset(valid_dataframe)
每个 Dataset 生成一个元组 (input, target)，其中 input 是特征的字典，target 是值 0 或 1。
for x, y in dataframe_to_dataset(train_dataframe).take(1):
print(f"Input: {x}")
print(f"Target: {y}")
Input: {'age': <tf.Tensor: shape=(), dtype=int64, numpy=33>, 'job': <tf.Tensor: shape=(), dtype=string, numpy=b'technician'>, 'marital': <tf.Tensor: shape=(), dtype=string, numpy=b'married'>, 'education': <tf.Tensor: shape=(), dtype=string, numpy=b'university.degree'>, 'default': <tf.Tensor: shape=(), dtype=string, numpy=b'unknown'>, 'housing': <tf.Tensor: shape=(), dtype=string, numpy=b'yes'>, 'loan': <tf.Tensor: shape=(), dtype=string, numpy=b'no'>, 'contact': <tf.Tensor: shape=(), dtype=string, numpy=b'cellular'>, 'month': <tf.Tensor: shape=(), dtype=string, numpy=b'aug'>, 'day_of_week': <tf.Tensor: shape=(), dtype=string, numpy=b'tue'>, 'campaign': <tf.Tensor: shape=(), dtype=int64, numpy=1>, 'pdays': <tf.Tensor: shape=(), dtype=int64, numpy=999>, 'previous': <tf.Tensor: shape=(), dtype=int64, numpy=0>, 'poutcome': <tf.Tensor: shape=(), dtype=string, numpy=b'nonexistent'>, 'emp.var.rate': <tf.Tensor: shape=(), dtype=float64, numpy=1.4>, 'cons.price.idx': <tf.Tensor: shape=(), dtype=float64, numpy=93.444>, 'cons.conf.idx': <tf.Tensor: shape=(), dtype=float64, numpy=-36.1>, 'euribor3m': <tf.Tensor: shape=(), dtype=float64, numpy=4.963>, 'nr.employed': <tf.Tensor: shape=(), dtype=float64, numpy=5228.1>, 'previously_contacted': <tf.Tensor: shape=(), dtype=int64, numpy=0>}
Target: 0
预处理
通常，我们的数据并非处于建模的适当或最佳格式，因此大多数时候我们需要对特征进行某种预处理，以使它们与模型兼容或为任务提取最多的信息。我们需要为训练执行此预处理步骤，但在推理时，我们还需要确保数据经过相同的处理过程，这就是 FeatureSpace 等实用程序大放异彩的地方，我们可以一次定义所有预处理并在系统的不同阶段重复使用它。
在这里，我们将了解如何使用 FeatureSpace 执行更复杂的转换及其灵活性，然后将所有内容组合到一个组件中，以预处理模型的数据。
FeatureSpace 实用程序通过使用 adapt() 函数从数据中学习来学习如何处理数据，这需要一个仅包含特征的数据集，因此让我们与一个实用函数一起创建它，以在实践中展示预处理示例。
train_ds_with_no_labels = train_ds.map(lambda x, _: x)
def example_feature_space(dataset, feature_space, feature_names):
feature_space.adapt(dataset)
for x in dataset.take(1):
inputs = {feature_name: x[feature_name] for feature_name in feature_names}
preprocessed_x = feature_space(inputs)
print(f"Input: {[{k:v.numpy()} for k, v in inputs.items()]}")
print(
f"Preprocessed output: {[{k:v.numpy()} for k, v in preprocessed_x.items()]}"
)
特征哈希
特征哈希是指将一组值哈希或编码到定义数量的箱中，在本例中，我们有 campaign（在此活动中针对某个客户执行的联系次数），它是一个可以取不同值范围的数值特征，我们将将其哈希到 4 个箱中，这意味着原始特征的任何可能值都将被放入这 4 个可能的箱中的一个。这里的输出可以是独热编码的向量或单个数字。
feature_space = FeatureSpace(
features={
"campaign": FeatureSpace.integer_hashed(num_bins=4, output_mode="one_hot")
},
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["campaign"])
Input: [{'campaign': 1}]
Preprocessed output: [{'campaign': array([0., 1., 0., 0.], dtype=float32)}]
特征哈希也可以用于字符串特征。
feature_space = FeatureSpace(
features={
"education": FeatureSpace.string_hashed(num_bins=3, output_mode="one_hot")
},
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["education"])
Input: [{'education': b'basic.9y'}]
Preprocessed output: [{'education': array([0., 1., 0.], dtype=float32)}]
对于数值特征，我们可以使用 float_discretized 选项获得类似的行为，它与 integer_hashed 之间的主要区别在于，前者对值进行分箱，同时保留一些数值关系（接近的值很可能被放入同一个箱中），而后者（哈希）不能保证这些数字会被哈希到同一个箱中，它取决于哈希函数。
feature_space = FeatureSpace(
features={"age": FeatureSpace.float_discretized(num_bins=3, output_mode="one_hot")},
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["age"])
Input: [{'age': 40}]
Preprocessed output: [{'age': array([0., 1., 0.], dtype=float32)}]
特征索引
对字符串特征进行索引本质上意味着为其创建离散的数值表示，这对于字符串特征尤其重要，因为大多数模型只接受数值特征。此转换将字符串值放入不同的类别中。这里的输出可以是独热编码的向量或单个数字。
请注意，通过指定 num_oov_indices=1，我们在输出向量中为 OOV（超出词汇表）值留了一个位置，这是处理训练后缺失或看不见的值（在 adapt() 步骤中未见过的值）的重要工具。
feature_space = FeatureSpace(
features={
"default": FeatureSpace.string_categorical(
num_oov_indices=1, output_mode="one_hot"
)
},
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["default"])
Input: [{'default': b'unknown'}]
Preprocessed output: [{'default': array([0., 0., 1., 0.], dtype=float32)}]
我们也可以对整数特征进行特征索引，这对于某些数据集来说非常重要，在这些数据集中，类别特征被数字替换，例如 sex 或 gender 等特征，其中值（1 和 0）之间没有数值关系，它们只是不同的类别，此行为可以通过此转换完美地捕获。
在此数据集中，我们可以使用我们创建的特征 previously_contacted。对于这种情况，我们想要显式地设置 num_oov_indices=0，原因是对于该特征，我们只期望两个可能的值，其他任何值都将是错误的输入或数据创建问题，因此我们可能只是希望代码抛出错误，以便我们能够意识到问题并修复它。
feature_space = FeatureSpace(
features={
"previously_contacted": FeatureSpace.integer_categorical(
num_oov_indices=0, output_mode="one_hot"
)
},
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["previously_contacted"])
Input: [{'previously_contacted': 0}]
Preprocessed output: [{'previously_contacted': array([1., 0.], dtype=float32)}]
特征交叉（混合不同类型的特征）
使用交叉，我们可以对任意数量的混合类型特征进行特征交互，只要它们是类别特征即可，您可以想象，与其拥有一个特征 {'age': 20} 和另一个 {'job': 'entrepreneur'}，不如拥有 {'age_X_job': 20_entrepreneur}，但是使用 FeatureSpace 和交叉，我们可以对每个单独的特征和特征交叉本身应用特定的预处理。此选项对于特定用例可能非常强大，这里可能是不错的选择，因为年龄与职业的组合对于银行领域可能具有不同的含义。
我们将交叉 age 和 job，并将它们的组合输出哈希到大小为 8 的向量表示中。这里的输出可以是独热编码的向量或单个数字。
有时多个特征的组合会导致超大的特征空间，想想将某人的邮政编码与其姓氏交叉，可能性将达到数千种，这就是 crossing_dim 参数如此重要的原因，它限制了交叉特征的输出维度。
请注意，age 的 6 个箱和 job 的 12 个值的可能值的组合将是 72，因此通过选择 crossing_dim = 8，我们选择约束输出向量。
feature_space = FeatureSpace(
features={
"age": FeatureSpace.integer_hashed(num_bins=6, output_mode="one_hot"),
"job": FeatureSpace.string_categorical(
num_oov_indices=0, output_mode="one_hot"
),
},
crosses=[
FeatureSpace.cross(
feature_names=("age", "job"),
crossing_dim=8,
output_mode="one_hot",
)
],
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["age", "job"])
Input: [{'age': 28}, {'job': b'blue-collar'}]
Preprocessed output: [{'age': array([0., 0., 1., 0., 0., 0.], dtype=float32)}, {'job': array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)}, {'age_X_job': array([0., 0., 0., 0., 1., 0., 0., 0.], dtype=float32)}]
使用 Keras 预处理层的 FeatureSpace
为了成为一个真正灵活且可扩展的特征，我们不能仅仅依赖于这些预定义的转换，我们必须能够重复使用 Keras/TensorFlow 生态系统中的其他转换并自定义我们自己的转换，这就是 FeatureSpace 也设计为与 Keras 预处理层 一起工作的原因，这样我们就可以使用框架提供的复杂数据转换，您甚至可以创建自己的自定义 Keras 预处理层并以相同的方式使用它。
在这里，我们将使用 [keras.layers.TextVectorization](/api/layers/preprocessing_layers/text/text_vectorization#textvectorization-class) 预处理层从我们的数据中创建 TF-IDF 特征。请注意，此特征并不是 TF-IDF 的一个很好的用例，这只用于演示目的。
custom_layer = keras.layers.TextVectorization(output_mode="tf_idf")
feature_space = FeatureSpace(
features={
"education": FeatureSpace.feature(
preprocessor=custom_layer, dtype="string", output_mode="float"
)
},
output_mode="dict",
)
example_feature_space(train_ds_with_no_labels, feature_space, ["education"])
Input: [{'education': b'university.degree'}]
Preprocessed output: [{'education': array([0. , 1.4574516, 0. , 0. , 0. , 0. ,
0. , 0. , 0. ], dtype=float32)}]
配置最终的 FeatureSpace
现在我们知道如何将 FeatureSpace 用于更复杂的用例，让我们选择对该任务更有用的用例并创建最终的 FeatureSpace 组件。
要配置每个特征的预处理方式，我们实例化一个 keras.utils.FeatureSpace，并将一个字典传递给它，该字典将我们的特征名称映射到特征转换函数。
feature_space = FeatureSpace(
features={
# Categorical features encoded as integers
"previously_contacted": FeatureSpace.integer_categorical(num_oov_indices=0),
# Categorical features encoded as string
"marital": FeatureSpace.string_categorical(num_oov_indices=0),
"education": FeatureSpace.string_categorical(num_oov_indices=0),
"default": FeatureSpace.string_categorical(num_oov_indices=0),
"housing": FeatureSpace.string_categorical(num_oov_indices=0),
"loan": FeatureSpace.string_categorical(num_oov_indices=0),
"contact": FeatureSpace.string_categorical(num_oov_indices=0),
"month": FeatureSpace.string_categorical(num_oov_indices=0),
"day_of_week": FeatureSpace.string_categorical(num_oov_indices=0),
"poutcome": FeatureSpace.string_categorical(num_oov_indices=0),
# Categorical features to hash and bin
"job": FeatureSpace.string_hashed(num_bins=3),
# Numerical features to hash and bin
"pdays": FeatureSpace.integer_hashed(num_bins=4),
# Numerical features to normalize and bin
"age": FeatureSpace.float_discretized(num_bins=4),
# Numerical features to normalize
"campaign": FeatureSpace.float_normalized(),
"previous": FeatureSpace.float_normalized(),
"emp.var.rate": FeatureSpace.float_normalized(),
"cons.price.idx": FeatureSpace.float_normalized(),
"cons.conf.idx": FeatureSpace.float_normalized(),
"euribor3m": FeatureSpace.float_normalized(),
"nr.employed": FeatureSpace.float_normalized(),
},
# Specify feature cross with a custom crossing dim.
crosses=[
FeatureSpace.cross(feature_names=("age", "job"), crossing_dim=8),
FeatureSpace.cross(feature_names=("housing", "loan"), crossing_dim=6),
FeatureSpace.cross(
feature_names=("poutcome", "previously_contacted"), crossing_dim=2
),
],
output_mode="concat",
)
使 FeatureSpace 适应训练数据
在我们开始使用 FeatureSpace 构建模型之前，我们必须使其适应训练数据。在 adapt() 期间，FeatureSpace 将
- 为分类特征索引可能的取值集合。
- 计算数值特征的均值和方差以进行归一化。
- 计算数值特征不同 bin 的值边界以进行离散化。
- 自定义层所需的任何其他类型的预处理。
请注意，adapt() 应该在 tf.data.Dataset 上调用，该数据集产生特征值的字典 - 无标签。
但首先让我们批量处理数据集
train_ds = train_ds.batch(32)
valid_ds = valid_ds.batch(32)
train_ds_with_no_labels = train_ds.map(lambda x, _: x)
feature_space.adapt(train_ds_with_no_labels)
此时，FeatureSpace 可以对原始特征值的字典进行调用，并且因为我们设置了 output_mode="concat"，它将为每个样本返回一个单一的连接向量，组合编码特征和特征交叉。
for x, _ in train_ds.take(1):
preprocessed_x = feature_space(x)
print(f"preprocessed_x shape: {preprocessed_x.shape}")
print(f"preprocessed_x sample: \n{preprocessed_x[0]}")
preprocessed_x shape: (32, 77)
preprocessed_x sample:
[ 0. 1. 0. 0. -0.19560693 0.95908785
-0.22542837 1. 0. 0. 1. 0.
0. 0. 1. 0. 0. 1.
0. 0. 0. 0. 0. 0.
0. 0.8486567 0.781508 1. 0. 0.
0. 0. 1. 1. 0. 0.
0. 1. 0. 0. 0. 0.
1. 0. 0. 0. 0. 0.
0. 0. 0.8400493 0. 0. 1.
0. 1. 0. 0. -0.35691845 1.
0. 0. 0. 0. 0. 0.
1. 0. 0. 0. 0. 0.
0. 1. 0. 1. 0. ]
保存 FeatureSpace
此时，我们可以选择保存我们的 FeatureSpace 组件，这有很多优点，例如在使用相同模型的不同实验中重复使用它，如果您需要重新运行预处理步骤可以节省时间，并且主要用于模型部署，通过加载它，您可以确保无论设备或环境如何，您都将应用相同的预处理步骤，这是减少 训练/服务偏差 的好方法。
feature_space.save("myfeaturespace.keras")
将 FeatureSpace 作为 tf.data 管道的一部分进行预处理
我们将选择通过将其作为 tf.data 管道的一部分来异步使用我们的组件，如 上一指南 中所述。这使得可以在数据到达模型之前在 CPU 上异步并行预处理数据。通常，在训练期间，这始终是正确的做法。
让我们创建一个预处理批次的训练和验证数据集
preprocessed_train_ds = train_ds.map(
lambda x, y: (feature_space(x), y), num_parallel_calls=tf.data.AUTOTUNE
).prefetch(tf.data.AUTOTUNE)
preprocessed_valid_ds = valid_ds.map(
lambda x, y: (feature_space(x), y), num_parallel_calls=tf.data.AUTOTUNE
).prefetch(tf.data.AUTOTUNE)
模型
我们将利用我们的 FeatureSpace 组件来构建模型，因为我们希望模型与我们的预处理函数兼容，让我们使用 FeatureSpace 特征映射作为我们模型的输入。
encoded_features = feature_space.get_encoded_features()
print(encoded_features)
<KerasTensor shape=(None, 77), dtype=float32, sparse=False, name=keras_tensor_56>
此模型非常简单，仅用于演示目的，因此请不要过多关注架构。
x = keras.layers.Dense(64, activation="relu")(encoded_features)
x = keras.layers.Dropout(0.5)(x)
output = keras.layers.Dense(1, activation="sigmoid")(x)
model = keras.Model(inputs=encoded_features, outputs=output)
model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
训练
让我们训练我们的模型 20 个 epoch。请注意，特征预处理是作为 tf.data 管道的一部分发生的，而不是作为模型的一部分发生的。
model.fit(
preprocessed_train_ds, validation_data=preprocessed_valid_ds, epochs=20, verbose=2
)
Epoch 1/20
103/103 - 1s - 6ms/step - accuracy: 0.8844 - loss: 0.3453 - val_accuracy: 0.9114 - val_loss: 0.2612
Epoch 2/20
103/103 - 0s - 2ms/step - accuracy: 0.8974 - loss: 0.3010 - val_accuracy: 0.9078 - val_loss: 0.2641
Epoch 3/20
103/103 - 0s - 2ms/step - accuracy: 0.9005 - loss: 0.2863 - val_accuracy: 0.9066 - val_loss: 0.2630
Epoch 4/20
103/103 - 0s - 2ms/step - accuracy: 0.9002 - loss: 0.2925 - val_accuracy: 0.9053 - val_loss: 0.2653
Epoch 5/20
103/103 - 0s - 2ms/step - accuracy: 0.8995 - loss: 0.2893 - val_accuracy: 0.9078 - val_loss: 0.2624
Epoch 6/20
103/103 - 0s - 2ms/step - accuracy: 0.9002 - loss: 0.2866 - val_accuracy: 0.9078 - val_loss: 0.2628
Epoch 7/20
103/103 - 0s - 2ms/step - accuracy: 0.9026 - loss: 0.2868 - val_accuracy: 0.9090 - val_loss: 0.2621
Epoch 8/20
103/103 - 0s - 2ms/step - accuracy: 0.9023 - loss: 0.2802 - val_accuracy: 0.9078 - val_loss: 0.2623
Epoch 9/20
103/103 - 0s - 2ms/step - accuracy: 0.9047 - loss: 0.2743 - val_accuracy: 0.9078 - val_loss: 0.2628
Epoch 10/20
103/103 - 0s - 2ms/step - accuracy: 0.9062 - loss: 0.2761 - val_accuracy: 0.9090 - val_loss: 0.2650
Epoch 11/20
103/103 - 0s - 2ms/step - accuracy: 0.9050 - loss: 0.2729 - val_accuracy: 0.9090 - val_loss: 0.2668
Epoch 12/20
103/103 - 0s - 2ms/step - accuracy: 0.9029 - loss: 0.2699 - val_accuracy: 0.9078 - val_loss: 0.2670
Epoch 13/20
103/103 - 0s - 2ms/step - accuracy: 0.9056 - loss: 0.2671 - val_accuracy: 0.9078 - val_loss: 0.2641
Epoch 14/20
103/103 - 0s - 2ms/step - accuracy: 0.9032 - loss: 0.2750 - val_accuracy: 0.9078 - val_loss: 0.2643
Epoch 15/20
103/103 - 0s - 2ms/step - accuracy: 0.9083 - loss: 0.2650 - val_accuracy: 0.9102 - val_loss: 0.2658
Epoch 16/20
103/103 - 0s - 2ms/step - accuracy: 0.9102 - loss: 0.2593 - val_accuracy: 0.9102 - val_loss: 0.2639
Epoch 17/20
103/103 - 0s - 2ms/step - accuracy: 0.9074 - loss: 0.2719 - val_accuracy: 0.9102 - val_loss: 0.2655
Epoch 18/20
103/103 - 0s - 2ms/step - accuracy: 0.9059 - loss: 0.2655 - val_accuracy: 0.9102 - val_loss: 0.2670
Epoch 19/20
103/103 - 0s - 2ms/step - accuracy: 0.9099 - loss: 0.2650 - val_accuracy: 0.9102 - val_loss: 0.2646
Epoch 20/20
103/103 - 0s - 2ms/step - accuracy: 0.9068 - loss: 0.2624 - val_accuracy: 0.9078 - val_loss: 0.2661
<keras.src.callbacks.history.History at 0x31eac7eb0>
使用端到端模型对新数据进行推理
现在，我们可以构建我们的推理模型（包括 FeatureSpace）来根据原始特征值的字典进行预测，如下所示
加载 FeatureSpace
首先让我们加载我们几分钟前保存的 FeatureSpace，如果您训练了一个模型但想在不同的时间进行推理（可能使用不同的设备或环境），这会非常方便。
loaded_feature_space = keras.saving.load_model("myfeaturespace.keras")
构建推理端到端模型
要构建推理模型，我们需要特征输入映射和预处理编码的 Keras 张量。
dict_inputs = loaded_feature_space.get_inputs()
encoded_features = loaded_feature_space.get_encoded_features()
print(encoded_features)
print(dict_inputs)
outputs = model(encoded_features)
inference_model = keras.Model(inputs=dict_inputs, outputs=outputs)
sample = {
"age": 30,
"job": "blue-collar",
"marital": "married",
"education": "basic.9y",
"default": "no",
"housing": "yes",
"loan": "no",
"contact": "cellular",
"month": "may",
"day_of_week": "fri",
"campaign": 2,
"pdays": 999,
"previous": 0,
"poutcome": "nonexistent",
"emp.var.rate": -1.8,
"cons.price.idx": 92.893,
"cons.conf.idx": -46.2,
"euribor3m": 1.313,
"nr.employed": 5099.1,
"previously_contacted": 0,
}
input_dict = {
name: keras.ops.convert_to_tensor([value]) for name, value in sample.items()
}
predictions = inference_model.predict(input_dict)
print(
f"This particular client has a {100 * predictions[0][0]:.2f}% probability "
"of subscribing a term deposit, as evaluated by our model."
)
<KerasTensor shape=(None, 77), dtype=float32, sparse=False, name=keras_tensor_99>
{'previously_contacted': <KerasTensor shape=(None, 1), dtype=int32, sparse=None, name=previously_contacted>, 'marital': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=marital>, 'education': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=education>, 'default': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=default>, 'housing': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=housing>, 'loan': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=loan>, 'contact': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=contact>, 'month': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=month>, 'day_of_week': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=day_of_week>, 'poutcome': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=poutcome>, 'job': <KerasTensor shape=(None, 1), dtype=string, sparse=None, name=job>, 'pdays': <KerasTensor shape=(None, 1), dtype=int32, sparse=None, name=pdays>, 'age': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=age>, 'campaign': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=campaign>, 'previous': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=previous>, 'emp.var.rate': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=emp.var.rate>, 'cons.price.idx': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=cons.price.idx>, 'cons.conf.idx': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=cons.conf.idx>, 'euribor3m': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=euribor3m>, 'nr.employed': <KerasTensor shape=(None, 1), dtype=float32, sparse=None, name=nr.employed>}
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 126ms/step
This particular client has a 9.60% probability of subscribing a term deposit, as evaluated by our model.