def test_create_table_with_array_2(self):
feature_count = 10
expect_data = np.random.rand(feature_count)
actual_data = np.zeros((feature_count, 1))
dtable = create_table(expect_data)
for item in dtable.collect():
actual_data[item[0]] = item[1]
assert dtable.count() == feature_count
assert_matrix(np.expand_dims(expect_data, axis=1), actual_data)
def test_create_table_with_array_1(self):
row_count = 10
expect_data = np.random.rand(row_count, 10)
actual_data = np.zeros((row_count, 10))
dtable = create_table(expect_data)
for item in dtable.collect():
actual_data[item[0]] = item[1]
assert dtable.count() == row_count
assert_matrix(expect_data, actual_data)
def predict(self, host_data, predict_param):
LOGGER.info("@ start host predict")
features, labels, instances_indexes = convert_instance_table_to_array(
host_data)
host_x = np.squeeze(features)
LOGGER.debug("host_x： " + str(host_x.shape))
host_prob = self.host_model.predict(host_x)
self._do_remote(host_prob,
name=self.transfer_variable.host_prob.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.host_prob),
role=consts.GUEST,
idx=-1)
pred_prob = self._do_get(
name=self.transfer_variable.pred_prob.name,
tag=self.transfer_variable.generate_transferid(
self.transfer_variable.pred_prob),
idx=-1)[0]
pred_prob = np.squeeze(pred_prob)
LOGGER.debug("pred_prob: " + str(pred_prob.shape))
pred_prob_table = create_table(pred_prob, instances_indexes)
actual_label_table = create_table(labels, instances_indexes)
pred_label_table = self.classified(pred_prob_table,
predict_param.threshold)
if predict_param.with_proba:
predict_result = actual_label_table.join(
pred_prob_table, lambda label, prob:
(label if label > 0 else 0, prob))
predict_result = predict_result.join(pred_label_table, lambda x, y:
(x[0], x[1], y))
else:
predict_result = actual_label_table.join(
pred_label_table, lambda a_label, p_label:
(a_label, None, p_label))
return predict_result
def test_create_table_with_dict(self):
row_count = 10
expect_data = np.random.rand(row_count, 10)
indexes = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
actual_data = {}
dtable = create_table(expect_data, indexes)
for item in dtable.collect():
actual_data[item[0]] = item[1]
assert dtable.count() == len(indexes)
for i, index in enumerate(indexes):
assert_array(actual_data[indexes[i]], expect_data[i])
def test_destroy_table(self):
row_count = 10
expect_data = np.random.rand(row_count, 10)
table_name = "table_name"
table_ns = "table_ns"
dtable = create_table(expect_data, model_table_name=table_name, model_namespace=table_ns, persistent=True)
dtable_2 = table(name=table_name, namespace=table_ns)
assert dtable.count() == dtable_2.count()
dtable_2.destroy()
dtable_3 = table(name=table_name, namespace=table_ns)
assert dtable_3.count() == 0
def test_hetero_plain_guest_prepare_table(self):
U_A = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11],
[4, 5, 6, 7, 8]])
y = np.array([[1], [-1], [1], [-1]])
Wh = np.ones((5, U_A.shape[1]))
bh = np.zeros(U_A.shape[1])
model_param = FTLModelParam(alpha=1, max_iteration=1)
autoencoderA = MockAutoencoder(0)
autoencoderA.build(U_A.shape[1], Wh, bh)
guest = PlainFTLGuestModel(autoencoderA, model_param)
converge_func = MockDiffConverge(None)
ftl_guest = TestHeteroFTLGuest(guest, model_param,
HeteroFTLTransferVariable())
ftl_guest.set_converge_function(converge_func)
guest_sample_indexes = np.array([0, 1, 2, 3])
guest_x_dict = {}
guest_label_dict = {}
instance_dict = {}
instance_list = []
np.random.seed(100)
for i, feature, label, in zip(guest_sample_indexes, U_A, y):
instance = Instance(inst_id=i, features=feature, label=label[0])
guest_x_dict[i] = feature
guest_label_dict[i] = label[0]
instance_dict[i] = instance
instance_list.append(instance)
guest_x = create_table(instance_list, indexes=guest_sample_indexes)
guest_x, overlap_indexes, non_overlap_indexes, guest_y = ftl_guest.prepare_data(
guest_x)
print("guest_x", guest_x)
print("overlap_indexes", overlap_indexes)
print("non_overlap_indexes", non_overlap_indexes)
print("guest_y", guest_y)