def call(self, inputs): if self.data_format != 'channels_first': inputs = tfe.transpose(inputs, perm=[0, 3, 1, 2]) outputs = self._pool_function(inputs, self.pool_size, self.strides, self.padding) if self.data_format != 'channels_first': outputs = tfe.transpose(outputs, perm=[0, 2, 3, 1]) return outputs
def forward(self, x: TFEVariable) -> TFEVariable: if not self.channels_first: x = tfe.transpose(x, perm=[0, 3, 1, 2]) self.cached_input_shape = x.shape self.cache = x out = self.pool(x, self.pool_size, self.strides, self.padding) if not self.channels_first: out = tfe.transpose(out, perm=[0, 2, 3, 1]) return out
def test_transpose(self): tf.reset_default_graph() prot = ABY3() tfe.set_protocol(prot) x = tfe.define_private_variable(tf.constant([[1, 2, 3], [4, 5, 6]])) y = tfe.define_constant(np.array([[1, 2, 3], [4, 5, 6]])) z1 = x.transpose() z2 = tfe.transpose(y) with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) # reveal result result = sess.run(z1.reveal()) np.testing.assert_allclose( result, np.array([[1, 4], [2, 5], [3, 6]]), rtol=0.0, atol=0.01 ) result = sess.run(z2) np.testing.assert_allclose( result, np.array([[1, 4], [2, 5], [3, 6]]), rtol=0.0, atol=0.01 )
def forward(self, x): """Compute the forward convolution.""" self.cached_input_shape = x.shape self.cache = x if not self.channels_first: x = tfe.transpose(x, perm=[0, 3, 1, 2]) out = tfe.conv2d(x, self.weights, self.strides, self.padding) if self.bias is not None: out = out + self.bias if not self.channels_first: out = tfe.transpose(out, perm=[0, 2, 3, 1]) return out
def call(self, inputs): if self.data_format != 'channels_first': inputs = tfe.transpose(inputs, perm=[0, 3, 1, 2]) outputs = tfe.conv2d(inputs, self.kernel, self.strides[0], self.padding) if self.use_bias: outputs = outputs + self.bias if self.data_format != 'channels_first': outputs = tfe.transpose(outputs, perm=[0, 2, 3, 1]) if self.activation is not None: return self.activation(outputs) return outputs
def backward(self, x, dy, learning_rate=0.01): batch_size = x.shape.as_list()[0] with tf.name_scope("backward"): dw = tfe.matmul(tfe.transpose(x), dy) / batch_size db = tfe.reduce_sum(dy, axis=0) / batch_size assign_ops = [ tfe.assign(self.w, self.w - dw * learning_rate), tfe.assign(self.b, self.b - db * learning_rate), ] return assign_ops
def rearrange_kernel(self, kernel): """ Rearrange kernel to match normal convoluion kernels Arguments: kernel: kernel to be rearranged """ mask = self.get_mask(self.input_dim) if isinstance(kernel, tf.Tensor): mask = tf.constant(mask.tolist(), dtype=tf.float32, shape=(self.kernel_size[0], self.kernel_size[1], self.input_dim * self.depth_multiplier, self.input_dim)) if self.depth_multiplier > 1: # rearrange kernel kernel = tf.transpose(kernel, [0, 1, 3, 2]) kernel = tf.reshape( kernel, shape=self.kernel_size + (self.input_dim * self.depth_multiplier, 1)) kernel = tf.multiply(kernel, mask) elif isinstance(kernel, np.ndarray): if self.depth_multiplier > 1: # rearrange kernel kernel = np.transpose(kernel, [0, 1, 3, 2]) kernel = np.reshape( kernel, newshape=self.kernel_size + (self.input_dim * self.depth_multiplier, 1)) kernel = np.multiply(kernel, mask) elif isinstance(kernel, PondPrivateTensor): mask = tfe.define_public_variable(mask) if self.depth_multiplier > 1: # rearrange kernel kernel = tfe.transpose(kernel, [0, 1, 3, 2]) kernel = tfe.reshape( kernel, shape=self.kernel_size + (self.input_dim * self.depth_multiplier, 1)) kernel = tfe.mul(kernel, mask) return kernel
def test_simple_lr_model(): tf.reset_default_graph() import time start = time.time() prot = ABY3() tfe.set_protocol(prot) # define inputs x_raw = tf.random.uniform(minval=-0.5, maxval=0.5, shape=[99, 10], seed=1000) x = tfe.define_private_variable(x_raw, name="x") y_raw = tf.cast(tf.reduce_mean(x_raw, axis=1, keepdims=True) > 0, dtype=tf.float32) y = tfe.define_private_variable(y_raw, name="y") w = tfe.define_private_variable(tf.random_uniform([10, 1], -0.01, 0.01, seed=100), name="w") b = tfe.define_private_variable(tf.zeros([1]), name="b") learning_rate = 0.01 with tf.name_scope("forward"): out = tfe.matmul(x, w) + b y_hat = tfe.sigmoid(out) with tf.name_scope("loss-grad"): dy = y_hat - y batch_size = x.shape.as_list()[0] with tf.name_scope("backward"): dw = tfe.matmul(tfe.transpose(x), dy) / batch_size db = tfe.reduce_sum(dy, axis=0) / batch_size upd1 = dw * learning_rate upd2 = db * learning_rate assign_ops = [tfe.assign(w, w - upd1), tfe.assign(b, b - upd2)] with tfe.Session() as sess: # initialize variables sess.run(tfe.global_variables_initializer()) for i in range(1): sess.run(assign_ops) print(sess.run(w.reveal())) end = time.time() print("Elapsed time: {} seconds".format(end - start))
def _transpose(converter, node: Any, inputs: List[str]) -> Any: x_in = converter.outputs[inputs[0]] perm = converter.outputs[inputs[1]] tensor = perm.attr["value"].tensor shape = [i.size for i in tensor.tensor_shape.dim] dtype = perm.attr["dtype"].type if dtype == tf.int32: nums = array.array('i', tensor.tensor_content) elif dtype == tf.int64: nums = array.array('l', tensor.tensor_content) else: raise TypeError("Unsupported dtype for transpose perm") return tfe.transpose(x_in, np.array(nums).reshape(shape))
def call(self, inputs): input_shape = inputs.shape.as_list() rank = len(input_shape) if self.data_format == "channels_first" and rank > 1: permutation = [0] permutation.extend(i for i in range(2, rank)) permutation.append(1) inputs = tfe.transpose(inputs, perm=permutation) if rank == 1: flatten_shape = [input_shape[0], 1] else: flatten_shape = [input_shape[0], -1] outputs = tfe.reshape(inputs, flatten_shape) return outputs
xp, yp = tfe.define_private_input('input-provider', lambda: gen_training_input(training_set_size, nb_feats, batch_size)) xp_test, yp_test = tfe.define_private_input('input-provider', lambda: gen_test_input(training_set_size, nb_feats, batch_size)) W = tfe.define_private_variable(tf.random_uniform([nb_feats, 1], -0.01, 0.01)) b = tfe.define_private_variable(tf.zeros([1])) # Training model out = tfe.matmul(xp, W) + b pred = tfe.sigmoid(out) # Due to missing log function approximation, we need to compute the cost in numpy # cost = -tfe.sum(y * tfe.log(pred) + (1 - y) * tfe.log(1 - pred)) * (1/train_batch_size) # Backprop dc_dout = pred - yp dW = tfe.matmul(tfe.transpose(xp), dc_dout) * (1 / batch_size) db = tfe.reduce_sum(1. * dc_dout, axis=0) * (1 / batch_size) ops = [ tfe.assign(W, W - dW * learning_rate), tfe.assign(b, b - db * learning_rate) ] # Testing model pred_test = tfe.sigmoid(tfe.matmul(xp_test, W) + b) def print_accuracy(pred_test_tf, y_test_tf: tf.Tensor) -> tf.Operation: correct_prediction = tf.equal(tf.round(pred_test_tf), y_test_tf) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) return tf.print("Accuracy", accuracy)