예제 #1
0
# NOTE: First install bert-as-service via
# $
# $ pip install serving-server
# $ pip install serving-client
# $

# using BertClient in sync way

import sys
import time

from transformer_serving.client import BertClient

if __name__ == '__main__':
    port = 6006
    port_out = 6007
    bc = BertClient(port=port,
                    port_out=port_out,
                    show_server_config=True,
                    timeout=-1)
    # encode a list of strings
    # with open('README.md') as fp:
    #     data = [v for v in fp if v.strip()][:512]
    #     num_tokens = sum(len([vv for vv in v.split() if vv.strip()]) for v in data)

    # show_tokens = len(sys.argv) > 3 and bool(sys.argv[3])
    data = ['aaaaaaaaa']
    output = bc.encode(data)  # warm-up GPU
    print(output)
예제 #2
0
# read and write TFRecord

import os

import GPUtil
import tensorflow as tf
from transformer_serving.client import BertClient

os.environ['CUDA_VISIBLE_DEVICES'] = str(GPUtil.getFirstAvailable()[0])
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.INFO)

with open('README.md') as fp:
    data = [v for v in fp if v.strip()]
    bc = BertClient()
    list_vec = bc.encode(data)
    list_label = [0 for _ in data]  # a dummy list of all-zero labels

# write tfrecords

with tf.python_io.TFRecordWriter('tmp.tfrecord') as writer:

    def create_float_feature(values):
        return tf.train.Feature(float_list=tf.train.FloatList(value=values))

    def create_int_feature(values):
        return tf.train.Feature(int64_list=tf.train.Int64List(
            value=list(values)))

    for (vec, label) in zip(list_vec, list_label):
        features = {
예제 #3
0
    '-pooling_strategy', 'REDUCE_MEAN',
    '-pooling_layer', '-2',
    '-gpu_memory_fraction', '0.2',
    '-device','3',
]
args = get_args_parser().parse_args(common)

for pool_layer in range(1, 13):
    setattr(args, 'pooling_layer', [-pool_layer])
    server = BertServer(args)
    server.start()
    print('wait until server is ready...')
    time.sleep(20)
    print('encoding...')
    bc = BertClient(port=port, port_out=port_out, show_server_config=True)
    subset_vec_all_layers.append(bc.encode(subset_text))
    bc.close()
    server.close()
    print('done at layer -%d' % pool_layer)

#save bert vectors and labels
stacked_subset_vec_all_layers = np.stack(subset_vec_all_layers)
np.save('example7_5k_2',stacked_subset_vec_all_layers)
np_subset_label = np.array(subset_label)
np.save('example7_5k_2_subset_label',np_subset_label)

#load bert vectors and labels
subset_vec_all_layers = np.load('example7_5k_mxnet.npy')
np_subset_label = np.load('example7_5k_mxnet_subset_label.npy')
subset_label = np_subset_label.tolist()
#=========================== visualize ===========================
예제 #4
0
# $

# using BertClient in sync way

import sys
import time

from transformer_serving.client import BertClient

if __name__ == '__main__':
    bc = BertClient(port=int(sys.argv[1]),
                    port_out=int(sys.argv[2]),
                    show_server_config=True)
    # encode a list of strings
    with open('README.md') as fp:
        data = [v for v in fp if v.strip()][:512]
        num_tokens = sum(
            len([vv for vv in v.split() if vv.strip()]) for v in data)

    show_tokens = len(sys.argv) > 3 and bool(sys.argv[3])
    bc.encode(data)  # warm-up GPU
    for j in range(10):
        tmp = data * (2**j)
        c_num_tokens = num_tokens * (2**j)
        start_t = time.time()
        bc.encode(tmp, show_tokens=show_tokens)
        time_t = time.time() - start_t
        print('encoding %10d sentences\t%.2fs\t%4d samples/s\t%6d tokens/s' %
              (len(tmp), time_t, int(
                  len(tmp) / time_t), int(c_num_tokens / time_t)))
예제 #5
0
# using BertClient in multicast way

import sys
import threading

from transformer_serving.client import BertClient


def client_clone(id, idx):
    bc = BertClient(port=int(sys.argv[1]),
                    port_out=int(sys.argv[2]),
                    identity=id)
    for j in bc.fetch():
        print('clone-client-%d: received %d x %d' %
              (idx, j.shape[0], j.shape[1]))


if __name__ == '__main__':
    bc = BertClient(port=int(sys.argv[1]), port_out=int(sys.argv[2]))
    # start two cloned clients sharing the same identity as bc
    for j in range(2):
        t = threading.Thread(target=client_clone, args=(bc.identity, j))
        t.start()

    with open('README.md') as fp:
        data = [v for v in fp if v.strip()]

    for _ in range(3):
        vec = bc.encode(data)
        print('bc received %d x %d' % (vec.shape[0], vec.shape[1]))