def template(x_shape=[2, 3],
feature_size=5,
vocabulary_size=6,
x_order=OrderNT,
w_order=OrderCN,
y_order=OrderNTC,
description: str = ""):
x = Variable(x_shape, order=x_order)
vx = np.random.randint(low=0,
high=vocabulary_size,
size=(x.shape_dict[Axis.N],
x.shape_dict[Axis.T])) # OrderNT
vw = np.random.rand(vocabulary_size, feature_size) # OrderCN
vy = vw[vx] # OrderNTC
w = ConstantVariable(vw, order=OrderCN)
y, = Embedding(None)(x, w)
x = x.change_order(x_order)
w = w.change_order(w_order)
y = y.change_order(y_order)
generate_kernel_test_case(
description=f"Embedding {description}",
backend=["webgpu", "webassembly"],
graph=Graph([x], [y]),
inputs={x: vx.transpose([OrderNT.axes_dict[a] for a in x.order.axes])},
expected={
y: vy.transpose([OrderNTC.axes_dict[a] for a in y.order.axes])
})
def _convert_embedding(converter: KerasConverter,
k_op: "keras.layers.Embedding"):
x = converter.get_variable(converter.get_input_tensor(k_op)[0])
x = x.reinterpret_axes(OrderNT)
w = converter.convert_to_constant_variable(k_op.embeddings, OrderCN)
y, = Embedding(None)(x, w)
converter.set_variable(converter.get_output_tensor(k_op)[0], y)
def template(N=2, T=3, vocabulary_size=4, feature_size=5, order_x=OrderNT, order_w=OrderNC):
x = Variable([N, T], OrderNT)
w = Variable([feature_size, vocabulary_size], OrderNC)
x.change_order(order_x)
w.change_order(order_w)
y, = Embedding(None)(x, w)
assert_shape(y, AxisKeyDict([Axis.N, Axis.T, Axis.C], [N, T, feature_size]))
def _convert_embedding(converter: KerasConverter, k_op: keras.layers.Embedding):
x = converter.get_variable(converter.get_input_tensor(k_op)[0])
if x.order == OrderNC:
x, = ReinterpretAxis(None, in_order=OrderNC, out_order=OrderNT)(x)
w = converter.convert_to_constant_variable(k_op.embeddings, OrderCN)
y, = Embedding(None)(x, w)
converter.set_variable(converter.get_output_tensor(k_op)[0], y)
def test_general():
vx = np.array([[2, 4, 3]])
vw = np.arange(15).reshape(5, 3)
vy = vw[vx]
x = Variable(vx.shape, order=OrderNT)
w = ConstantVariable(vw, order=OrderCN)
y, = Embedding(None)(x, w)
generate_kernel_test_case(description=f"Embedding",
backend=["webgpu"],
graph=Graph([x], [y]),
inputs={x: vx},
expected={y: vy})
def generate_graph_model2(caption_net, hidden_num):
# inputs
var_input_img = Variable([1, 1, hidden_num], OrderNTC)
var_input_word = Variable([1, 1], OrderNT)
var_switch_img = Variable([1, 1, hidden_num], OrderNTC)
var_switch_word = Variable([1, 1, hidden_num], OrderNTC)
var_last_h = Variable([1, hidden_num], OrderNC)
var_last_c = Variable([1, hidden_num], OrderNC)
# prepare for lstm
var_emb_word, = Embedding(None)(var_input_word,
ConstantVariable(
caption_net.word_vec.W.data,
OrderCN)) # OrderNTC
var_lstm_input = (var_emb_word * var_switch_word) + \
(var_input_img * var_switch_img)
# lstm
lstm_opr = LSTM(None,
use_bias=True,
return_sequences=False,
activation="tanh",
recurrent_activation="sigmoid",
use_initial_h=True,
use_initial_c=True)
w_input = _convert_lstm_to_webdnn_order(caption_net.lstm.upward.W.data.T)
w_hidden = _convert_lstm_to_webdnn_order(caption_net.lstm.lateral.W.data.T)
b = _convert_lstm_to_webdnn_order(
caption_net.lstm.upward.b.data[None, :])[0]
var_lstm_h, var_lstm_c = lstm_opr(
x=var_lstm_input,
w_input=ConstantVariable(w_input, OrderCN),
w_hidden=ConstantVariable(w_hidden, OrderCN),
b=ConstantVariable(b, OrderC),
initial_h=var_last_h,
initial_c=var_last_c)
# word probability
var_word_score, = Linear(None)(var_lstm_h,
ConstantVariable(
caption_net.out_word.W.data.T, OrderCN))
var_word_score_biased, = AxiswiseBias(None, axis=Axis.C)(
var_word_score, ConstantVariable(caption_net.out_word.b.data, OrderC))
var_word_prob, = Softmax(None, axis=Axis.C)(var_word_score_biased)
return Graph([
var_input_img, var_input_word, var_switch_img, var_switch_word,
var_last_h, var_last_c
], [var_word_prob, var_lstm_h, var_lstm_c])