def test_encode_context_feature_values_with_prefix(self, mock_module_cls):
def mock_fn(input, signature=None):
self.assertIn(signature,
{"encode_context", "encode_response", None})
if signature == "encode_context":
self.assertIsInstance(input, dict)
self.assertEqual(2, len(input))
for input_t in input.values():
self.assertEqual(input_t.dtype, tf.string)
mock_module_cls.return_value = mock_fn
with mock.patch("encoder_client._batch_session_run") as f:
client = encoder_client.EncoderClient(
"test_uri",
use_extra_context=True,
max_extra_contexts=3,
use_extra_context_prefixes=True,
cache_size=0,
)
mock_module_cls.assert_called_with("test_uri")
encodings = client.encode_contexts(
["hello", "hi", "yo"],
extra_contexts=[
["a", "b", "c", "d d"],
["A", "B", "C", "D", "E", "F"],
[],
],
)
f.assert_called_once()
self.assertEqual(
["0: d d 1: c 2: b", "0: F 1: E 2: D", ""],
list(f.call_args[0][1][client._fed_extra_contexts]),
)
self.assertEqual(f.return_value, encodings)
def test_encode_context(self, mock_module_cls):
def mock_fn(input, signature=None):
self.assertIn(signature,
{"encode_context", "encode_response", None})
if signature == "encode_context":
self.assertIsInstance(input, dict)
self.assertEqual(2, len(input))
for input_t in input.values():
self.assertEqual(input_t.dtype, tf.string)
return tf.ones([tf.shape(input_t)[0], 3])
mock_module_cls.return_value = mock_fn
client = encoder_client.EncoderClient("test_uri",
use_extra_context=True)
mock_module_cls.assert_called_with("test_uri")
encodings = client.encode_contexts(
["hello", "hi", "yo"],
extra_contexts=[
["a", "b", "c", "d"],
["A", "B", "C", "D", "E", "F"],
[],
],
)
np.testing.assert_allclose([[1., 1., 1.]] * 3, encodings)
def test_encode_sentences_batching_caching(self, mock_module_cls):
def mock_fn(input, signature=None):
self.assertIn(signature,
{"encode_context", "encode_response", None})
self.assertIsInstance(input, tf.Tensor)
self.assertEqual(input.dtype, tf.string)
if signature is None:
return tf.random_normal([tf.shape(input)[0], 3])
mock_module_cls.return_value = mock_fn
client = encoder_client.EncoderClient(
# force batching by setting batch size to 3
"test_uri",
internal_batch_size=3,
cache_size=100,
)
mock_module_cls.assert_called_with("test_uri")
encodings = client.encode_sentences(
["a", "a", "b", "c", "d", "e", "f", "g"])
# Test de-duplication:
np.testing.assert_allclose(encodings[0], encodings[1])
encodings_2 = client.encode_sentences(["a", "b", "c", "z"])
# Test caching
np.testing.assert_allclose(encodings[0], encodings_2[0])
np.testing.assert_allclose(encodings[2], encodings_2[1])
np.testing.assert_allclose(encodings[3], encodings_2[2])
def __init__(self, train_x, train_y, valid_x, valid_y):
self.train_x = train_x
self.train_y = train_y
self.valid_x = valid_x
self.valid_y = valid_y
self.n_labels = self.valid_y.shape[1]
self.module = encoder_client.EncoderClient(
"http://models.poly-ai.com/convert/v1/model.tar.gz")
def test_encode_response(self, mock_module_cls):
def mock_fn(input, signature=None):
self.assertIn(signature,
{"encode_context", "encode_response", None})
self.assertIsInstance(input, tf.Tensor)
self.assertEqual(input.dtype, tf.string)
if signature == "encode_response":
return tf.ones([tf.shape(input)[0], 3])
mock_module_cls.return_value = mock_fn
client = encoder_client.EncoderClient("test_uri")
mock_module_cls.assert_called_with("test_uri")
encodings = client.encode_responses(["hello"])
np.testing.assert_allclose([[1, 1, 1]], encodings)
# Find the position of 0 in the argsort, as index 0 is the correct
# response.
ranks.append((-scores).argsort().argmin())
if (i + 1) % 100 == 0:
glog.info(f"Scored {i + 1} / {len(examples)} examples.")
ranks = numpy.asarray(ranks)
for k in [1, 10, 50]:
recall_at_k = (ranks < k).mean()
glog.info(f"Recall@{k} = {recall_at_k:.3f}")
mrr = (1 / (1.0 + ranks)).mean()
glog.info(f"MRR = {mrr:.3f}")
if __name__ == "__main__":
flags = _parse_args()
client = encoder_client.EncoderClient(
flags.encoder,
use_extra_context=True,
use_extra_context_prefixes=True,
max_extra_contexts=10,
)
reader = test_reader.TestReader(
examples_json=flags.examples_json,
labels_tsv=flags.labels_tsv,
)
_evaluate(client, reader.examples)
print(sequence_encoding)
print(sequence_encoding.shape)
tokens = encoding['tokens']
print(tokens)
tokenized_encoding = sess.run(encoding_tensor2,
feed_dict={text_placeholder: text})
# print(encoding.shape)
print(tokenized_encoding)
if sess is not None:
sess.close()
# --------------------------- experiment convert encode client
# encode_sentences
import encoder_client
import pdb
# Internally it implements caching, deduplication, and batching, to help speed up encoding. Note that because it does batching internally, you can pass very large lists of sentences to encode without going out of memory.
client = encoder_client.EncoderClient(
"http://models.poly-ai.com/convert/v1/model.tar.gz")
# find good responses to the folowing context
context_encodings = client.encode_contexts(["What's your name?"])
# rank the following reponses as candidates
candidate_responses = ["No, thanks.", "I'm Matt", "Hey", "I have a dog"]
response_encodings = client.encode_responses(candidate_responses)
# compute score using dot product
scores = response_encodings.dot(context_encodings.T).flatten()
# output top score response
top_idx = scores.argmax()
pdb.set_trace()
print('Best response: {}, score: {:.3f}'.format(candidate_responses[top_idx],
scores[top_idx]))
