def testCombineSoftnessCannotExpandToSingularSoft(self):
left = SoftTensorTypeModel([5,10,1], soft_by_dimensions=[True, False, True])
right = SoftTensorTypeModel([5,10,3], soft_by_dimensions=[True, False, True])
helper = SoftTensorBinaryOperatorHelper()
with self.assertRaises(Exception) as context:
helper.get_combine_type_dimensions(left, right, "test_combine")
def testCombineDimMismatchInPartialGivesException(self):
left = SoftTensorTypeModel([5,10])
right = SoftTensorTypeModel([5,12,3])
helper = SoftTensorBinaryOperatorHelper()
with self.assertRaises(Exception) as context:
helper.get_combine_type_dimensions(left, right, "test_combine")
def testCombineSoftnessMismatchGivesException(self):
left = SoftTensorTypeModel([5,10,3])
right = SoftTensorTypeModel([5,10,3], soft_by_dimensions=[False, True, False])
helper = SoftTensorBinaryOperatorHelper()
with self.assertRaises(Exception) as context:
helper.get_combine_type_dimensions(left, right, "test_combine")
def build_value_type_model(self, input_types, value, mode):
left_type = input_types["left"]
right_type = input_types["right"]
helper = SoftTensorBinaryOperatorHelper()
output_type = helper.create_output_type(left_type, right_type, left_type.get_data_type(), value.get_name())
return {"output": output_type}
def testCombineScalarsProducesScalar(self):
left = SoftTensorTypeModel([])
right = SoftTensorTypeModel([])
helper = SoftTensorBinaryOperatorHelper()
combined_dims, _ = helper.get_combine_type_dimensions(left, right, "test_combine")
self.assertIsNotNone(combined_dims)
self.assertEqual(len(combined_dims), 0)
def execute(self, execution_component, input_dictionary, value, output_value_models, mode):
left = input_dictionary["left"]
right = input_dictionary["right"]
op = lambda x,y: x + y
helper = SoftTensorBinaryOperatorHelper()
helper.process(left, right, op, output_value_models["output"], language=value.language)
return output_value_models
def testCombineHardMultipleUnknownDims(self):
left = SoftTensorTypeModel([5,None,3])
right = SoftTensorTypeModel([None,10,None])
helper = SoftTensorBinaryOperatorHelper()
combined_dims, _ = helper.get_combine_type_dimensions(left, right, "test_combine")
self.assertIsNotNone(combined_dims)
self.assertEqual(len(combined_dims), 3)
self.assertEqual([5,10,3], combined_dims)
def testCombineHardExpandBoth(self):
left = SoftTensorTypeModel([5,1,3,1])
right = SoftTensorTypeModel([1,10,1,7])
helper = SoftTensorBinaryOperatorHelper()
combined_dims, _ = helper.get_combine_type_dimensions(left, right, "test_combine")
self.assertIsNotNone(combined_dims)
self.assertEqual(len(combined_dims), 4)
self.assertEqual([5,10,3,7], combined_dims)
def testCombineHardLongPartial(self):
left = SoftTensorTypeModel([5,10])
right = SoftTensorTypeModel([5,10,3,10,2,5])
helper = SoftTensorBinaryOperatorHelper()
combined_dims, _ = helper.get_combine_type_dimensions(left, right, "test_combine")
self.assertIsNotNone(combined_dims)
self.assertEqual(len(combined_dims), 6)
self.assertEqual([5,10,3,10,2,5], combined_dims)
def testCombineSoftLongPartial(self):
left = SoftTensorTypeModel([5,10], soft_by_dimensions=[True, False])
right = SoftTensorTypeModel([5,10,3,10,2,5], soft_by_dimensions=[True, False, True, False, False, True])
helper = SoftTensorBinaryOperatorHelper()
combined_dims, combined_softness = helper.get_combine_type_dimensions(left, right, "test_combine")
self.assertIsNotNone(combined_dims)
self.assertEqual(len(combined_dims), 6)
self.assertEqual([5,10,3,10,2,5], combined_dims)
self.assertEqual(len(combined_softness), 6)
self.assertEqual([True, False, True, False, False, True], combined_softness)
def testCombineSoftExpandsToMultipleHardSingulars(self):
left = SoftTensorTypeModel([1,10,1], soft_by_dimensions=[False, False, False])
right = SoftTensorTypeModel([5,10,3], soft_by_dimensions=[True, False, True])
helper = SoftTensorBinaryOperatorHelper()
combined_dims, combined_softness = helper.get_combine_type_dimensions(left, right, "test_combine")
self.assertIsNotNone(combined_dims)
self.assertEqual(len(combined_dims), 3)
self.assertEqual([5,10,3], combined_dims)
self.assertEqual(len(combined_softness), 3)
self.assertEqual([True, False, True], combined_softness)
def execute(self, execution_component, input_dictionary, value,
output_value_models, mode):
left = input_dictionary["left"]
right = input_dictionary["right"]
if value.operation == "minus":
op = tf.subtract
elif value.operation == "add":
op = tf.add
elif value.operation == "mul":
op = tf.multiply
elif value.operation == "div":
op = tf.div
helper = SoftTensorBinaryOperatorHelper()
helper.process(left,
right,
op,
output_value_models["output"],
language="tensorflow")
return output_value_models