def _flatten(converter, node, inputs):
x_in = converter.outputs[inputs[0]]
shape = x_in.shape.as_list()
non_batch = 1
for dim in shape[1:]:
non_batch *= dim
return tfe.reshape(x_in, [-1, non_batch])
def main(server):
num_rows = 7000
num_features = 32
num_epoch = 5
batch_size = 200
num_batches = (num_rows // batch_size) * num_epoch
#who shall receive the output
model_owner = ModelOwner('alice')
data_schema0 = DataSchema([tf.float64] * 16, [0.0] * 16)
data_schema1 = DataSchema([tf.int64] + [tf.float64] * 16, [0] + [0.0] * 16)
data_owner_0 = DataOwner('alice',
'aliceTrainFile.csv',
data_schema0,
batch_size=batch_size)
data_owner_1 = DataOwner('bob',
'bobTrainFileWithLabel.csv',
data_schema1,
batch_size=batch_size)
tfe.set_protocol(
tfe.protocol.Pond(
tfe.get_config().get_player(data_owner_0.player_name),
tfe.get_config().get_player(data_owner_1.player_name)))
x_train_0 = tfe.define_private_input(data_owner_0.player_name,
data_owner_0.provide_data)
x_train_1 = tfe.define_private_input(data_owner_1.player_name,
data_owner_1.provide_data)
y_train = tfe.gather(x_train_1, 0, axis=1)
y_train = tfe.reshape(y_train, [batch_size, 1])
#Remove bob's first column (which is label)
x_train_1 = tfe.strided_slice(x_train_1, [0, 1],
[x_train_1.shape[0], x_train_1.shape[1]],
[1, 1])
x_train = tfe.concat([x_train_0, x_train_1], axis=1)
model = LogisticRegression(num_features)
reveal_weights_op = model_owner.receive_weights(model.weights)
with tfe.Session() as sess:
sess.run(tfe.global_variables_initializer(), tag='init')
start_time = time.time()
model.fit(sess, x_train, y_train, num_batches)
end_time = time.time()
# TODO(Morten)
# each evaluation results in nodes for a forward pass being added to the graph;
# maybe there's some way to avoid this, even if it means only if the shapes match
model.evaluate(sess, x_train, y_train, data_owner_0)
model.evaluate(sess, x_train, y_train, data_owner_1)
print(sess.run(reveal_weights_op, tag='reveal'),
((end_time - start_time) * 1000))
def _reshape(converter, node: Any, inputs: List[str]) -> Any:
x_in = converter.outputs[inputs[0]]
shape = converter.outputs[inputs[1]]
tensor = shape.attr["value"].tensor
dtype = shape.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 reshape shape")
return tfe.reshape(x_in, list(nums))
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 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
# get model parameters as private tensors from model owner
params = tfe.define_private_input('model-trainer', model_trainer.provide_input, masked=True) # pylint: disable=E0632
# we'll use the same parameters for each prediction so we cache them to avoid re-training each time
params = tfe.cache(params)
# get prediction input from client
x, y = tfe.define_private_input('prediction-client', prediction_client.provide_input, masked=True) # pylint: disable=E0632
# helpers
conv = lambda x, w, s: tfe.conv2d(x, w, s, 'VALID')
pool = lambda x: tfe.avgpool2d(x, (2, 2), (2, 2), 'VALID')
# compute prediction
Wconv1, bconv1, Wfc1, bfc1, Wfc2, bfc2 = params
bconv1 = tfe.reshape(bconv1, [-1, 1, 1])
layer1 = pool(tfe.relu(conv(x, Wconv1, ModelTrainer.STRIDE) + bconv1))
layer1 = tfe.reshape(layer1, [-1, ModelTrainer.HIDDEN_FC1])
layer2 = tfe.matmul(layer1, Wfc1) + bfc1
logits = tfe.matmul(layer2, Wfc2) + bfc2
# send prediction output back to client
prediction_op = tfe.define_output('prediction-client', [logits, y], prediction_client.receive_output)
with tfe.Session() as sess:
print("Init")
sess.run(tf.global_variables_initializer(), tag='init')
print("Training")
sess.run(tfe.global_caches_updater(), tag='training')
conv2_tfe.initialize(initial_weights=wconv2)
avg_pool1 = tfe.layers.AveragePooling2D(input_shape=[-1, 24, 24, 20],
pool_size=(2, 2),
strides=(2, 2),
padding='VALID',
channels_first=False)
avg_pool2 = tfe.layers.AveragePooling2D(input_shape=[-1, 8, 8, 50],
pool_size=(2, 2),
strides=(2, 2),
padding='VALID',
channels_first=False)
x = tfe.reshape(x, [-1, 28, 28, 1])
layer1 = avg_pool1.forward(tfe.relu(conv1_tfe.forward(x) + bconv1))
layer2 = avg_pool2.forward(tfe.relu(conv2_tfe.forward(layer1) + bconv2))
layer2 = tfe.reshape(layer2, [-1, ModelTrainer.HIDDEN_FC1])
layer3 = tfe.relu(tfe.matmul(layer2, wfc1) + bfc1)
logits = tfe.matmul(layer3, wfc2) + bfc2
# send prediction output back to client
prediction_op = tfe.define_output('prediction-client', [logits, y],
prediction_client.receive_output)
with tfe.Session() as sess:
print("Init")
sess.run(tf.global_variables_initializer(), tag='init')
print("Training")
def forward(self, x):
y = tfe.reshape(x, self.output_shape)
self.layer_output = y
return y
data_owner_1 = DataOwner('bob',
f'{name}/tfe_label_train.csv',
data_schema1,
batch_size=batch_size)
tfe.set_protocol(
tfe.protocol.Pond(
tfe.get_config().get_player(data_owner_0.player_name),
tfe.get_config().get_player(data_owner_1.player_name)))
x_train_0 = tfe.define_private_input(data_owner_0.player_name,
data_owner_0.provide_data)
x_train_1 = tfe.define_private_input(data_owner_1.player_name,
data_owner_1.provide_data)
y_train = tfe.gather(x_train_1, 0, axis=1)
y_train = tfe.reshape(y_train, [batch_size, 1])
# Remove bob's first column (which is label)
x_train_1 = tfe.strided_slice(x_train_1, [0, 1],
[x_train_1.shape[0], x_train_1.shape[1]],
[1, 1])
x_train = tfe.concat([x_train_0, x_train_1], axis=1)
model = LinearRegression(num_features)
# model = LogisticRegression(num_features)
fit_forward_op = model.fit_forward(x_train,
y_train,
learning_rate=case['l'])
reveal_weights_op = model_owner.receive_weights(model.weights)
# prepare test data
