def testMergeShapes(self): # All inputs unknown. p1 = tf.placeholder(tf.float32) p2 = tf.placeholder(tf.float32) p3 = tf.placeholder(tf.float32) m, index = control_flow_ops.merge([p1, p2, p3]) self.assertIs(None, m.get_shape().ndims) self.assertEqual([], index.get_shape()) # All inputs known but different. p1 = tf.placeholder(tf.float32, shape=[1, 2]) p2 = tf.placeholder(tf.float32, shape=[2, 1]) m, index = control_flow_ops.merge([p1, p2]) self.assertIs(None, m.get_shape().ndims) self.assertEqual([], index.get_shape()) # All inputs known but same. p1 = tf.placeholder(tf.float32, shape=[1, 2]) p2 = tf.placeholder(tf.float32, shape=[1, 2]) m, index = control_flow_ops.merge([p1, p2]) self.assertEqual([1, 2], m.get_shape()) self.assertEqual([], index.get_shape()) # Possibly the same but not guaranteed. p1 = tf.placeholder(tf.float32, shape=[1, 2]) p2 = tf.placeholder(tf.float32) p2.set_shape([None, 2]) m, index = control_flow_ops.merge([p1, p2]) self.assertIs(None, m.get_shape().ndims) self.assertEqual([], index.get_shape())
def testLoop_1(self): with self.test_session(): zero = tf.convert_to_tensor(0) one = tf.convert_to_tensor(1) n = tf.constant(10) enter_zero = control_flow_ops.enter(zero, "foo_1", False) enter_one = control_flow_ops.enter(one, "foo_1", False) enter_n = control_flow_ops.enter(n, "foo_1", False) merge_zero = control_flow_ops.merge([enter_zero, enter_zero], name="merge_zero")[0] merge_one = control_flow_ops.merge([enter_one, enter_one], name="merge_one")[0] merge_n = control_flow_ops.merge([enter_n, enter_n], name="merge_n")[0] less_op = tf.less(merge_n, merge_n) cond_op = control_flow_ops.loop_cond(less_op) switch_zero = control_flow_ops.switch(merge_zero, cond_op) switch_one = control_flow_ops.switch(merge_one, cond_op) switch_n = control_flow_ops.switch(merge_n, cond_op) next_zero = control_flow_ops.next_iteration(switch_zero[1]) next_one = control_flow_ops.next_iteration(switch_one[1]) next_n = control_flow_ops.next_iteration(switch_n[1]) merge_zero.op._update_input(1, next_zero) merge_one.op._update_input(1, next_one) merge_n.op._update_input(1, next_n) exit_n = control_flow_ops.exit(switch_n[0]) result = exit_n.eval() self.assertAllEqual(10, result)
def apply_with_random_selector(img_1, img_2, func, num_cases): sel = tf.random_uniform([], maxval=num_cases, dtype=tf.int32) # Pass the real x only to one of the func calls. img_1_results = [] img_2_results = [] for case in range(num_cases): img_1_results.append( func(control_flow_ops.switch(img_1, tf.equal(sel, case))[1], case)) img_2_results.append( func(control_flow_ops.switch(img_2, tf.equal(sel, case))[1], case)) img_1 = control_flow_ops.merge(img_1_results)[0] img_2 = control_flow_ops.merge(img_2_results)[0] return img_1, img_2
def apply_with_random_selector(image, func, num_cases): """random select a mode case to func(image, case)""" # random select a mode sel = tf.random_uniform([], maxval=num_cases, dtype=tf.int32) return control_flow_ops.merge([ func(control_flow_ops.switch(image, tf.equal(case, sel))[1], case) for case in range(num_cases)])[0]
def testLoop_2(self): with self.test_session(): zero = tf.constant(0) one = tf.constant(1) n = tf.constant(10) enter_i = control_flow_ops.enter(zero, "foo", False) enter_one = control_flow_ops.enter(one, "foo", True) enter_n = control_flow_ops.enter(n, "foo", True) merge_i = control_flow_ops.merge([enter_i, enter_i])[0] less_op = tf.less(merge_i, enter_n) cond_op = control_flow_ops.loop_cond(less_op) switch_i = control_flow_ops.switch(merge_i, cond_op) add_i = tf.add(switch_i[1], enter_one) with tf.device("/gpu:0"): next_i = control_flow_ops.next_iteration(add_i) merge_i.op._update_input(1, next_i) exit_i = control_flow_ops.exit(switch_i[0]) result = exit_i.eval() self.assertAllEqual(10, result)
def _process_switch(self, switch_op, ops_which_must_run, last_op_using_resource_tensor, merge_for_resource): """Processes a switch node for a resource input. When tensorflow creates a cond, it creates a control flow context for each branch of the cond. Each external tensor accessed by that branch is routed through a switch op, which gets created in the graph _after_ the op which uses that tensor get created. If the resource comes from another switch op we process that one first. _process_switch creates a corresponding merge node for the switch node. This merge node is added to the outer control flow context of the switch node. We also ensure that: 1. The switch node executes after the previous op which used the resource tensor 2. Any op which uses a resource output of the switch node executes before the merge for the switch node. 3. The next op which uses the input resource to the switch node (which might be another switch node for the other branch of the conditional) will execute after the merge node is done. 4. The merge node is marked as must_run so it will run even if no subsequent operation uses the resource. Args: switch_op: the switch op to be processed ops_which_must_run: the set of ops which must run last_op_using_resource_tensor: map from resource tensor to last op using it merge_for_resource: map from resource tensor to merge which must follow all usages of it. """ inp = switch_op.inputs[0] if inp.dtype == dtypes_module.resource and inp.op.type == "Switch": self._process_switch(inp.op, ops_which_must_run, last_op_using_resource_tensor, merge_for_resource) if switch_op.outputs[0] in merge_for_resource: return new_merge = control_flow_ops.merge(switch_op.outputs, name="artificial_merge") new_merge[0].op._control_flow_context = ( # pylint: disable=protected-access switch_op._control_flow_context.outer_context) # pylint: disable=protected-access # Ensures the merge always runs ops_which_must_run.add(new_merge[0].op) if inp in last_op_using_resource_tensor: # Ensures the switch exectutes after the previous op using the resource. switch_op._add_control_input(last_op_using_resource_tensor[inp]) # pylint: disable=protected-access # Ensure the next op outside the cond happens after the merge. last_op_using_resource_tensor[inp] = new_merge[0].op if inp in merge_for_resource: merge_for_resource[inp]._add_control_input(new_merge[0].op) # pylint: disable=protected-access for o in switch_op.outputs: # Ensures the merge will execute after all ops inside the cond merge_for_resource[o] = new_merge[0].op
def random_resize(im, size): choice = tf.random_uniform([], maxval=4, dtype=tf.int32) im = control_flow_ops.merge([ tf.image.resize_images( control_flow_ops.switch(im, tf.equal(choice, method))[1], size, method) for method in range(4) ])[0] return im
def _testSwitchMerge_1(self, use_gpu): with self.test_session(use_gpu=use_gpu): data = tf.constant([1, 2, 3, 4, 5, 6], name="data") ports = tf.convert_to_tensor(True, name="ports") switch_op = control_flow_ops.switch(data, ports) merge_op = control_flow_ops.merge(switch_op)[0] result = merge_op.eval() self.assertAllEqual(np.arange(1, 7), result)
def testSwitchMergeIdentity_1(self): with self.test_session(): data = tf.constant([1, 2, 3, 4, 5, 6], name="data") ports = tf.convert_to_tensor(True, name="ports") switch_op = control_flow_ops.switch(data, ports) merge_op = control_flow_ops.merge(switch_op)[0] id_op = tf.identity(merge_op) result = id_op.eval() self.assertAllEqual(np.arange(1, 7), result)
def injectFaultMerge(inputs, b): "Function to call injectFault on Merge" # FIXME: Implement this functionality logging.debug("Calling Operator Merge") op = control_flow_ops.merge(inputs=[inputs, b]) sess = tf.Session() res = sess.run(op) return res
def testSwitchMergeLess_1(self): with self.test_session(): data = tf.constant([1, 2, 3, 4, 5, 6], name="data") zero = tf.convert_to_tensor(0) one = tf.convert_to_tensor(1) less_op = tf.less(zero, one) switch_op = control_flow_ops.switch(data, less_op) merge_op = control_flow_ops.merge(switch_op)[0] result = merge_op.eval() self.assertAllEqual(np.arange(1, 7), result)
def testSwitchMergeAddIdentity_1(self): with self.test_session(): data = tf.constant([1, 2, 3, 4, 5, 6], name="data") ports = tf.convert_to_tensor(True, name="ports") switch_op = control_flow_ops.switch(data, ports) one = tf.constant(1) add_op = tf.add(switch_op[0], one) id_op = tf.identity(switch_op[1]) merge_op = control_flow_ops.merge([add_op, id_op])[0] result = merge_op.eval() self.assertAllEqual(np.arange(1, 7), result)
def testSwitchMergeAddMul_1(self): with self.test_session(): data = tf.constant([1, 2, 3, 4, 5, 6], name="data") ports = tf.convert_to_tensor(True, name="ports") switch_op = control_flow_ops.switch(data, ports) one = tf.constant(1) add_op = tf.add(switch_op[0], one) five = tf.constant(5) mul_op = tf.mul(switch_op[1], five) merge_op = control_flow_ops.merge([add_op, mul_op])[0] result = merge_op.eval() self.assertAllEqual(np.array([x * 5 for x in [1, 2, 3, 4, 5, 6]]), result)
def random_grayscale(im): def convert(im, flag): if flag == 0: im = tf.image.rgb_to_grayscale(im) im = tf.stack([im, im, im], axis=-1) return im choice = tf.random_uniform([], maxval=4, dtype=tf.int32) im = control_flow_ops.merge([ convert(control_flow_ops.switch(im, tf.equal(choice, flag))[1], flag) for flag in range(2) ])[0] return im
def testSwitchMergeIndexedSlices(self): with self.test_session(): values = tf.constant([1, 2, 3, 4, 5, 6]) indices = tf.constant([0, 2, 4, 6, 8, 10]) data = tf.IndexedSlices(values, indices) pred = tf.convert_to_tensor(True) switch_op = control_flow_ops.switch(data, pred) merge_op = control_flow_ops.merge(switch_op)[0] val = merge_op.values.eval() ind = merge_op.indices.eval() self.assertAllEqual(np.arange(1, 7), val) self.assertAllEqual(np.arange(0, 12, 2), ind)
def testLoop_false(self): with self.test_session(): false = tf.convert_to_tensor(False) n = tf.constant(10) enter_false = control_flow_ops.enter(false, "foo_1", False) enter_n = control_flow_ops.enter(n, "foo_1", False) merge_n = control_flow_ops.merge([enter_n], name="merge_n")[0] switch_n = control_flow_ops.switch(merge_n, enter_false) exit_n = control_flow_ops.exit(switch_n[0]) result = exit_n.eval() self.assertAllEqual(10, result)
def apply_with_random_selector(x, func, num_cases): """Computes func(x, sel), with sel sampled from [0...num_cases-test]. Args: x: input Tensor. func: Python function to apply. num_cases: Python int32, number of cases to sample sel from. Returns: The result of func(x, sel), where func receives the value of the selector as a python integer, but sel is sampled dynamically. """ sel = tf.random_uniform([], maxval=num_cases, dtype=tf.int32) # Pass the real x only to one of the func calls. return control_flow_ops.merge([ func(control_flow_ops.switch(x, tf.equal(sel, case))[1], case) for case in range(num_cases) ])[0]
def create_q_net(self, state_inputs, # NHWC format. action_inputs_training_q, scope, trainable, action_inputs_training_policy=None, # None for target net. cond_training_q=None # bool to control switch. can be None for target net. ): with tf.variable_scope(scope): # 输入归一化层 prev_layer=self.input_normalizer(state_inputs,**self.input_norm_params) ##fc layers l = 1 # start from fc-1 as 1 for n_unit, activation, initializer, normalizer, norm_param, regularizer in zip( self.n_fc_units, self.fc_activations, self.fc_initializers, self.fc_normalizers, self.fc_norm_params, self.fc_regularizers): # 传入动作数据 if l == DDPG_CFG.include_action_fc_layer: if action_inputs_training_policy is None: # target net actions = action_inputs_training_q else: # add logic for selecting online net action inputs # switch return :(output_false, output_true) (_, sw_action_training_q) = switch(data=action_inputs_training_q, pred=cond_training_q, name='switch_actions_training_q') (sw_action_training_policy, _) = switch(data=action_inputs_training_policy, pred=cond_training_q, name='switch_actions_training_policy') (actions, _) = merge([sw_action_training_q, sw_action_training_policy]) prev_layer = tf.concat([prev_layer, actions], axis=1) l += 1 prev_layer = fully_connected(prev_layer, num_outputs=n_unit, activation_fn=activation, weights_initializer=initializer, weights_regularizer=regularizer, normalizer_fn=normalizer, #when specify norm , bias will be ignored. normalizer_params=norm_param, trainable=trainable) # output layer. fully_connected will create bias which is not wanted in output layer. output_layer = fully_connected(inputs=prev_layer,num_outputs=1, activation_fn=None, weights_initializer=self.output_layer_initializer, weights_regularizer=self.output_layer_regularizer, biases_initializer=None, # to skip bias in output layer trainable=trainable) return output_layer
def Test(): data = tf.constant([1, 2, 3, 4, 5, 6]) zero = tf.convert_to_tensor(0) one = tf.convert_to_tensor(1) less_op = tf.less(zero, one) switch_op = control_flow_ops.switch(data, less_op) merge_op = control_flow_ops.merge(switch_op)[0] result = tf.transpose(merge_op) tensor_info_result = tf.compat.v1.saved_model.utils.build_tensor_info( result) signature_def = tf.saved_model.signature_def_utils.build_signature_def( inputs=None, outputs={'result': tensor_info_result}, method_name='some_function') return {'key': signature_def}
def Test(): data = tf.constant([1, 2, 3, 4, 5, 6]) # Create placeholders to prevent constant folding. x_op = tf.placeholder(dtype=tf.int32) y_op = tf.placeholder(dtype=tf.int32) less_op = tf.less(x_op, y_op) switch_op = control_flow_ops.switch(data, less_op) merge_op = control_flow_ops.merge(switch_op)[0] result = tf.transpose(merge_op) tensor_info_result = tf.compat.v1.saved_model.utils.build_tensor_info( result) signature_def = tf.saved_model.signature_def_utils.build_signature_def( inputs=None, outputs={'result': tensor_info_result}, method_name='some_function') return {'key': signature_def}, None, None
def testSwitchMerge(self): with self.cached_session() as sess: predicate = array_ops.placeholder(dtypes.bool) with self.test_scope(): false_output, true_output = control_flow_ops.switch( data=constant_op.constant(42.0), pred=predicate) with ops.control_dependencies( [array_ops.identity(false_output)]): five = constant_op.constant(5.0) with ops.control_dependencies( [array_ops.identity(true_output)]): ten = constant_op.constant(10.0) result = control_flow_ops.merge([five, ten]) with_true = sess.run(result, {predicate: True}) self.assertEquals(with_true.output, 10.0) self.assertEquals(with_true.value_index, 1) with_false = sess.run(result, {predicate: False}) self.assertEquals(with_false.output, 5.0) self.assertEquals(with_false.value_index, 0)
def apply_with_random_selector(x, func, num_cases): """Computes func(x, sel), with sel sampled from [0...num_cases-1]. TODO(coreylynch): add as a dependency, when slim or tensorflow/models are pipfied. Source: https://raw.githubusercontent.com/tensorflow/models/a9d0e6e8923a4/slim/preprocessing/inception_preprocessing.py Args: x: input Tensor. func: Python function to apply. num_cases: Python int32, number of cases to sample sel from. Returns: The result of func(x, sel), where func receives the value of the selector as a python integer, but sel is sampled dynamically. """ sel = tf.random_uniform([], maxval=num_cases, dtype=tf.int32) # Pass the real x only to one of the func calls. return control_flow_ops.merge([ func(control_flow_ops.switch(x, tf.equal(sel, case))[1], case) for case in range(num_cases)])[0]
def random_distort_color(im): def distort(im, order): if order == 0: im = random_contrast( random_hue(random_saturation(random_brightness(im)))) elif order == 1: im = random_hue( random_contrast(random_brightness(random_saturation(im)))) elif order == 2: im = random_saturation( random_brightness(random_hue(random_contrast(im)))) else: im = random_brightness( random_contrast(random_saturation(random_hue(im)))) return im choice = tf.random_uniform([], maxval=4, dtype=tf.int32) im = control_flow_ops.merge([ distort( control_flow_ops.switch(im, tf.equal(choice, order))[1], order) for order in range(4) ])[0] return im
def create_q_net(self, state_inputs, # NHWC format. action_inputs_training_q, scope, trainable, action_inputs_training_policy=None, # None for target net. cond_training_q=None # bool to control switch. can be None for target net. ): prev_layer = state_inputs conv_layers = [] fc_layers = [] with tf.variable_scope(scope): ##conv layers # TODO add batch_norm to input process. for n_maps, kernel_size, stride, padding, activation, initializer, \ normalizer, norm_param, regularizer in zip( self.conv_n_feature_maps, self.conv_kernel_sizes, self.conv_strides, self.conv_padding, self.conv_activations, self.conv_initializers, self.conv_normalizers, self.conv_norm_params, self.conv_regularizers): prev_layer = conv2d(prev_layer, num_outputs=n_maps, kernel_size=kernel_size, stride=stride, padding=padding, activation_fn=activation, data_format='NHWC', normalizer_fn=normalizer, normalizer_params=norm_param, weights_initializer=initializer, weights_regularizer=regularizer, trainable=trainable) conv_layers.append(prev_layer) # end conv layer ##fc layers # flat the output of last conv layer to (batch_size, n_fc_in) # TODO calc n_fc_in from the prev_layer tensor shape. prev_layer = tf.reshape(conv_layers[-1], shape=[-1, self.n_fc_in]) l = 1 # start from fc-1 as 1 for n_unit, activation, initializer, normalizer, norm_param,regularizer in zip( self.n_fc_units, self.fc_activations, self.fc_initializers, self.fc_normalizers, self.fc_norm_params, self.fc_regularizers): # include action_inputs if l == DDPG_CFG.include_action_fc_layer: # prev_layer is fc-1-out,shape (batch_size, n_fc1_units) # action_inputs shape ( batch_size, a_dim) # NOTE: online q and target q are different now, but # different part is without params, so softupdate and copy-init # from online to target will still work. if action_inputs_training_policy is None: # target net actions = action_inputs_training_q else: # add logic for selecting online net action inputs # switch return :(output_false, output_true) (_, sw_action_training_q) = switch(data=action_inputs_training_q, pred=cond_training_q, name='switch_actions_training_q') (sw_action_training_policy, _) = switch(data=action_inputs_training_policy, pred=cond_training_q, name='switch_actions_training_policy') (actions, _) = merge([sw_action_training_q, sw_action_training_policy]) prev_layer = tf.concat([prev_layer, actions], axis=1) l += 1 prev_layer = fully_connected(prev_layer, num_outputs=n_unit, activation_fn=activation, weights_initializer=initializer, normalizer_fn=normalizer, normalizer_params=norm_param, weights_regularizer=regularizer, trainable=trainable) fc_layers.append(prev_layer) # end fc layers ##output layer # num_output = 1 , means Q(s,a) is a scalar. output_layer = fully_connected(fc_layers[-1], num_outputs=1, activation_fn=None, weights_initializer=self.output_layer_initializer, weights_regularizer=self.output_layer_regularizer, trainable=trainable) # # linear layer connected to 1 output representing Q(s,a) # # Weights are init to Uniform[-3e-3, 3e-3] # w_init = tflearn.initializations.uniform(minval=-0.003, maxval=0.003) # out = tflearn.fully_connected(net, 1, weights_init=w_init) # return inputs, action, out # == == end with variable_scope() == return output_layer
def create_q_net( self, state_inputs, # NHWC format. action_inputs_training_q, scope, trainable, action_inputs_training_policy=None, # None for target net. cond_training_q=None # bool to control switch. can be None for target net. ): with tf.variable_scope(scope): #input norm layer prev_layer = self.input_normalizer(state_inputs, **self.input_norm_params) ##fc layers # flat the output of last conv layer to (batch_size, n_fc_in) l = 1 # start from fc-1 as 1 for n_unit, activation, initializer, normalizer, norm_param, regularizer in zip( self.n_fc_units, self.fc_activations, self.fc_initializers, self.fc_normalizers, self.fc_norm_params, self.fc_regularizers): # include action_inputs if l == DDPG_CFG.include_action_fc_layer: # prev_layer is fc-1-out,shape (batch_size, n_fc1_units) # action_inputs shape ( batch_size, a_dim) # NOTE: online q and target q are different now, but # different part is without params, so softupdate and copy-init # from online to target will still work. if action_inputs_training_policy is None: # target net actions = action_inputs_training_q else: # add logic for selecting online net action inputs # switch return :(output_false, output_true) (_, sw_action_training_q) = switch( data=action_inputs_training_q, pred=cond_training_q, name='switch_actions_training_q') (sw_action_training_policy, _) = switch(data=action_inputs_training_policy, pred=cond_training_q, name='switch_actions_training_policy') (actions, _) = merge( [sw_action_training_q, sw_action_training_policy]) prev_layer = tf.concat([prev_layer, actions], axis=1) l += 1 prev_layer = fully_connected( prev_layer, num_outputs=n_unit, activation_fn=activation, weights_initializer=initializer, weights_regularizer=regularizer, normalizer_fn= normalizer, #when specify norm , bias will be ignored. normalizer_params=norm_param, trainable=trainable) # end fc layers ##output layer. fully_connected will create bias which is not wanted in output layer. output_layer = fully_connected( inputs=prev_layer, num_outputs=1, activation_fn=None, weights_initializer=self.output_layer_initializer, weights_regularizer=self.output_layer_regularizer, biases_initializer=None, # to skip bias in output layer trainable=trainable) # num_output = 1 , means Q(s,a) is a scalar. # output_layer = fully_connected(prev_layer, num_outputs=1, activation_fn=None, # weights_initializer=self.output_layer_initializer, # weights_regularizer=self.output_layer_regularizer, # trainable=trainable) # == == end with variable_scope() == return output_layer
def __network(self, input, netname, online=True, reg=None, bn_training=False): collections = [ tf.compat.v1.GraphKeys.GLOBAL_VARIABLES, netname + '_train_vars' ] with tf.variable_scope(netname, reuse=tf.AUTO_REUSE): policyLayers = [self.__state_dim, 64, 128, 256, 128, 64] QLayers = [ self.__state_dim + self.__action_dim, 64, 128, 256, 128, 64 ] with tf.variable_scope('policy', reuse=tf.AUTO_REUSE): i = input #i = tf.layers.batch_normalization(input,training=bn_training) for index, layer in enumerate(policyLayers): i = self.__dense(i, layer, collections=collections, name='dense_' + str(index), reg=reg) act_x = self.__dense(i, self.__action_dim, collections=collections, active=False, name='dense_action', reg=reg) with tf.variable_scope('act'): act = tf.tanh(act_x) if online: (sw_policy, _) = switch(act, self.con_training_q, name='sw_policy') (_, sw_action) = switch(self.action, self.con_training_q, name='sw_action') (act, _) = merge([sw_policy, sw_action], name='merge') with tf.variable_scope('Q', reuse=tf.AUTO_REUSE): i = tf.concat([act, input], 1) #i = tf.layers.batch_normalization(i,training=bn_training) for index, layer in enumerate(QLayers): i = self.__dense(i, layer, collections=collections, name='dense_' + str(index), reg=reg) i = self.__dense(i, 1, collections=collections, active=False, name='q_value', reg=reg) if online: return [act_x, act, i] else: return i
""" num_inputs = len(x) rand_sel = tf.random_uniform([], maxval=num_cases, dtype=tf.int32) # Pass the real x only to one of the func calls. tuples = [list() for t in x] for case in range(num_cases): new_x = [ control_flow_ops.switch(t, tf.equal(rand_sel, case))[1] for t in x ] output = func(tuple(new_x), case) for j in range(num_inputs): tuples[j].append(output[j]) for i in range(num_inputs): tuples[i] = control_flow_ops.merge(tuples[i])[0] return tuple(tuples) def _random_integer(minval, maxval, seed): """Returns a random 0-D tensor between minval and maxval. Args: minval: minimum value of the random tensor. maxval: maximum value of the random tensor. seed: random seed. Returns: A random 0-D tensor between minval and maxval. """ return tf.random_uniform([],
def handler(cmd_queue, chan): global object_dict global object_id global callback_stack global initialized if not initialized: callback_stack = [] object_dict = dict() object_id = 1 # TODO: forward logging or disable it in test tf.logging.set_verbosity(tf.logging.INFO) initialized = True print("handler is initialized") while True: cmd = cmd_queue.get(block=True) cmd_id = cmd.__get_cmd_id() print("new command id %d" % cmd_id) try: if cmd_id == TF_PY_NW_CALLBACK_DONE: param.base.done = STATUS_TASK_DONE ret = fcntl.ioctl(kvm_fd, IOCTL_KVM_NOTIFY_TASK_FINISHED, task.node_id) if ret < 0: print("notify task completion failed: %d\n" % ret); if callback_stack and \ callback_stack[-1]["callback_id"] == param.base.object_id: print("callback is finished") return STATUS_CALLBACK_DONE else: print("callback is error") return STATUS_CALLBACK_ERROR if cmd_id == TF_PY_SESSION_INIT: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) sess = tf.Session(param0, param1, param2) # assign object_id ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = sess ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() #elif cmd_id == TF_PY_SESSION_ENTER: # sess = object_dict[param.base.object_id] # ctx_sess = sess.__enter__() # if sess is ctx_sess: # pass # else: # unlikely # print("unlikely to search for sess") # param.base.object_id = next(obj_id for obj_id, obj in # object_dict.items() if obj is ctx_sess) #elif cmd_id == TF_PY_SESSION_EXIT: # param1 = parse_param(vm_id, mm, param, param.param1) # param2 = parse_param(vm_id, mm, param, param.param2) # param3 = parse_param(vm_id, mm, param, param.param3) # sess = object_dict[param.base.object_id] # sess.__exit__(param1, param2, param3) #elif cmd_id == TF_PY_SESSION_DEL: # sess = object_dict[param.base.object_id] # sess.__del__() # deprecated #elif cmd_id == TF_PY_SESSION_RUN: # sess = object_dict[param.base.object_id] # param1 = parse_param(vm_id, mm, param, param.param1) # if type(param1) == NwObject: # print("get NwObject=%d" % param1.object_id()) # param1 = object_dict[param1.object_id()] # print(param1) # ret_val = sess.run(param1) # print(ret_val) # writeback_result(vm_id, mm, param, param.ret_val1, ret_val); elif cmd_id == TF_PY_TPU_CLUSTER_RESOLVER_INIT: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) print("TPUClusterResolver", param0, param1, param2) tpu_grpc = tf.contrib.cluster_resolver.TPUClusterResolver( tpu=param0, zone=param1, project=param2) # assign object_id ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = tpu_grpc ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() # deprecated elif cmd_id == TF_PY_TPU_CLUSTER_RESOLVER_MASTER: tpu_grpc = object_dict[cmd.__get_object_id()] # FIXED: may have parameters tpu_grpc_url = tpu_grpc.master() # serialize return value dump_ret, len_ret = pickle_arg(tpu_grpc_url) total_buffer_size = chan.buffer_size(len_ret) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), total_buffer_size) ret_cmd.__set_cmd_base(TENSORFLOW_PY_API, TF_PY_TPU_CLUSTER_RESOLVER_MASTER_RET) offset_ret = ret_cmd.attach_buffer(dump_ret, len_ret) ret_cmd.__set_tf_args([(len_ret, offset_ret)]) ret_cmd.send() elif cmd_id == TF_PY_TPU_INITIALIZE_SYSTEM: # TODO: may have parameters ts = tpu.initialize_system() ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ts ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_TPU_SHUTDOWN_SYSTEM: # TODO: may have parameters ts = tpu.shutdown_system() ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ts ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_GLOBAL_VARIABLES_INITIALIZER: # TODO: may have parameters ts = tf.global_variables_initializer() ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ts ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_ONES: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) print(param0) if param1 is None: param1 = dtypes.float32 print(param1) var = tf.ones(param0, param1) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = var ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_RANDOM_UNIFORM: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param4 = unpickle_arg(cmd, 4) param5 = unpickle_arg(cmd, 5) if param1 is None: param1 = 0 if param3 is None: param3 = dtypes.float32 print(param0, param1, param2, param3) var = tf.random_uniform(param0, param1, param2, param3, param4, param5) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = var ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_TRANSPOSE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param0 = object_dict[param0.object_id()] if param2 is None: param2 = "transpose" if param3 is None: param3 = False print("transpose", param0, param1, param2, param3) var = tf.transpose(param0, param1, param2, param3) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = var ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_CAST: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param0 = object_dict[param0.object_id()] print("cast", param0, param1, param2) var = tf.cast(param0, param1, param2) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = var ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_EXPAND_DIMS: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param0 = object_dict[param0.object_id()] print("expand_dims", param0, param1, param2, param3) var = tf.expand_dims(param0, param1, param2, param3) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = var ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_CONCAT: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param0 = object_dict[param0.object_id()] if param2 is None: param2 = "concat" print("concat", param0, param1, param2) var = tf.concat(param0, param1, param2) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = var ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_EQUAL: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param0 = object_dict[param0.object_id()] print("equal", param0, param1, param2) if isinstance(param1, NwObject): param1 = object_dict[param1.object_id()] result = tf.equal(param0, param1, param2) print(result) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = result ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_FIXED_LEN_FEATURE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) feature = tf.FixedLenFeature(param0, param1, param2) print(feature) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = feature ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_VAR_LEN_FEATURE: param0 = unpickle_arg(cmd, 0) feature = tf.VarLenFeature(param0) print(feature) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = feature ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_PARSE_SINGLE_EXAMPLE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) print(param1, param2) # expand embedded NwObject if isinstance(param0, NwObject): param0 = object_dict[param0.object_id()] dict_walker(param1) print("after translation", param0, param1) result = tf.parse_single_example(param0, param1, param2, param3) print(result) dict_mapper(result) print(result) dump_ret, len_ret = pickle_arg(result) total_buffer_size = chan.buffer_size(len_ret) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), total_buffer_size) ret_cmd.__set_cmd_base(TENSORFLOW_PY_API, TF_PY_PARSE_SINGLE_EXAMPLE_RET) offset_ret = ret_cmd.attach_buffer(dump_ret, len_ret) ret_cmd.__set_tf_args([(len_ret, offset_ret)]) ret_cmd.send() elif cmd_id == TF_PY_CONTROL_FLOW_OPS_SWITCH: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param0 = object_dict[param0.object_id()] param1 = object_dict[param1.object_id()] print("switch", param0, param1, param2, param3) result = control_flow_ops.switch(param0, param1, param2, param3) print(result) mapped_tuple = tuple_mapper(result, [0, 1]) print(mapped_tuple) dump_ret, len_ret = pickle_arg(mapped_tuple) total_buffer_size = chan.buffer_size(len_ret) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), total_buffer_size) ret_cmd.__set_cmd_base(TENSORFLOW_PY_API, TF_PY_CONTROL_FLOW_OPS_SWITCH_RET) offset_ret = ret_cmd.attach_buffer(dump_ret, len_ret) ret_cmd.__set_tf_args([(len_ret, offset_ret)]) ret_cmd.send() elif cmd_id == TF_PY_CONTROL_FLOW_OPS_MERGE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param0 = object_dict[param0.object_id()] print("merge", param0, param1) list_walker(param0) print("merge-new", param0, param1) result = control_flow_ops.merge(param0, param1) print(result) mapped_tuple = tuple_mapper(result, [0]) print(mapped_tuple) dump_ret, len_ret = pickle_arg(mapped_tuple) total_buffer_size = chan.buffer_size(len_ret) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), total_buffer_size) ret_cmd.__set_cmd_base(TENSORFLOW_PY_API, TF_PY_CONTROL_FLOW_OPS_MERGE_RET) offset_ret = ret_cmd.attach_buffer(dump_ret, len_ret) ret_cmd.__set_tf_args([(len_ret, offset_ret)]) ret_cmd.send() elif cmd_id == TF_PY_TPU_REWRITE: # TODO: may have more parameters param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) # default parameter if param1 is None: param1 = None # expand embedded NwObject list_walker(param1) func = tpu.rewrite(param0, param1) print("Rewrite result:", func, " object id =", object_id) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = func ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_TPU_RUN_CONFIG: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param4 = unpickle_arg(cmd, 4) # default parameter if param0 is None: param0 = None if param1 is None: param1 = None if param2 is None: param2 = None if param3 is None: param3 = None # expand embedded NwObject param3 = object_dict[param3.object_id()] print(param3, param4) func = tpu.RunConfig(param0, param1, param2, param3, **param4) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = func ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_TPU_TPU_ESTIMATOR: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param4 = unpickle_arg(cmd, 4) param5 = unpickle_arg(cmd, 5) param6 = unpickle_arg(cmd, 6) param7 = unpickle_arg(cmd, 7) param8 = unpickle_arg(cmd, 8) param9 = unpickle_arg(cmd, 9) param10 = unpickle_arg(cmd, 10) param11 = unpickle_arg(cmd, 11) # default parameter if param0 is None: param0 = None if param1 is None: param1 = None if param2 is None: param2 = None if param3 is None: param3 = None if param4 is None: param4 = True if param5 is None: param5 = None if param6 is None: param6 = None if param7 is None: param7 = None if param8 is None: param8 = None if param9 is None: param9 = True if param10 is None: param10 = True if param11 is None: param11 = None # expand embedded NwObject param2 = object_dict[param2.object_id()] print(param2) func = tpu.TPUEstimator(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = func ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_IMAGE_RESIZE_IMAGES: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param4 = unpickle_arg(cmd, 4) # default parameter if param2 is None: param2 =ResizeMethod.BILINEAR if param3 is None: param3 = False if param4 is None: param4 = False # expand embedded NwObject param0 = object_dict[param0.object_id()] print(param0) img = tf.image.resize_images(param0, param1, param2, param3, param4) # TODO: it may return a float ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = img ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_SLICE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) # expand embedded NwObject print(param0, param1, param2, param3) param0 = object_dict[param0.object_id()] ret = tf.slice(param0, param1, param2, param3) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ret ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_SHAPE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) if param2 is None: param2 = dtypes.int32 # expand embedded NwObject print(param0, param1, param2) param0 = object_dict[param0.object_id()] ret = tf.shape(param0, param1, param2) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ret ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_IMAGE_SAMPLE_DISTORTED_BOUNDING_BOX: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param4 = unpickle_arg(cmd, 4) param5 = unpickle_arg(cmd, 5) param6 = unpickle_arg(cmd, 6) param7 = unpickle_arg(cmd, 7) param8 = unpickle_arg(cmd, 8) param9 = unpickle_arg(cmd, 9) # default parameter if param4 is None: param4 = 0.1 print("sample_distorted_bounding_box", param0, param1) result = tf.image.sample_distorted_bounding_box( param0, param1, param2, param3, param4, param5, param6, param7, param8, param9) print(result) mapped_tuple = tuple_mapper(result, [0, 1, 2]) print(mapped_tuple) dump_ret, len_ret = pickle_arg(mapped_tuple) total_buffer_size = chan.buffer_size(len_ret) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), total_buffer_size) ret_cmd.__set_cmd_base(TENSORFLOW_PY_API, TF_PY_CONTROL_FLOW_OPS_MERGE_RET) offset_ret = ret_cmd.attach_buffer(dump_ret, len_ret) ret_cmd.__set_tf_args([(len_ret, offset_ret)]) ret_cmd.send() elif cmd_id == TF_PY_IMAGE_DRAW_BOUNDING_BOXES: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) # expand embedded NwObject print(param0, param1, param2) param0 = object_dict[param0.object_id()] param1 = object_dict[param1.object_id()] ret = tf.image.draw_bounding_boxes(param0, param1, param2) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ret ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_IMAGE_DECODE_JPEG: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) param4 = unpickle_arg(cmd, 4) param5 = unpickle_arg(cmd, 5) param6 = unpickle_arg(cmd, 6) param7 = unpickle_arg(cmd, 7) if param1 is None: param1 = 0 if param2 is None: param2 = 1 if param3 is None: param3 = True if param4 is None: param4 = False if param5 is None: param5 = 1 if param6 is None: param6 = "" param0 = object_dict[param0.object_id()] ret = tf.image.decode_jpeg(param0, param1, param2, param3, param4, param5, param6, param7) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ret ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_IMAGE_CONVERT_IMAGE_DTYPE: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) param3 = unpickle_arg(cmd, 3) # expand embedded NwObject print(param0, param1, param2, param3) param0 = object_dict[param0.object_id()] if param2 is None: param2 = False ret = tf.image.convert_image_dtype(param0, param1, param2, param3) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ret ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_DATA_DATASET_LIST_FILES: param0 = unpickle_arg(cmd, 0) param1 = unpickle_arg(cmd, 1) param2 = unpickle_arg(cmd, 2) print(param0, param1, param2) if isinstance(param0, NwObject): param0 = object_dict[param0.object_id()] ret = tf.data.Dataset.list_files(param0, param1, param2) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = ret ret_cmd.__set_object_id(object_id) object_id += 1 ret_cmd.send() elif cmd_id == TF_PY_NW_OBJECT: obj = object_dict[cmd.__get_object_id()] name = unpickle_arg(cmd, 0) args = unpickle_arg(cmd, 1) kwargs = unpickle_arg(cmd, 2) print("NwObject", obj, name, args, kwargs) # expand embedded NwObject args = list(args) list_walker(args) args = tuple(args) dict_walker(kwargs) print("after translation", obj, name, args, kwargs) # run result = getattr(obj, name)(*(args or []), **(kwargs or {})) print("analyze type", type(result), result) # TODO: go through tuple, dict or list if isinstance(result, tuple): result = tuple_mapper(result, range(len(result))) if isinstance(result, dict): dict_mapper(result) if isinstance(result, list): list_mapper(result) ret_cmd = None # serialize return value # if isinstance(result, list): # Check whether a nested list pickles # https://github.com/uqfoundation/dill/issues/307 # pickleable = pickle.pickles(reduce(operator.add, result)) # else: # pickleable = pickle.pickles(result) pickleable = True if is_unpickleable_type(result) or not pickleable: ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), 0) object_dict[object_id] = result ret_cmd.__set_object_id(object_id) object_id += 1 else: dump_ret, len_ret = pickle_arg(result) total_buffer_size = chan.buffer_size(len_ret) ret_cmd = chan.new_command(chan.__get_sizeof_tf_cmd(), total_buffer_size) ret_cmd.__set_cmd_base(TENSORFLOW_PY_API, TF_PY_NW_OBJECT_RET) offset_ret = ret_cmd.attach_buffer(dump_ret, len_ret) ret_cmd.__set_object_id(0) ret_cmd.__set_tf_args([(len_ret, offset_ret)]) ret_cmd.send() elif cmd_id == TF_PY_NW_METHOD: # Reuse as callback #ins = parse_param(vm_id, mm, param, param.param1) #name = parse_param(vm_id, mm, param, param.param2) #print(ins, name) #method = getattr(ins, name) #print(method) #object_dict[object_id] = method cw = callback_constructor(object_id, callback_param, param, mm, vm_id, cmd_queue, kvm_fd) object_dict[object_id] = cw param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_NW_CALLBACK_TEST: nw_func = parse_param(vm_id, mm, param, param.param1) print(nw_func, nw_func.object_id()) func = object_dict[nw_func.object_id()] print("callback func", func) x = parse_param(vm_id, mm, param, param.param2) y = parse_param(vm_id, mm, param, param.param3) result = func(x, y) print(result) writeback_result(vm_id, mm, param, param.ret_val1, result); else: print("unsupported Tensorflow API %d" % cmd_id) except Exception as error: print("fault: ", str(error)) exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno) traceback.print_stack() cmd.free_command() print("finished cmd %d" % cmd_id)
def create_op(self, *args, **kwargs): """Creates an `Operation`. For operations of the following form orig_value = op(*args, **kwargs) this function constructs the following subgraph : v = Variable() if v is not initialized: orig_value = op(*args, **kwargs) v.assign(orig_value) # Initializes v return orig_value else: return v The above transformation is not performed and the original op is returned as is if any of the following is true: * `_return_as_is` flag is set to true. * op_type is listed in _PASS_THROUGH_OPS * op has no outputs. * One of the op's return value has a ref type. Args: *args: Arguments for create_op() **kwargs: Keyword arguments for create_op(). Refer to tensorflow.python.framework.ops.Graph.create_op() for the mandatory and optional arguments. Returns: An Operation. Raises: UnimplementedError: if output type is a reference and the op's type is not one of the supported types in `_REF_OPS_WHITELIST`. """ op_type = kwargs['op_type'] if 'op_type' in kwargs else args[0] output_dtypes = kwargs['dtypes'] if 'dtypes' in kwargs else args[2] output_dtypes = [dtypes.as_dtype(d) for d in output_dtypes] if self._return_as_is or op_type in _PASS_THROUGH_OPS: return self._wrap(super(ImperativeGraph, self).create_op(*args, **kwargs)) if not output_dtypes: return self._wrap( super(ImperativeGraph, self).create_op(*args, **kwargs)) output_has_ref = any([dtype._is_ref_dtype for dtype in output_dtypes]) # pylint: disable=protected-access if output_has_ref: if op_type not in _REF_OPS_WHITELIST: raise errors.UnimplementedError(None, None, op_type + ' op not supported in ' 'imperative graph') ret = super(ImperativeGraph, self).create_op(*args, **kwargs) if self._in_variable_creation: if op_type == 'Assign': self.add_pending_init(ret) return self._wrap(ret) with self.return_as_is(): # Declares the variables to hold the output values of this op. op_output_var = [state_ops.variable_op_v2( tensor_shape.TensorShape(None), dtype, container=self._name) for dtype in output_dtypes] # Ops to free the resources used by the temporary cache variables. # The following two ops are created for each cache variable, # having no control dependencies on any other ops : # var_handle_op ----> destroy_resource_op for dtype, v in zip(output_dtypes, op_output_var): with ops.control_dependencies(None): self._variable_cleanup_ops += [ gen_resource_variable_ops.destroy_resource_op( gen_resource_variable_ops.var_handle_op( dtype, tensor_shape.TensorShape(None), container=self._name, shared_name=v.op.name), ignore_lookup_error=True)] # Create the conditional to run the original op only when the variable # corresponding to the first output is not initialized. inited = state_ops.is_variable_initialized(op_output_var[0]) v_f, v_t = control_flow_ops.ref_switch(op_output_var[0], inited) # pylint: disable=protected-access v_f_op = gen_array_ops._ref_identity(v_f) v_t_op = gen_array_ops._ref_identity(v_t) # pylint: enable=protected-access with ops.control_dependencies([v_f_op.op]): # Create the original op orig_op = self._wrap( super(ImperativeGraph, self).create_op(*args, **kwargs)) shapes = [val.get_shape() for val in orig_op.outputs] controls = [] for var, val in zip(op_output_var, orig_op.outputs): if (not val.get_shape().is_fully_defined() or val.get_shape().num_elements() > 0): assign_op = state_ops.assign(var, val, validate_shape=False) assign_op.set_shape(val.get_shape()) controls.append(assign_op) values = [] if len(controls) > 1: if control_flow_ops.IsSwitch(orig_op): # pylint: disable=protected-access controls = gen_control_flow_ops._ref_merge(controls) # pylint: enable=protected-access else: controls = control_flow_ops.tuple(controls) for var, val in zip(op_output_var, orig_op.outputs): with ops.control_dependencies(controls): with self.colocate_with(v_f_op): real_val = array_ops.identity(val) with ops.control_dependencies([v_t_op.op]): with self.colocate_with(v_t_op): stored_val = array_ops.identity(var) stored_val.set_shape(val.get_shape()) real_val, _ = control_flow_ops.merge([real_val, stored_val]) real_val.op.node_def.attr['_gradient_op_type'].CopyFrom( attr_value_pb2.AttrValue(s=compat.as_bytes(self._merge_op_type))) values.append(real_val) for i, _ in enumerate(shapes): values[i].set_shape(shapes[i]) self._outputs_map[orig_op.name] = values try: self._gradient_function_map[orig_op.name] = ops.get_gradient_function( orig_op) except (KeyError, LookupError): pass else: orig_op.node_def.attr['_gradient_op_type'].CopyFrom( attr_value_pb2.AttrValue( s=compat.as_bytes(self._imperative_op_type))) return MultiOutputOperation(values, orig_op)
def create_op(self, *args, **kwargs): """Creates an `Operation`. For operations of the following form orig_value = op(*args, **kwargs) this function constructs the following subgraph : v = Variable() if v is not initialized: orig_value = op(*args, **kwargs) v.assign(orig_value) # Initializes v return orig_value else: return v The above transformation is not performed and the original op is returned as is if any of the following is true: * `_return_as_is` flag is set to true. * op_type is listed in _PASS_THROUGH_OPS * op has no outputs. * One of the op's return value has a ref type. Args: *args: Arguments for create_op() **kwargs: Keyword arguments for create_op(). Refer to tensorflow.python.framework.ops.Graph.create_op() for the mandatory and optional arguments. Returns: An Operation. Raises: UnimplementedError: if output type is a reference and the op's type is not one of the supported types in `_REF_OPS_WHITELIST`. """ op_type = kwargs['op_type'] if 'op_type' in kwargs else args[0] output_dtypes = kwargs['dtypes'] if 'dtypes' in kwargs else args[2] output_dtypes = [dtypes.as_dtype(d) for d in output_dtypes] if self._return_as_is or op_type in _PASS_THROUGH_OPS: return self._wrap( super(ImperativeGraph, self).create_op(*args, **kwargs)) if not output_dtypes: return self._wrap( super(ImperativeGraph, self).create_op(*args, **kwargs)) output_has_ref = any([dtype._is_ref_dtype for dtype in output_dtypes]) # pylint: disable=protected-access if output_has_ref: if op_type not in _REF_OPS_WHITELIST: raise errors.UnimplementedError( None, None, op_type + ' op not supported in ' 'imperative graph') ret = super(ImperativeGraph, self).create_op(*args, **kwargs) if self._in_variable_creation: if op_type == 'Assign': self.add_pending_init(ret) return self._wrap(ret) with self.return_as_is(): # Declares the variables to hold the output values of this op. op_output_var = [ state_ops.variable_op_v2(tensor_shape.TensorShape(None), dtype, container=self._name) for dtype in output_dtypes ] # Ops to free the resources used by the temporary cache variables. # The following two ops are created for each cache variable, # having no control dependencies on any other ops : # var_handle_op ----> destroy_resource_op for dtype, v in zip(output_dtypes, op_output_var): with ops.control_dependencies(None): self._variable_cleanup_ops += [ gen_resource_variable_ops.destroy_resource_op( gen_resource_variable_ops.var_handle_op( dtype, tensor_shape.TensorShape(None), container=self._name, shared_name=v.op.name), ignore_lookup_error=True) ] # Create the conditional to run the original op only when the variable # corresponding to the first output is not initialized. inited = state_ops.is_variable_initialized(op_output_var[0]) v_f, v_t = control_flow_ops.ref_switch(op_output_var[0], inited) # pylint: disable=protected-access v_f_op = gen_array_ops._ref_identity(v_f) v_t_op = gen_array_ops._ref_identity(v_t) # pylint: enable=protected-access with ops.control_dependencies([v_f_op.op]): # Create the original op orig_op = self._wrap( super(ImperativeGraph, self).create_op(*args, **kwargs)) shapes = [val.get_shape() for val in orig_op.outputs] controls = [] for var, val in zip(op_output_var, orig_op.outputs): if (not val.get_shape().is_fully_defined() or val.get_shape().num_elements() > 0): assign_op = state_ops.assign(var, val, validate_shape=False) assign_op.set_shape(val.get_shape()) controls.append(assign_op) values = [] if len(controls) > 1: if control_flow_ops.IsSwitch(orig_op): # pylint: disable=protected-access controls = gen_control_flow_ops._ref_merge(controls) # pylint: enable=protected-access else: controls = control_flow_ops.tuple(controls) for var, val in zip(op_output_var, orig_op.outputs): with ops.control_dependencies(controls): with self.colocate_with(v_f_op): real_val = array_ops.identity(val) with ops.control_dependencies([v_t_op.op]): with self.colocate_with(v_t_op): stored_val = array_ops.identity(var) stored_val.set_shape(val.get_shape()) real_val, _ = control_flow_ops.merge( [real_val, stored_val]) real_val.op.node_def.attr['_gradient_op_type'].CopyFrom( attr_value_pb2.AttrValue( s=compat.as_bytes(self._merge_op_type))) values.append(real_val) for i, _ in enumerate(shapes): values[i].set_shape(shapes[i]) self._outputs_map[orig_op.name] = values try: self._gradient_function_map[ orig_op.name] = ops.get_gradient_function(orig_op) except (KeyError, LookupError): pass else: orig_op.node_def.attr['_gradient_op_type'].CopyFrom( attr_value_pb2.AttrValue( s=compat.as_bytes(self._imperative_op_type))) return MultiOutputOperation(values)
def handler(queue, kvm_fd, mm): global object_dict global object_id global callback_stack global initialized if not initialized: callback_stack = [] object_dict = dict() object_id = 1 # TODO: forward logging or disable it in test tf.logging.set_verbosity(tf.logging.INFO) initialized = True print("handler is initialized") while True: task = None task = queue.get(block=True) while task is None: try: task = queue.get(block=True, timeout=5) except Queue.Empty: task = None if callback_stack: if time.time() > callback_stack[-1]["deadline"]: print("callback failed deadline") return STATUS_CALLBACK_TIMEOUT vm_id = task.vm_id if vm_id == STOP_HANDLER: break param = TF_PY_PARAM.from_buffer(mm, task.data_ptr) callback_param = TF_PY_PARAM.from_buffer( mm, task.data_ptr + param.base.callback_param_offset) print( "retrieve [vm#%d] tensorflow task=%d cmd=%d, obj=%d, dstore=%lx, done=%d" % (task.vm_id, task.node_id, param.base.cmd_id, param.base.object_id, param.base.dstore_size, param.base.done)) print( "retrieve [vm#%d] callback node cmd=%d, obj=%d, dstore=%lx, done=%d" % (task.vm_id, callback_param.base.cmd_id, callback_param.base.object_id, callback_param.base.dstore_size, callback_param.base.done)) cmd_id = param.base.cmd_id try: if cmd_id == TF_PY_NW_CALLBACK_DONE: param.base.done = STATUS_TASK_DONE ret = fcntl.ioctl(kvm_fd, IOCTL_KVM_NOTIFY_TASK_FINISHED, task.node_id) if ret < 0: print("notify task completion failed: %d\n" % ret) if callback_stack and \ callback_stack[-1]["callback_id"] == param.base.object_id: print("callback is finished") return STATUS_CALLBACK_DONE else: print("callback is error") return STATUS_CALLBACK_ERROR if cmd_id == TF_PY_SESSION_INIT: print("SessionInit!!!") param1 = parse_param(vm_id, mm, param, param.param1) print(param1) sess = tf.Session(param1) # assign object_id object_dict[object_id] = sess param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_SESSION_ENTER: sess = object_dict[param.base.object_id] ctx_sess = sess.__enter__() if sess is ctx_sess: pass else: # unlikely print("unlikely to search for sess") param.base.object_id = next( obj_id for obj_id, obj in object_dict.items() if obj is ctx_sess) elif cmd_id == TF_PY_SESSION_EXIT: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) sess = object_dict[param.base.object_id] sess.__exit__(param1, param2, param3) elif cmd_id == TF_PY_SESSION_DEL: sess = object_dict[param.base.object_id] sess.__del__() # deprecated elif cmd_id == TF_PY_SESSION_RUN: sess = object_dict[param.base.object_id] param1 = parse_param(vm_id, mm, param, param.param1) if type(param1) == NwObject: print("get NwObject=%d" % param1.object_id()) param1 = object_dict[param1.object_id()] print(param1) ret_val = sess.run(param1) print(ret_val) writeback_result(vm_id, mm, param, param.ret_val1, ret_val) elif cmd_id == TF_PY_TPU_CLUSTER_RESOLVER_INIT: print("resloverInit!!!") param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) if param1 is None: param1 = None if param2 is None: param2 = None if param3 is None: param3 = None print("TPUClusterResolver", param1, param2, param3) tpu_grpc = tf.contrib.cluster_resolver.TPUClusterResolver( tpu=param1, zone=param2, project=param3) # assign object_id object_dict[object_id] = tpu_grpc param.base.object_id = object_id print("assign obj_id=%d" % object_id) object_id += 1 # deprecated elif cmd_id == TF_PY_TPU_CLUSTER_RESOLVER_MASTER: # FIXED: use __getattr__ print("master!!") tpu_grpc = object_dict[param.base.object_id] # FIXED: may have parameters tpu_grpc_url = tpu_grpc.master() # serialize return value writeback_result(vm_id, mm, param, param.ret_val1, tpu_grpc_url) elif cmd_id == TF_PY_TPU_INITIALIZE_SYSTEM: # TODO: may have parameters ts = tpu.initialize_system() object_dict[object_id] = ts param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_TPU_SHUTDOWN_SYSTEM: # TODO: may have parameters ts = tpu.shutdown_system() object_dict[object_id] = ts param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_GLOBAL_VARIABLES_INITIALIZER: # TODO: may have parameters ts = tf.global_variables_initializer() object_dict[object_id] = ts param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_ONES: print("param1 size=%ld,offset=%ld" % (param.param1.size, param.param1.offset)) param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) if param2 is None: param2 = dtypes.float32 print(param2) var = tf.ones(param1, param2) object_dict[object_id] = var param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_RANDOM_UNIFORM: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param5 = parse_param(vm_id, mm, param, param.param5) param6 = parse_param(vm_id, mm, param, param.param6) if param2 is None: param2 = 0 if param4 is None: param4 = dtypes.float32 print(param1, param2, param3, param4) var = tf.random_uniform(param1, param2, param3, param4, param5, param6) object_dict[object_id] = var param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_TRANSPOSE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param1 = object_dict[param1.object_id()] if param3 is None: param3 = "transpose" if param4 is None: param4 = False print("transpose", param1, param2, param3, param4) var = tf.transpose(param1, param2, param3, param4) object_dict[object_id] = var param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_CAST: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param1 = object_dict[param1.object_id()] print("cast", param1, param2, param3) var = tf.cast(param1, param2, param3) object_dict[object_id] = var param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_EXPAND_DIMS: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param1 = object_dict[param1.object_id()] print("expand_dims", param1, param2, param3, param4) var = tf.expand_dims(param1, param2, param3, param4) object_dict[object_id] = var param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_CONCAT: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param1 = object_dict[param1.object_id()] if param3 is None: param3 = "concat" print("concat", param1, param2, param3) var = tf.concat(param1, param2, param3) object_dict[object_id] = var param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_EQUAL: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param1 = object_dict[param1.object_id()] print("equal", param1, param2, param3) if isinstance(param2, NwObject): param2 = object_dict[param2.object_id()] result = tf.equal(param1, param2, param3) print(result) object_dict[object_id] = result param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_FIXED_LEN_FEATURE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) feature = tf.FixedLenFeature(param1, param2, param3) print(feature) object_dict[object_id] = feature param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_VAR_LEN_FEATURE: param1 = parse_param(vm_id, mm, param, param.param1) feature = tf.VarLenFeature(param1) print(feature) object_dict[object_id] = feature param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_PARSE_SINGLE_EXAMPLE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) print(param1, param2) # expand embedded NwObject if isinstance(param1, NwObject): param1 = object_dict[param1.object_id()] dict_walker(param2) print("after translation", param1, param2) result = tf.parse_single_example(param1, param2, param3, param4) print(result) dict_mapper(result) print(result) writeback_result(vm_id, mm, param, param.ret_val1, result) elif cmd_id == TF_PY_CONTROL_FLOW_OPS_SWITCH: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param1 = object_dict[param1.object_id()] param2 = object_dict[param2.object_id()] print("switch", param1, param2, param3, param4) result = control_flow_ops.switch(param1, param2, param3, param4) print(result) mapped_tuple = tuple_mapper(result, [0, 1]) print(mapped_tuple) writeback_result(vm_id, mm, param, param.ret_val1, mapped_tuple) elif cmd_id == TF_PY_CONTROL_FLOW_OPS_MERGE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param1 = object_dict[param1.object_id()] print("merge", param1, param2) list_walker(param1) print("merge-new", param1, param2) result = control_flow_ops.merge(param1, param2) print(result) mapped_tuple = tuple_mapper(result, [0]) print(mapped_tuple) writeback_result(vm_id, mm, param, param.ret_val1, mapped_tuple) elif cmd_id == TF_PY_TPU_REWRITE: # TODO: may have parameters param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) # default parameter if param2 is None: param2 = None # expand embedded NwObject list_walker(param2) func = tpu.rewrite(param1, param2) object_dict[object_id] = func param.base.object_id = object_id print("rewrite object_id=%d" % object_id) object_id += 1 elif cmd_id == TF_PY_TPU_RUN_CONFIG: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param5 = parse_param(vm_id, mm, param, param.param5) # default parameter if param1 is None: param1 = None if param2 is None: param2 = None if param3 is None: param3 = None if param4 is None: param4 = None # expand embedded NwObject param4 = object_dict[param4.object_id()] print(param4, param5) func = tpu.RunConfig(param1, param2, param3, param4, **param5) object_dict[object_id] = func param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_TPU_TPU_ESTIMATOR: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param5 = parse_param(vm_id, mm, param, param.param5) param6 = parse_param(vm_id, mm, param, param.param6) param7 = parse_param(vm_id, mm, param, param.param7) param8 = parse_param(vm_id, mm, param, param.param8) param9 = parse_param(vm_id, mm, param, param.param9) param10 = parse_param(vm_id, mm, param, param.param10) param11 = parse_param(vm_id, mm, param, param.param11) param12 = parse_param(vm_id, mm, param, param.param12) # default parameter if param1 is None: param1 = None if param2 is None: param2 = None if param3 is None: param3 = None if param4 is None: param4 = None if param5 is None: param5 = True if param6 is None: param6 = None if param7 is None: param7 = None if param8 is None: param8 = None if param9 is None: param9 = None if param10 is None: param10 = True if param11 is None: param11 = True if param12 is None: param12 = None # expand embedded NwObject param3 = object_dict[param3.object_id()] print(param3) func = tpu.TPUEstimator(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12) object_dict[object_id] = func param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_IMAGE_RESIZE_IMAGES: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param5 = parse_param(vm_id, mm, param, param.param5) # default parameter if param3 is None: param3 = ResizeMethod.BILINEAR if param4 is None: param4 = False if param5 is None: param5 = False # expand embedded NwObject param1 = object_dict[param1.object_id()] print(param1) img = tf.image.resize_images(param1, param2, param3, param4, param5) # TODO: it may return a float object_dict[object_id] = img param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_SLICE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) # expand embedded NwObject print(param1, param2, param3) param1 = object_dict[param1.object_id()] ret = tf.slice(param1, param2, param3, param4) object_dict[object_id] = ret param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_SHAPE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) if param3 is None: param3 = dtypes.int32 # expand embedded NwObject print(param1, param2, param3) param1 = object_dict[param1.object_id()] ret = tf.shape(param1, param2, param3) object_dict[object_id] = ret param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_IMAGE_SAMPLE_DISTORTED_BOUNDING_BOX: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param5 = parse_param(vm_id, mm, param, param.param5) param6 = parse_param(vm_id, mm, param, param.param6) param7 = parse_param(vm_id, mm, param, param.param7) param8 = parse_param(vm_id, mm, param, param.param8) param9 = parse_param(vm_id, mm, param, param.param9) param10 = parse_param(vm_id, mm, param, param.param10) # default parameter if param5 is None: param5 = 0.1 print("sample_distorted_bounding_box", param1, param2) result = tf.image.sample_distorted_bounding_box( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10) print(result) mapped_tuple = tuple_mapper(result, [0, 1, 2]) print(mapped_tuple) writeback_result(vm_id, mm, param, param.ret_val1, mapped_tuple) elif cmd_id == TF_PY_IMAGE_DRAW_BOUNDING_BOXES: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) # expand embedded NwObject print(param1, param2, param3) param1 = object_dict[param1.object_id()] param2 = object_dict[param2.object_id()] ret = tf.image.draw_bounding_boxes(param1, param2, param3) object_dict[object_id] = ret param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_IMAGE_DECODE_JPEG: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) param5 = parse_param(vm_id, mm, param, param.param5) param6 = parse_param(vm_id, mm, param, param.param6) param7 = parse_param(vm_id, mm, param, param.param7) param8 = parse_param(vm_id, mm, param, param.param8) if param2 is None: param2 = 0 if param3 is None: param3 = 1 if param4 is None: param4 = True if param5 is None: param5 = False if param6 is None: param6 = 1 if param7 is None: param7 = "" param1 = object_dict[param1.object_id()] img = tf.image.decode_jpeg(param1, param2, param3, param4, param5, param6, param7, param8) object_dict[object_id] = img param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_IMAGE_CONVERT_IMAGE_DTYPE: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) param4 = parse_param(vm_id, mm, param, param.param4) # expand embedded NwObject print(param1, param2, param3) param1 = object_dict[param1.object_id()] if param3 is None: param3 = False ret = tf.image.convert_image_dtype(param1, param2, param3, param4) object_dict[object_id] = ret param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_DATA_DATASET_LIST_FILES: param1 = parse_param(vm_id, mm, param, param.param1) param2 = parse_param(vm_id, mm, param, param.param2) param3 = parse_param(vm_id, mm, param, param.param3) print(param1, param2, param3) if isinstance(param1, NwObject): param1 = object_dict[oaram1.object_id()] ret = tf.data.Dataset.list_files(param1, param2, param3) object_dict[object_id] = ret param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_NW_OBJECT: print("nw_object!! id = %d" % param.base.object_id) obj = object_dict[param.base.object_id] name = parse_param(vm_id, mm, param, param.param1) args = parse_param(vm_id, mm, param, param.param2) kwargs = parse_param(vm_id, mm, param, param.param3) print("NwObject", obj, name, args, kwargs) # expand embedded NwObject args = list(args) list_walker(args) args = tuple(args) dict_walker(kwargs) print("after translation", obj, name, args, kwargs) # run result = getattr(obj, name)(*(args or []), **(kwargs or {})) param.base.object_id = -1 param.ret_val1.size = 0 print("analyze type", type(result), result) # TODO: go through tuple, dict or list if isinstance(result, tuple): result = tuple_mapper(result, range(len(result))) if isinstance(result, dict): dict_mapper(result) if isinstance(result, list): list_mapper(result) # serialize return value if is_unpickleable_type(result) or \ pickle.pickles(result) is False: object_dict[object_id] = result param.base.object_id = object_id object_id += 1 elif result is not None: writeback_result(vm_id, mm, param, param.ret_val1, result) elif cmd_id == TF_PY_NW_METHOD: # Reuse as callback #ins = parse_param(vm_id, mm, param, param.param1) #name = parse_param(vm_id, mm, param, param.param2) #print(ins, name) #method = getattr(ins, name) #print(method) #object_dict[object_id] = method cw = callback_constructor(object_id, callback_param, param, mm, vm_id, queue, kvm_fd) object_dict[object_id] = cw param.base.object_id = object_id object_id += 1 elif cmd_id == TF_PY_NW_CALLBACK_TEST: nw_func = parse_param(vm_id, mm, param, param.param1) print(nw_func, nw_func.object_id()) func = object_dict[nw_func.object_id()] print("callback func", func) x = parse_param(vm_id, mm, param, param.param2) y = parse_param(vm_id, mm, param, param.param3) result = func(x, y) print(result) writeback_result(vm_id, mm, param, param.ret_val1, result) else: print("unsupported Tensorflow API") except Exception, error: param.base.done = STATUS_TASK_ERROR #mm.flush(task.data_ptr, sizeof(PARAM_BASE)) print "fault: ", str(error) exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno) traceback.print_stack() print("finished [vm#%d] TF task %d cmd %d" % (task.vm_id, task.node_id, param.base.cmd_id)) param.base.done = STATUS_TASK_DONE #mm.flush(task.data_ptr, sizeof(PARAM_BASE)) #mm.flush(INVOKER_FIFO_SIZE + VGPU_DSTORE_SIZE * (vm_id - 1) + # param.base.dstore_offset + param.ret_val1.offset, # param.ret_val1.size) # notify hypervisor ret = fcntl.ioctl(kvm_fd, IOCTL_KVM_NOTIFY_TASK_FINISHED, task.node_id) if ret < 0: print("notify task completion failed: %d\n" % ret)
def main(argv): if len(argv) > 1: raise app.UsageError('Too many command-line arguments.') shutil.rmtree(FLAGS.saved_model_path) # The following test creates two signatures, each of which contains a # switch-merge construct that will be functionalized to the tf.If op. However, # `then` and `else` branches' arguments are deliberately made different # between these two model signatures, in order to trigger error in cases these # branches are functionalized to functions with the same function name. data_0 = array_ops.constant([1, 2, 3, 4, 5, 6]) data_1 = array_ops.constant([2, 3, 4, 5, 6, 7]) # Create placeholders to prevent constant folding. x_op = array_ops.placeholder(dtype=dtypes.int32) y_op = array_ops.placeholder(dtype=dtypes.int32) less_op = math_ops.less(x_op, y_op) switch_0_op = control_flow_ops.switch(data_0, less_op) switch_1_op = control_flow_ops.switch(data_1, less_op) # merge_0_op will be functionalized to a tf.If op with only one argument # `data_0` in addition to the condition `less_op`. merge_0_op = control_flow_ops.merge(switch_0_op)[0] # merge_1_op will be functionalized to a tf.If op with two arguments, `data_0` # and `data_1` in addition to the condition `less_op`. merge_1_op = control_flow_ops.merge([switch_0_op[0], switch_1_op[1]])[0] result = merge_0_op result_1 = merge_1_op sess = session.Session() sm_builder = builder.SavedModelBuilder(FLAGS.saved_model_path) tensor_info_x = utils.build_tensor_info(x_op) tensor_info_y = utils.build_tensor_info(y_op) tensor_info_result = utils.build_tensor_info(result) tensor_info_result_1 = utils.build_tensor_info(result_1) signature = ( signature_def_utils.build_signature_def( inputs={ 'x': tensor_info_x, 'y': tensor_info_y }, outputs={'result': tensor_info_result}, method_name=signature_constants.PREDICT_METHOD_NAME)) signature_1 = ( signature_def_utils.build_signature_def( inputs={ 'x': tensor_info_x, 'y': tensor_info_y }, outputs={'result_1': tensor_info_result_1}, method_name=signature_constants.PREDICT_METHOD_NAME)) sm_builder.add_meta_graph_and_variables( sess, [tag_constants.SERVING], signature_def_map={ 'sig': signature, 'sig_1': signature_1, }, strip_default_attrs=True) sm_builder.save()
def _build_net( self, state_inputs, batch_actions, scope, trainable, online_action_outputs=None, # None for target net. (更新 actor时,用到了,对 a 求导 ) cond_training_q=None # bool to control switch. can be None for target net. ): ''' :param state_inputs: :param batch_actions: 两个作用:(1) 训练Q,批量抽样 action 的 placeholder (2) target 网络, a' 的引用 :param scope: :param trainable: :param online_action_outputs: # None for target net. (更新 actor时,用到了,对 a (action 网络的输出) 求导 :param cond_training_q: :return: ''' with tf.variable_scope(scope): # input: 84 * 84 * 3 with tf.variable_scope("conv1"): # conv 1 filter1 = self._weight_variable([8, 8, self.s_images_dim, 16], trainable) b1 = self._bias_variable([16], trainable) conv1 = tf.nn.relu( self._conv2d(state_inputs, filter1, stride=[1, 4, 4, 1]) + b1) # conv1: 20 * 20 * 16 with tf.variable_scope("conv2"): # conv 2 filter2 = self._weight_variable([4, 4, 16, 32], trainable) b2 = self._bias_variable([32], trainable) conv2 = tf.nn.relu( self._conv2d(conv1, filter2, stride=[1, 2, 2, 1]) + b2) # max pooling max_pool2 = self._max_pooling(conv2) # conv2: 9 * 9 * 32 # max_pool2: 5 * 5 * 32 = 800 with tf.variable_scope("full_con"): flat = tf.reshape(max_pool2, [-1, 5 * 5 * 32]) full_cons_1 = [] for agent in range(self.agent_num): with tf.variable_scope("agent_{}".format(agent)): if cond_training_q is None: # target net actions = batch_actions else: # TODO: (后续可以调整)将输出图形dense后 与 每个agent对应输入对应拼接起来 # switch return :(output_false, output_true) (_, sw_action_training_q) = switch( data=batch_actions, pred=cond_training_q, name='switch_actions_training_q') (sw_action_training_policy, _) = switch(data=online_action_outputs, pred=cond_training_q, name='switch_actions_training_policy') (actions, _) = merge([ sw_action_training_q, sw_action_training_policy ]) agent_dense = tf.concat([flat, actions[agent]], axis=1) w_full = self._weight_variable( [5 * 5 * 32 + self.action_dim, 1024], trainable) b_full = self._bias_variable([1024], trainable) agent_full1 = tf.nn.relu( tf.matmul(agent_dense, w_full) + b_full) full_cons_1.append(agent_full1) # full_con: 1024 with tf.variable_scope("full_con2"): full_cons_2 = [] for agent in range(self.agent_num): with tf.variable_scope("agent_{}".format(agent)): # ouput: 3 w_full2 = self._weight_variable([1024, 128], trainable) b_full2 = self._bias_variable(128, trainable) agent_full2 = tf.nn.sigmoid( tf.matmul(full_cons_1[agent], w_full2) + b_full2) full_cons_2.append(agent_full2) # full_con2: 128 with tf.variable_scope("ouput"): ouputs = [] for agent in range(self.agent_num): with tf.variable_scope("agent_{}".format(agent)): # ouput: 3 w_outout = self._weight_variable([128, 1], trainable) b_output = self._bias_variable(1, trainable) out = tf.matmul(full_cons_2[agent], w_outout) + b_output ouputs.append(out) # ouput: 1 return ouputs