def setUp(self):
self.paillier_encrypt = PaillierEncrypt()
self.paillier_encrypt.generate_key()
self.gradient_operator = LogisticGradient()
self.taylor_operator = TaylorLogisticGradient()
self.X = np.array([[1, 2, 3, 4, 5], [3, 2, 4, 5, 1], [
2,
2,
3,
1,
1,
]]) / 10
self.X1 = np.c_[self.X, np.ones(3)]
self.Y = np.array([[1], [1], [-1]])
self.values = []
for idx, x in enumerate(self.X):
inst = Instance(inst_id=idx, features=x, label=self.Y[idx])
self.values.append((idx, inst))
self.values1 = []
for idx, x in enumerate(self.X1):
inst = Instance(inst_id=idx, features=x, label=self.Y[idx])
self.values1.append((idx, inst))
self.coef = np.array([2, 2.3, 3, 4, 2.1]) / 10
self.coef1 = np.append(self.coef, [1])
def setUp(self):
eggroll.init("test_instance")
dense_inst = []
for i in range(100):
inst = Instance(features=(i % 16 * np.ones(20)))
dense_inst.append((i, inst))
self.dense_table = eggroll.parallelize(dense_inst,
include_key=True,
partition=2)
sparse_inst = []
col_zero = []
for i in range(100):
indices = []
data = []
for j in range(20):
val = ((i + 5)**3 + (j + 1)**4) % 16
if val > 0:
indices.append(j)
data.append(val)
if j == 0:
col_zero.append(val)
sparse_vec = SparseVector(indices, data, 20)
inst = Instance(features=sparse_vec)
sparse_inst.append((i, inst))
self.sparse_inst = sparse_inst
self.sparse_table = eggroll.parallelize(sparse_inst,
include_key=True,
partition=1)
def setUp(self):
self.feature_histogram = FeatureHistogram()
eggroll.init("test_feature_histogram")
data_insts = []
for i in range(1000):
indices = []
data = []
for j in range(10):
x = random.randint(0, 5)
if x != 0:
data.append(x)
indices.append(j)
sparse_vec = SparseVector(indices, data, shape=10)
data_insts.append((Instance(features=sparse_vec), (1, random.randint(0, 3))))
self.node_map = {0: 0, 1: 1, 2: 2, 3: 3}
self.data_insts = data_insts
self.data_bin = eggroll.parallelize(data_insts, include_key=False)
self.grad_and_hess_list = [(random.random(), random.random()) for i in range(1000)]
self.grad_and_hess = eggroll.parallelize(self.grad_and_hess_list, include_key=False)
bin_split_points = []
for i in range(10):
bin_split_points.append(np.array([i for i in range(5)]))
self.bin_split_points = np.array(bin_split_points)
self.bin_sparse = [0 for i in range(10)]
def setUp(self):
self.guest_X = np.array([[1, 2, 3, 4, 5], [3, 2, 4, 5, 1],
[
2,
2,
3,
1,
1,
]]) / 10
self.guest_Y = np.array([[1], [1], [-1]])
self.values = []
for idx, x in enumerate(self.guest_X):
inst = Instance(inst_id=idx, features=x, label=self.guest_Y[idx])
self.values.append((idx, inst))
self.host_X = np.array([[1, 1.2, 3.1, 4, 5], [2.3, 2, 4, 5.3, 1],
[
2,
2.2,
1.3,
1,
1.6,
]]) / 10
self.host_Y = np.array([[-1], [1], [-1]])
self.host_values = []
for idx, x in enumerate(self.host_X):
inst = Instance(inst_id=idx, features=x, label=self.host_Y[idx])
self.values.append((idx, inst))
self.max_iter = 10
self.alpha = 0.01
self.learning_rate = 0.01
optimizer = 'SGD'
self.gradient_operator = LogisticGradient()
self.initializer = Initializer()
self.fit_intercept = True
self.init_param_obj = InitParam(fit_intercept=self.fit_intercept)
self.updater = L2Updater(self.alpha, self.learning_rate)
self.optimizer = Optimizer(learning_rate=self.learning_rate,
opt_method_name=optimizer)
self.__init_model()
def __prepare_data(self, data_num=1000, feature_num=100):
final_result = []
for i in range(data_num):
tmp = i * np.ones(feature_num)
inst = Instance(inst_id=i, features=tmp, label=0)
tmp = (i, inst)
final_result.append(tmp)
table = eggroll.parallelize(final_result,
include_key=True,
partition=3)
return table
def setUp(self):
eggroll.init("123")
self.data_num = 1000
self.feature_num = 200
final_result = []
for i in range(self.data_num):
tmp = i * np.ones(self.feature_num)
inst = Instance(inst_id=i, features=tmp, label=0)
tmp = (str(i), inst)
final_result.append(tmp)
table = eggroll.parallelize(final_result,
include_key=True,
partition=3)
self.table = table
def setUp(self):
self.paillier_encrypt = PaillierEncrypt()
self.paillier_encrypt.generate_key()
self.hetero_lr_gradient = HeteroLogisticGradient(self.paillier_encrypt)
size = 10
self.wx = eggroll.parallelize([self.paillier_encrypt.encrypt(i) for i in range(size)])
self.en_sum_wx_square = eggroll.parallelize([self.paillier_encrypt.encrypt(np.square(i)) for i in range(size)])
self.w = [i for i in range(size)]
self.data_inst = eggroll.parallelize(
[Instance(features=[1 for _ in range(size)], label=pow(-1, i % 2)) for i in range(size)], partition=1)
# test fore_gradient
self.fore_gradient_local = [-0.5, 0.75, 0, 1.25, 0.5, 1.75, 1, 2.25, 1.5, 2.75]
# test gradient
self.gradient = [1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125]
self.gradient_fit_intercept = [1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125, 1.125]
self.loss = 4.505647