def set_inputs(self, x, y): self.inputs = { 'X': convert_float_to_uint16(x), 'Y': convert_float_to_uint16(y) } self.x_fp32 = x self.y_fp32 = y
def init_test_data(self): self.x0 = convert_float_to_uint16( np.random.random(self.x0_shape).astype(np.float32)) self.x1 = convert_float_to_uint16( np.random.random(self.x1_shape).astype(np.float32)) self.x2 = convert_float_to_uint16( np.random.random(self.x2_shape).astype(np.float32))
def setUp(self): self.input_type = np.uint16 self.dtype = np.uint16 self.mkldnn_data_type = "bfloat16" self.init_op_type() self.init_test_case() input = np.random.random(self.input_size).astype(np.float32) filter = np.random.random(self.filter_size).astype(np.float32) self.attrs = { 'strides': self.stride, 'paddings': self.pad, 'padding_algorithm': self.padding_algorithm, 'groups': self.groups, 'dilations': self.dilations, 'is_test': self.is_test, 'use_mkldnn': self.use_mkldnn, 'mkldnn_data_type': self.mkldnn_data_type, 'force_fp32_output': self.force_fp32_output, 'data_format': self.data_format, 'fuse_activation': self.fuse_activation, 'fuse_alpha': self.fuse_alpha, 'fuse_beta': self.fuse_beta } if self.output_size is not None: self.attrs['output_size'] = self.output_size if len(self.output_padding) > 0: self.attrs['output_padding'] = self.output_padding output = conv2dtranspose_forward_naive(input, filter, self.attrs).astype(np.float32) if self.input_type is not np.float32: input = convert_float_to_uint16(input) self.inputs = { 'Input': input.view(self.input_type), 'Filter': OpTest.np_dtype_to_fluid_dtype(filter) } if self.fuse_bias and self.bias_size is not None: bias = np.random.random(self.bias_size).astype(np.float32) output = conv2d_bias_naive(output, bias) output = output.astype(np.float32) self.attrs['fuse_bias'] = self.fuse_bias self.inputs['Bias'] = OpTest.np_dtype_to_fluid_dtype(bias) if self.fuse_activation == "relu": output = np.maximum(output, 0).astype(np.float32) output = output.astype(np.float32) if not self.force_fp32_output: output = convert_float_to_uint16(output, self.attrs['data_format']) self.outputs['Output'] = output
def setUp(self): self.op_type = "gelu" self.dtype = np.uint16 x = np.random.uniform(-1, 1, [2, 4, 3, 5]).astype(np.float32) out = convert_float_to_uint16(gelu(x, True)) self.inputs = {'X': convert_float_to_uint16(x)} self.outputs = {'Out': out} self.attrs = {"use_mkldnn": True, "approximate": True}
def setUp(self): self.op_type = "scale" self.scale = -2.3 self.x_fp32 = np.random.random((10, 10)).astype(np.float32) self.x_bf16 = convert_float_to_uint16(self.x_fp32) self.scale_tensor = np.array([self.scale]).astype(np.float32) self.inputs = { 'X': self.x_bf16, 'ScaleTensor': convert_float_to_uint16(self.scale_tensor) } self.attrs = {'use_mkldnn': True} self.outputs = {'Out': self.x_fp32 * self.scale}
def setUp(self): self.op_type = "elementwise_sub" self.init_dtype() self.init_input_output() self.init_kernel_type() self.init_axis() self.x_bf16 = convert_float_to_uint16(self.x) self.y_bf16 = convert_float_to_uint16(self.y) self.inputs = {'X': self.x_bf16, 'Y': self.y_bf16} self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn} self.outputs = {'Out': convert_float_to_uint16(self.out)}
def setUp(self): self.op_type = "elementwise_mul" self.use_mkldnn = True self.mkldnn_data_type = "bfloat16" self.axis = -1 self.generate_data() self.x_bf16 = convert_float_to_uint16(self.x) self.y_bf16 = convert_float_to_uint16(self.y) self.inputs = {'X': self.x_bf16, 'Y': self.y_bf16} self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn} self.outputs = {'Out': convert_float_to_uint16(self.out)}
def setUp(self): self.op_type = "sum" self.init_kernel_type() x0 = np.random.random((3, 40)).astype(np.float32) x1 = np.random.random((3, 40)).astype(np.float32) x2 = np.random.random((3, 40)).astype(np.float32) y = x0 + x1 + x2 self.inputs = { "X": [("x0", convert_float_to_uint16(x0)), ("x1", convert_float_to_uint16(x1)), ("x2", convert_float_to_uint16(x2))] } self.outputs = {'Out': convert_float_to_uint16(y)}
def setUp(self): super(TestPoolBf16MklDNNOpGrad, self).setUp() self.attrs['mkldnn_data_type'] = "bfloat16" self.x_fp32 = np.random.random(self.shape).astype(np.float32) output = self.pool2D_forward_naive(self.x_fp32, self.ksize, self.strides, self.paddings, self.global_pool, self.ceil_mode, self.exclusive, self.adaptive, "float32").astype(np.float32) self.inputs = {'X': convert_float_to_uint16(self.x_fp32)} self.outputs = {'Out': convert_float_to_uint16(output)}
def setUp(self): TestPool2D_Op_Mixin.setUp(self) self.dtype = np.uint16 input = np.random.random(self.shape).astype(np.float32) output = (self.pool2D_forward_naive(input, self.ksize, self.strides, self.paddings, self.global_pool, self.ceil_mode, self.exclusive, self.adaptive, "float32")).astype(np.float32) self.inputs = {'X': convert_float_to_uint16(input)} self.outputs = {'Out': convert_float_to_uint16(output)}
def setUp(self): self.op_type = 'log_softmax' self.python_api = F.log_softmax self.dtype = np.uint16 self.shape = [2, 3, 4, 5] self.axis = -1 x = np.random.uniform(0.1, 1., self.shape).astype(np.float32) out = np.apply_along_axis(ref_log_softmax, self.axis, x) self.x_grad = ref_log_softmax_grad(x, self.axis) self.inputs = {'X': convert_float_to_uint16(x)} self.outputs = {'Out': convert_float_to_uint16(out)} self.attrs = {'axis': self.axis}
def setUp(self): self.op_type = "softmax" self.use_mkldnn = True self.dtype = np.uint16 self.init_kernel_type() self.shape = self.get_x_shape() self.axis = self.get_axis() x = np.random.uniform(0.1, 1, self.shape).astype(np.float) out = convert_float_to_uint16( np.apply_along_axis(stable_softmax, self.axis, x)) self.inputs = {'X': convert_float_to_uint16(x)} self.outputs = {'Out': out} self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn}
def create_dense_param_var(self, scope, place, height, width): param_tensor = scope.var('Param').get_tensor() param_array = np.random.random((height, width)).astype('float32') param_array_bf16 = convert_float_to_uint16(param_array) param_tensor.set(param_array_bf16, place) return param_tensor, param_array
def setUp(self): self.op_type = "scale" self.scale = 1.2 self.x_fp32 = np.random.random((9, 13)).astype(np.float32) self.x_bf16 = convert_float_to_uint16(self.x_fp32) self.scale_tensor = np.array([self.scale]).astype(np.float32) self.inputs = { 'X': self.x_bf16, 'ScaleTensor': convert_float_to_uint16(self.scale_tensor) } self.attrs = { 'bias': -1.1, 'bias_after_scale': False, 'use_mkldnn': True } self.outputs = {'Out': (self.x_fp32 + self.attrs['bias']) * self.scale}
def test_check_grad(self): self.calculate_grads() self.check_grad_with_place( core.CPUPlace(), ["X", "Y"], "Out", user_defined_grads=[self.dx, self.dy], user_defined_grad_outputs=[convert_float_to_uint16(self.dout)])
def setUp(self): self.op_type = "matmul" self.use_mkldnn = True self.dtype = np.uint16 self.mkldnn_data_type = "bfloat16" self.force_fp32_output = False self.generate_data() self.set_attributes() if not self.force_fp32_output: self.out = convert_float_to_uint16(self.out) self.outputs = {'Out': self.out} self.x = convert_float_to_uint16(self.x) self.y = convert_float_to_uint16(self.y) self.inputs = {'X': self.x, 'Y': self.y}
def create_dense_lr_var(self, scope, place): lr_tensor = scope.var('LearningRate').get_tensor() lr_value = np.random.uniform() lr_array = np.full((1), lr_value, np.float32) lr_array_bf16 = convert_float_to_uint16(lr_array) lr_tensor.set(lr_array_bf16, place) return lr_tensor, lr_value
def test_check_grad(self): self.calculate_grads() self.check_grad_with_place( core.CPUPlace(), ["X"], "Out", check_dygraph=False, user_defined_grads=[self.dx], user_defined_grad_outputs=[convert_float_to_uint16(self.out)])
def test_check_grad_ingore_y(self): self.calculate_grads() self.check_grad_with_place( core.CPUPlace(), ['X'], 'Out', set('Y'), user_defined_grads=[self.dx], user_defined_grad_outputs=[convert_float_to_uint16(self.dout)])
def setUp(self): self.init_test() self.ids = np.random.randint(low=0, high=15, size=self.ids_shape).astype("int64") self.flat_ids = self.ids.flatten() self.w_fp32 = np.random.random((15, 32)).astype("float32") self.w_bf16 = convert_float_to_uint16(self.w_fp32) self.scope = core.Scope() self.place = core.CPUPlace()
def setUp(self): self.dtype = np.uint16 self.init_data() self.config() self.out = self.op_forward(self.x) self.inputs = {'X': convert_float_to_uint16(self.x)} self.outputs = {'Out': self.out} self.set_attrs()
def setUp(self): self.op_type = "elementwise_mul" self.dtype = np.uint16 self.x = np.random.uniform(0.1, 1, [13, 17]).astype(np.float32) self.y = np.random.uniform(0.1, 1, [13, 17]).astype(np.float32) self.out = np.multiply(self.x, self.y) self.axis = -1 self.inputs = { 'X': OpTest.np_dtype_to_fluid_dtype(convert_float_to_uint16(self.x)), 'Y': OpTest.np_dtype_to_fluid_dtype(convert_float_to_uint16(self.y)) } self.outputs = {'Out': convert_float_to_uint16(self.out)} self.attrs = {'axis': self.axis, 'use_mkldnn': False}
def setUp(self): self.op_type = 'sgd' self.dtype = np.uint16 self.use_mkldnn = True self.conf() w = np.random.random((self.h, self.w)).astype('float32') w_bf16 = convert_float_to_uint16(w) g = np.random.random((self.h, self.w)).astype('float32') g_bf16 = convert_float_to_uint16(g) lr = np.array([0.1]).astype('float32') lr_bf16 = convert_float_to_uint16(lr) self.inputs = { 'Param': w_bf16, 'Grad': g_bf16, 'LearningRate': lr_bf16 } self.outputs = {'ParamOut': w - lr * g} self.attrs = {'use_mkldnn': self.use_mkldnn}
def setUp(self): self.op_type = "scale" self.x_fp32 = np.random.random((10, 10)).astype(np.float32) self.x_bf16 = convert_float_to_uint16(self.x_fp32) self.scale = -2.3 self.inputs = {'X': self.x_bf16} self.attrs = {'scale': self.scale, 'use_mkldnn': True, 'bias': 0.4} self.use_mkldnn = True self.outputs = { 'Out': (self.x_fp32 * self.attrs['scale']) + self.attrs['bias'] }
def create_sparse_grad_var(self, scope, place, height, rows, row_numel): grad_selected_rows = scope.var('Grad').get_selected_rows() grad_selected_rows.set_height(height) grad_selected_rows.set_rows(rows) grad_array = np.random.random((len(rows), row_numel)).astype('float32') np_array_bf16 = convert_float_to_uint16(grad_array) grad_tensor = grad_selected_rows.get_tensor() grad_tensor.set(np_array_bf16, place) return grad_tensor, grad_array
def test_check_grad(self): dout = self.conv_output_float x = self.inputs_fp32['Input'] w = self.inputs_fp32['Filter'] dx, dweights = conv_backward(dout, x, w, self.conv2d_param) self.check_grad_with_place( core.CPUPlace(), ["Input", "Filter"], "Output", user_defined_grads=[dx, dweights], user_defined_grad_outputs=[convert_float_to_uint16(dout)])
def create_sparse_param_var(self, scope, place, height, rows, row_numel): param_selected_rows = scope.var('Param').get_selected_rows() param_selected_rows.set_height(height) param_selected_rows.set_rows(rows) param_selected_rows.sync_index() param_array = np.random.random( (len(rows), row_numel)).astype('float32') np_array_bf16 = convert_float_to_uint16(param_array) param_tensor = param_selected_rows.get_tensor() param_tensor.set(np_array_bf16, place) return param_tensor, param_array
def setUp(self): self.op_type = "sum" self.use_mkldnn = True self.mkldnn_data_type = "bfloat16" # float32 input to be use for reference x0 = np.random.random((25, 8)).astype('float32') x1 = np.random.random((25, 8)).astype('float32') x2 = np.random.random((25, 8)).astype('float32') # actual input (bf16) to bf16 sum op x0_bf16 = convert_float_to_uint16(x0) x1_bf16 = convert_float_to_uint16(x1) x2_bf16 = convert_float_to_uint16(x2) self.inputs = { "X": [("x0", x0_bf16), ("x1", x1_bf16), ("x2", x2_bf16)] } y = x0 + x1 + x2 self.outputs = {'Out': convert_float_to_uint16(y)} self.attrs = {'use_mkldnn': self.use_mkldnn}
def setUp(self): self.op_type = "fc" self.use_mkldnn = True self.mkldnn_data_type = "bfloat16" self.force_fp32_output = False self.generate_data() self.output = fully_connected_naive(self.matrix.input, self.matrix.weights, self.bias) if not self.force_fp32_output: self.output = convert_float_to_uint16(self.output) self.inputs = { 'Input': convert_float_to_uint16(self.matrix.input), 'W': self.matrix.weights, 'Bias': self.bias } self.attrs = { 'use_mkldnn': self.use_mkldnn, 'force_fp32_output': self.force_fp32_output } self.outputs = {'Out': self.output}
def setUp(self): self.init_test() self.dtype = np.uint16 table = np.random.random((17, 31)).astype("float32") self.ids = np.random.randint(0, 17, self.ids_shape).astype("int64") self.flat_ids = self.ids.flatten() self.w_bf16 = convert_float_to_uint16(table) self.out_bf16 = _lookup(self.w_bf16, self.ids, self.flat_ids, self.op_type) self.out_fp32 = _lookup(table, self.ids, self.flat_ids, self.op_type) self.w_grad_fp32 = _get_grad(table, self.ids, self.flat_ids, self.op_type) self.inputs = {'W': self.w_bf16, 'Ids': self.ids} self.outputs = {'Out': self.out_fp32}