def test_all(self):
var = xdl.Variable(name="w", dtype=DataType.int32, shape=[4], initializer=xdl.Zeros())
execute(xdl.variable_registers())
execute(xdl.global_initializers())
op = xdl.ps_assign_add_op(var_name="w", var_type="index", delta=np.array([1,2,3,4], dtype=np.int32))
execute(op)
ret = execute(var.value)
self.assertTrue((ret == np.array([1,2,3,4])).all())
def test_not_init(self):
var = xdl.Variable(name="w",
dtype=DataType.int32,
shape=[4],
initializer=xdl.Zeros())
execute(var.var_register)
op = xdl.ps_is_initialized_op(var_name="w")
ret = execute(op)
self.assertTrue((ret == np.array([0])).all())
def get_global_step():
global _GLOBAL_STEP
if _GLOBAL_STEP is not None:
return _GLOBAL_STEP
_GLOBAL_STEP = Variable(name="xdl_global_step",
shape=[],
dtype=xdl.DataType.int64,
trainable=False,
initializer=xdl.Zeros())
return _GLOBAL_STEP
def test_all(self):
var = xdl.Variable(name="w", dtype=DataType.float, shape=[4,2], initializer=xdl.Zeros())
execute(xdl.variable_registers())
execute(xdl.global_initializers())
op = xdl.ps_sparse_assign_op(
var_name="w", var_type="index",
ids=np.array([1,2], dtype=np.int32),
values=np.array([[1,2],[3,4]], dtype=np.float32))
execute(op)
ret = execute(var.value)
self.assertTrue((ret == np.array([[0,0],[1,2],[3,4],[0,0]], dtype=np.float32)).all())
def embedding(name, sparse_input, initializer, emb_dim, feature_dim,
combiner='sum',
vtype=VarType.Index,
length=50,
reverse=False,
batch_read=3000,
feature_add_probability=1.0,
cbf=0,
device='CPU',
statis_list=None,
statis_decay=0.07,
statis_decay_period=100,
labels=None,
save=True,
**device_attr):
"""xdl embedding
Args:
name: name for embedding, will be used for declaring variable on ps-plus
sparse_input: a sparse tensor represent input data
initializer: intializer for the variable on ps-plus
emb_dim: embedding dimension
feature_dim: sparse input dimension, for pre-allocate memory
combiner: reduce operator, support sum|mean
Returns:
a tensor represent embedding result
Raises:
None
"""
global EMBEDDING_LIST, EMBEDDING_SET
if name not in EMBEDDING_SET:
EMBEDDING_SET.add(name)
EMBEDDING_LIST.append(name)
import xdl.python.framework.variable as variable
with variable.variable_info(batch_read=batch_read, save_ratio=feature_add_probability, bloom_filter=cbf, save="true" if save else "false"):
var = variable.Variable(name=name,
dtype=DataType.float,
shape=[feature_dim, emb_dim],
initializer=initializer,
vtype=vtype,
trainable=True)
if statis_list is not None:
statis_vars = []
for statis_type in statis_list:
statis_var = variable.Variable(name=name,
dtype=DataType.float,
shape=[feature_dim, 1],
initializer=xdl.Zeros(),
vtype=vtype,
trainable=False,
statis_type=statis_type,
statis_decay=statis_decay,
statis_decay_period=statis_decay_period)
statis_vars.append(statis_var)
if sparse_input.has_unique_ids():
unique_ids = xdl.identity_op(sparse_input.ids)
idx = sparse_input.indices
embeddings = var.gather(unique_ids)
sidx = sparse_input.sidx
sseg = sparse_input.sseg
else:
with xdl.device(device, **device_attr):
unique_ids, idx, sidx, sseg = xdl.unique(sparse_input.ids, sparse_input.segments, itype=DataType.int32)
embeddings = var.gather(unique_ids)
if statis_list is not None:
assert labels is not None
from xdl.python.training.training_utils import get_global_step
global_step = get_global_step()
statis_results = []
for statis_var in statis_vars:
statis_result = statis_var.statis(sparse_input.ids, idx, sparse_input.segments, sidx, sseg, labels, global_step.value)
statis_results.append(statis_result)
global _EMBEDDING_TENSOR
_EMBEDDING_TENSOR[embeddings] = var
import xdl.python.sparse_engine.embedding_ops as embedding_ops
import numpy as np
if combiner == 'sum':
embeddings = embedding_ops.ksum(
embeddings,
idx,
sparse_input.values,
sparse_input.segments,
sidx,
sseg,
device, **device_attr)
elif combiner == 'mean':
embeddings = embedding_ops.kmean(
embeddings,
idx,
sparse_input.values,
sparse_input.segments,
sidx,
sseg,
device, **device_attr)
elif combiner == 'tile':
embeddings = embedding_ops.tile(
embeddings,
idx,
np.array([], dtype=np.float32),
#sparse_input.values,
sparse_input.segments,
length,
reverse,
device, **device_attr)
else:
raise Exception("Unrecognized combiner:" + str(combiner))
if sparse_input.shape is not None and len(sparse_input.shape) > 0:
embeddings.set_shape([sparse_input.shape[0], emb_dim]);
emb_info = EmbeddingInfo(name, feature_dim, emb_dim, combiner, None, var, length, embeddings)
set_embedding_info([var], emb_info)
if statis_list is not None:
return embeddings, statis_results
return embeddings