def test_update_embedding_param(self):
params = Parameters()
for name in ["test_1", "test_2"]:
params.embedding_params[name] = EmbeddingTable(name, 8)
slot_key = get_slot_table_name(name, "momentum")
params.embedding_params[slot_key] = EmbeddingTable(
slot_key, 8, "0.0", True)
indices = {
"test_1": np.array([1, 5]),
"test_2": np.array([10]),
}
embed_vars = {
"test_1": tf.Variable(np.random.rand(2, 8).astype(np.float32)),
"test_2": tf.Variable(np.random.rand(1, 8).astype(np.float32)),
}
slot_vars = {
"test_1": {
"momentum":
tf.Variable(np.random.rand(2, 8).astype(np.float32))
},
"test_2": {
"momentum":
tf.Variable(np.random.rand(1, 8).astype(np.float32))
},
}
opt = SGD(momentum=0.1)
opt_wrapper = OptimizerWrapper(opt, None, None,
params.set_embedding_param)
opt_wrapper._tls._unique_ids_all_layers = indices
opt_wrapper._tls._embed_variables = embed_vars
opt_wrapper._tls._slot_variables = slot_vars
opt_wrapper._update_embedding_param()
for name in ["test_1", "test_2"]:
self.assertTrue(
np.allclose(
embed_vars[name].numpy(),
params.get_embedding_param(name, indices[name]),
))
slot = "momentum"
slot_table_name = get_slot_table_name(name, slot)
self.assertTrue(
np.allclose(
slot_vars[name][slot].numpy(),
params.get_embedding_param(slot_table_name, indices[name]),
))
def _test_correctness(self, optimizer_class, X, Y, seed, **opt_kwargs):
"""Test the correctness of specific TensorFlow optimizer."""
_model_file = get_module_file_path(
os.path.dirname(os.path.realpath(__file__)),
"embedding_test_module.KerasEmbeddingModel",
)
model_module = load_module(_model_file).__dict__
# train model with TensorFlow optimizer
dim = 4
weights = self._random_init_model_weight([(4, dim), (4, dim), (72, 1),
(1, )], seed)
loss_fn = model_module["loss"]
model1 = model_module["KerasEmbeddingModel"](4, dim, weights)
opt1 = optimizer_class(**opt_kwargs)
_train(model1, opt1, X, Y, loss_fn, random_seed=seed)
model2 = model_module["EdlEmbeddingModel"](dim, weights[2:])
opt2 = optimizer_class(**opt_kwargs)
embedding_weight_names = [
layer.embedding_weight_name
for layer in find_layer(model2, Embedding)
]
# create Parameters object and initialize embedding vectors
params = Parameters()
for weight_name, embed_value in zip(embedding_weight_names,
weights[:2]):
embed_table = EmbeddingTable(weight_name, dim)
embed_table.set(range(len(embed_value)), embed_value)
params.embedding_params[weight_name] = embed_table
_train_edl_embedding_with_optimizer_wrapper(model2,
opt2,
X,
Y,
loss_fn,
params,
random_seed=seed)
# compare trained parameters
wrong_msg = (
"The updated parameters of Optimizer Wrapper and TensorFlow "
"optimizer %s differ." % opt1.get_config()["name"])
for layer1, layer2 in zip(model1.layers, model2.layers):
if "embedding" in layer2.name:
w1 = layer1.weights[0].numpy()
w2 = params.get_embedding_param(layer2.embedding_weight_name,
range(4))
self.assertTrue(np.isclose(w1, w2).all(), msg=wrong_msg)
else:
for w1, w2 in zip(layer1.weights, layer2.weights):
self.assertTrue(np.isclose(w1.numpy(), w2.numpy()).all(),
msg=wrong_msg)
def _test_async_correctness(
self,
grads_and_vars_batches,
embed_values,
expected_non_embed_values,
expected_embed_values=None,
):
"""Checks the correctness of async OptimizerWrapper. This function
creates many threads and these threads call
`OptimizerWrapper.apply_gradients` simultaneously.
Args:
grads_and_vars_batches: A python list of `grads_and_vars`. Every
thread takes a `grads_and_vars` and calls `apply_gradients`.
embed_values: A python dictionary of
`(layer_name, embedding table)`.
expected_non_embed_values: A python list of expected non-embdding
values after applying gradients.
expected_embed_values: A python dictionary of expected embedding
values after applying gradients. None means no need to check
embedding values.
"""
thread_num = len(grads_and_vars_batches)
input_dims = {}
embed_var_n = len(embed_values)
params = Parameters()
for layer, values in embed_values.items():
embed_dim = values.shape[1]
input_dims[layer] = values.shape[0]
embed_table = EmbeddingTable(layer, embed_dim)
embed_table.set(range(input_dims[layer]), values)
params.embedding_params[layer] = embed_table
opt = SGD(0.1)
opt_wrapper = OptimizerWrapper(
opt,
True,
lookup_embedding_func=params.get_embedding_param,
update_embedding_func=params.set_embedding_param,
)
# call optimizer_wrapper.apply_gradients asynchronously
def _apply_gradients(opt_wrapper, grads_and_vars):
# sleep 1s to wait that all threads are in this method call
time.sleep(1)
opt_wrapper.apply_gradients(grads_and_vars)
executor = ThreadPoolExecutor(max_workers=thread_num)
tasks = [
executor.submit(_apply_gradients, opt_wrapper, grads_and_vars)
for grads_and_vars in grads_and_vars_batches
]
_ = [task.result() for task in tasks]
# check updated results of non-embedding variables
non_embed_vars = [
var for grad, var in grads_and_vars_batches[0][:-embed_var_n]
]
for var, expected_value in zip(non_embed_vars,
expected_non_embed_values):
self.assertTrue(np.isclose(var.numpy(), expected_value).all())
# `expected_embed_values=None` means that no need to check
# embedding table
if not expected_embed_values:
return
# check updated results of embedding table
for layer, expected_values in expected_embed_values.items():
value = params.get_embedding_param(layer, range(input_dims[layer]))
self.assertTrue(
any([
np.isclose(value, expected).all()
for expected in expected_values
]))
class ParametersTest(unittest.TestCase):
def setUp(self):
self.params = Parameters()
self.model_pb = Model()
self.infos_pb = self.model_pb.embedding_table_infos
self.tensors_pb = self.model_pb.dense_parameters
self.embedding_tables_pb = self.model_pb.embedding_tables
self.embedding_table_name = "embedding_1"
self.embedding_dim = 10
embedding_pb = self.infos_pb.add()
embedding_pb.name = self.embedding_table_name
embedding_pb.dim = self.embedding_dim
embedding_pb.initializer = "uniform"
arr1 = np.random.uniform(size=(3, 4))
serialize_ndarray(arr1, self.tensors_pb["x"])
arr2 = np.random.uniform(size=(4, 5))
serialize_ndarray(arr2, self.tensors_pb["y"])
embedding_vectors = np.random.uniform(size=(2, 10))
embedding_indices = np.array([0, 8])
serialize_indexed_slices(
Tensor(None, embedding_vectors, embedding_indices),
self.embedding_tables_pb[self.embedding_table_name],
)
def _test_get_embedding_param(self, slot_names=[], slot_init_value={}):
indices = [0, 3, 7]
res = self.params.get_embedding_param(
self.embedding_table_name, indices
)
self.assertTupleEqual(res.shape, (3, 10))
for slot in slot_names:
res = self.params.get_embedding_param(
get_slot_table_name(self.embedding_table_name, slot), indices
)
self.assertTrue(((res - slot_init_value[slot]) < 0.0001).all())
res = self.params.get_embedding_param(self.embedding_table_name, [])
self.assertIsNone(res)
with self.assertRaises(ValueError):
self.params.get_embedding_param("tom", indices)
def test_init_from_model_pb(self):
self.params.reset()
self.params.init_from_model_pb(self.model_pb)
res = self.params.non_embedding_params
self.assertTrue("x" in res)
self.assertTrue("y" in res)
self.assertTrue(res["x"].trainable)
self.assertTupleEqual(tuple(res["y"].shape.as_list()), (4, 5))
self._test_get_embedding_param()
def test_non_embedding_params(self):
self.params.reset()
res = self.params.non_embedding_params
self.assertFalse(any(res))
variables = {
"x": tf.Variable(1, name="x"),
"y": tf.Variable(2, name="y"),
}
self.params.non_embedding_params = variables
self.assertTrue("x" in self.params.non_embedding_params)
self.assertTrue("y" in self.params.non_embedding_params)
def test_get_embedding_param(self):
self.params.reset()
self.params.init_embedding_params(self.infos_pb)
self._test_get_embedding_param()
def test_set_embedding_param(self):
self.params.reset()
self.params.init_embedding_params(self.infos_pb)
indices = [100, 34, 8]
x = len(indices)
values = np.random.uniform(size=x * self.embedding_dim).reshape(
(x, self.embedding_dim)
)
self.params.set_embedding_param(
self.embedding_table_name, indices, values
)
row0 = self.params.get_embedding_param(
self.embedding_table_name, [100]
)
row1 = self.params.get_embedding_param(self.embedding_table_name, [34])
row2 = self.params.get_embedding_param(self.embedding_table_name, [8])
rows = [row0, row1, row2]
rows = np.concatenate(rows)
np.testing.assert_array_equal(rows, values)
with self.assertRaises(ValueError):
self.params.set_embedding_param("tom", [0, 1, 2], values)
def test_check_grad(self):
self.params.reset()
self.params.init_from_model_pb(self.model_pb)
grad0 = Tensor("z", None, None)
with self.assertRaisesRegex(ValueError, "Name error"):
self.params.check_grad(grad0)
grad1 = Tensor("x", np.random.uniform(size=(3, 5)), None)
with self.assertRaisesRegex(ValueError, "Non embedding param error"):
self.params.check_grad(grad1)
grad2 = Tensor(
name="embedding_1",
values=np.random.uniform(size=(3, 11)),
indices=np.array([1, 2, 3]),
)
with self.assertRaisesRegex(
ValueError, "ElasticDL embedding param error"
):
self.params.check_grad(grad2)
grad3 = Tensor(
name="x",
values=np.random.uniform(size=(4, 4)),
indices=np.array([1, 2, 3, 4]),
)
with self.assertRaisesRegex(ValueError, "Keras embedding param error"):
self.params.check_grad(grad3)
def test_create_slot_params(self):
# At first, no embedding table are in the parameters
self.assertFalse(self.params.has_embedding_params())
# create embedding tables in the parameters
self.params.init_embedding_params(self.infos_pb)
self.assertTrue(self.params.has_embedding_params())
slot_names = ["accumulator", "linear"]
slot_init_value = {slot_names[0]: 3.5, slot_names[1]: 0.0}
self.params.create_slot_params(slot_names, slot_init_value)
self._test_get_embedding_param(slot_names, slot_init_value)
def test_export_to_model_pb(self):
self.params.init_from_model_pb(self.model_pb)
self.params.version = 15
model_pb = self.params.to_model_pb()
params = Parameters()
params.init_from_model_pb(model_pb)
self.assertEqual(params.version, self.params.version)
self.assertEqual(
params.non_embedding_params.keys(),
self.params.non_embedding_params.keys(),
)
self.assertEqual(
params.embedding_params["embedding_1"].get([0]).tolist(),
self.params.embedding_params["embedding_1"].get([0]).tolist(),
)