def main(config="../../config.yaml", namespace=""):
# obtain config
if isinstance(config, str):
config = load_job_config(config)
parties = config.parties
guest = parties.guest[0]
host = parties.host[0]
guest_train_data = {"name": "breast_hetero_guest", "namespace": f"experiment{namespace}"}
host_train_data = {"name": "breast_hetero_host", "namespace": f"experiment{namespace}"}
pipeline = PipeLine().set_initiator(role='guest', party_id=guest).set_roles(guest=guest, host=host)
reader_0 = Reader(name="reader_0")
reader_0.get_party_instance(role='guest', party_id=guest).component_param(table=guest_train_data)
reader_0.get_party_instance(role='host', party_id=host).component_param(table=host_train_data)
data_transform_0 = DataTransform(name="data_transform_0")
data_transform_0.get_party_instance(role='guest', party_id=guest).component_param(with_label=True)
data_transform_0.get_party_instance(role='host', party_id=host).component_param(with_label=False)
intersection_0 = Intersection(name="intersection_0")
hetero_nn_0 = HeteroNN(name="hetero_nn_0", epochs=100,
interactive_layer_lr=0.15, batch_size=-1, early_stop="diff",
selector_param={"method": "relative"})
guest_nn_0 = hetero_nn_0.get_party_instance(role='guest', party_id=guest)
guest_nn_0.add_bottom_model(Dense(units=3, input_shape=(10,), activation="relu",
kernel_initializer=initializers.Constant(value=1)))
guest_nn_0.set_interactve_layer(Dense(units=2, input_shape=(2,),
kernel_initializer=initializers.Constant(value=1)))
guest_nn_0.add_top_model(Dense(units=1, input_shape=(2,), activation="sigmoid",
kernel_initializer=initializers.Constant(value=1)))
host_nn_0 = hetero_nn_0.get_party_instance(role='host', party_id=host)
host_nn_0.add_bottom_model(Dense(units=3, input_shape=(20,), activation="relu",
kernel_initializer=initializers.Constant(value=1)))
host_nn_0.set_interactve_layer(Dense(units=2, input_shape=(2,),
kernel_initializer=initializers.Constant(value=1)))
hetero_nn_0.compile(optimizer=optimizers.SGD(lr=0.15), loss="binary_crossentropy")
hetero_nn_1 = HeteroNN(name="hetero_nn_1")
evaluation_0 = Evaluation(name="evaluation_0")
pipeline.add_component(reader_0)
pipeline.add_component(data_transform_0, data=Data(data=reader_0.output.data))
pipeline.add_component(intersection_0, data=Data(data=data_transform_0.output.data))
pipeline.add_component(hetero_nn_0, data=Data(train_data=intersection_0.output.data))
pipeline.add_component(hetero_nn_1, data=Data(test_data=intersection_0.output.data),
model=Model(model=hetero_nn_0.output.model))
pipeline.add_component(evaluation_0, data=Data(data=hetero_nn_0.output.data))
pipeline.compile()
pipeline.fit()
print(hetero_nn_0.get_config(roles={"guest": [guest],
"host": [host]}))
print(pipeline.get_component("hetero_nn_0").get_summary())
def main(config="../../config.yaml", namespace=""):
# obtain config
if isinstance(config, str):
config = load_job_config(config)
parties = config.parties
guest = parties.guest[0]
host = parties.host[0]
backend = config.backend
work_mode = config.work_mode
guest_train_data = {
"name": "breast_hetero_guest",
"namespace": f"experiment{namespace}"
}
host_train_data = {
"name": "breast_hetero_host",
"namespace": f"experiment{namespace}"
}
pipeline = PipeLine().set_initiator(role='guest',
party_id=guest).set_roles(guest=guest,
host=host)
reader_0 = Reader(name="reader_0")
reader_0.get_party_instance(
role='guest', party_id=guest).algorithm_param(table=guest_train_data)
reader_0.get_party_instance(
role='host', party_id=host).algorithm_param(table=host_train_data)
reader_1 = Reader(name="reader_1")
reader_1.get_party_instance(
role='guest', party_id=guest).algorithm_param(table=guest_train_data)
reader_1.get_party_instance(
role='host', party_id=host).algorithm_param(table=host_train_data)
dataio_0 = DataIO(name="dataio_0")
dataio_0.get_party_instance(
role='guest', party_id=guest).algorithm_param(with_label=True)
dataio_0.get_party_instance(
role='host', party_id=host).algorithm_param(with_label=False)
dataio_1 = DataIO(name="dataio_1")
dataio_1.get_party_instance(
role='guest', party_id=guest).algorithm_param(with_label=True)
dataio_1.get_party_instance(
role='host', party_id=host).algorithm_param(with_label=False)
intersection_0 = Intersection(name="intersection_0")
intersection_1 = Intersection(name="intersection_1")
hetero_nn_0 = HeteroNN(name="hetero_nn_0",
epochs=100,
validation_freqs=1,
interactive_layer_lr=0.15,
batch_size=-1,
early_stop="diff",
early_stopping_rounds=15,
use_first_metric_only=True)
hetero_nn_0.add_bottom_model(
Dense(units=3,
input_shape=(10, ),
activation="relu",
kernel_initializer=initializers.Constant(value=1)))
hetero_nn_0.set_interactve_layer(
Dense(units=2,
input_shape=(2, ),
kernel_initializer=initializers.Constant(value=1)))
hetero_nn_0.add_top_model(
Dense(units=1,
input_shape=(2, ),
activation="sigmoid",
kernel_initializer=initializers.Constant(value=1)))
hetero_nn_0.compile(optimizer=optimizers.SGD(lr=0.15),
metrics=["AUC"],
loss="binary_crossentropy")
hetero_nn_1 = HeteroNN(name="hetero_nn_1")
evaluation_0 = Evaluation(name="evaluation_0")
pipeline.add_component(reader_0)
pipeline.add_component(reader_1)
pipeline.add_component(dataio_0, data=Data(data=reader_0.output.data))
pipeline.add_component(dataio_1, data=Data(data=reader_1.output.data))
pipeline.add_component(intersection_0,
data=Data(data=dataio_0.output.data))
pipeline.add_component(intersection_1,
data=Data(data=dataio_1.output.data))
pipeline.add_component(hetero_nn_0,
data=Data(train_data=intersection_0.output.data,
validate_data=intersection_1.output.data))
pipeline.add_component(hetero_nn_1,
data=Data(test_data=intersection_1.output.data),
model=Model(model=hetero_nn_0.output.model))
pipeline.add_component(
evaluation_0,
data=Data(data=[hetero_nn_0.output.data, hetero_nn_1.output.data]))
pipeline.compile()
pipeline.fit(backend=backend, work_mode=work_mode)
print(pipeline.get_component("hetero_nn_0").get_summary())
print(pipeline.get_component("evaluation_0").get_summary())
def main(config="../../config.yaml",
param="./hetero_nn_breast_config.yaml",
namespace=""):
# obtain config
if isinstance(config, str):
config = load_job_config(config)
if isinstance(param, str):
param = JobConfig.load_from_file(param)
parties = config.parties
guest = parties.guest[0]
host = parties.host[0]
backend = config.backend
work_mode = config.work_mode
guest_train_data = {
"name": param["guest_table_name"],
"namespace": f"experiment{namespace}"
}
host_train_data = {
"name": param["host_table_name"],
"namespace": f"experiment{namespace}"
}
pipeline = PipeLine().set_initiator(role='guest',
party_id=guest).set_roles(guest=guest,
host=host)
reader_0 = Reader(name="reader_0")
reader_0.get_party_instance(
role='guest', party_id=guest).component_param(table=guest_train_data)
reader_0.get_party_instance(
role='host', party_id=host).component_param(table=host_train_data)
dataio_0 = DataIO(name="dataio_0")
dataio_0.get_party_instance(
role='guest', party_id=guest).component_param(with_label=True)
dataio_0.get_party_instance(
role='host', party_id=host).component_param(with_label=False)
intersection_0 = Intersection(name="intersection_0")
hetero_nn_0 = HeteroNN(name="hetero_nn_0",
epochs=param["epochs"],
interactive_layer_lr=param["learning_rate"],
batch_size=param["batch_size"],
early_stop="diff")
hetero_nn_0.add_bottom_model(
Dense(units=param["bottom_layer_units"],
input_shape=(10, ),
activation="tanh",
kernel_initializer=initializers.RandomUniform(minval=-1,
maxval=1,
seed=123)))
hetero_nn_0.set_interactve_layer(
Dense(units=param["interactive_layer_units"],
input_shape=(param["bottom_layer_units"], ),
activation="relu",
kernel_initializer=initializers.RandomUniform(minval=-1,
maxval=1,
seed=123)))
hetero_nn_0.add_top_model(
Dense(units=param["top_layer_units"],
input_shape=(param["interactive_layer_units"], ),
activation=param["top_act"],
kernel_initializer=initializers.RandomUniform(minval=-1,
maxval=1,
seed=123)))
opt = getattr(optimizers, param["opt"])(lr=param["learning_rate"])
hetero_nn_0.compile(optimizer=opt,
metrics=param["metrics"],
loss=param["loss"])
if param["loss"] == "categorical_crossentropy":
eval_type = "multi"
else:
eval_type = "binary"
evaluation_0 = Evaluation(name="evaluation_0", eval_type=eval_type)
pipeline.add_component(reader_0)
pipeline.add_component(dataio_0, data=Data(data=reader_0.output.data))
pipeline.add_component(intersection_0,
data=Data(data=dataio_0.output.data))
pipeline.add_component(hetero_nn_0,
data=Data(train_data=intersection_0.output.data))
pipeline.add_component(evaluation_0,
data=Data(data=hetero_nn_0.output.data))
pipeline.compile()
job_parameters = JobParameters(backend=backend, work_mode=work_mode)
pipeline.fit(job_parameters)
data_summary = {
"train": {
"guest": guest_train_data["name"],
"host": host_train_data["name"]
},
"test": {
"guest": guest_train_data["name"],
"host": host_train_data["name"]
}
}
return data_summary, pipeline.get_component("evaluation_0").get_summary()
def main(config="../../config.yaml", param="./hetero_nn_breast_config.yaml", namespace=""):
# obtain config
if isinstance(config, str):
config = load_job_config(config)
if isinstance(param, str):
param = JobConfig.load_from_file(param)
parties = config.parties
guest = parties.guest[0]
host = parties.host[0]
guest_train_data = {"name": param["guest_table_name"], "namespace": f"experiment{namespace}"}
host_train_data = {"name": param["host_table_name"], "namespace": f"experiment{namespace}"}
pipeline = PipeLine().set_initiator(role='guest', party_id=guest).set_roles(guest=guest, host=host)
reader_0 = Reader(name="reader_0")
reader_0.get_party_instance(role='guest', party_id=guest).component_param(table=guest_train_data)
reader_0.get_party_instance(role='host', party_id=host).component_param(table=host_train_data)
dataio_0 = DataIO(name="dataio_0")
dataio_0.get_party_instance(role='guest', party_id=guest).component_param(with_label=True)
dataio_0.get_party_instance(role='host', party_id=host).component_param(with_label=False)
intersection_0 = Intersection(name="intersection_0")
hetero_nn_0 = HeteroNN(name="hetero_nn_0", epochs=param["epochs"],
interactive_layer_lr=param["learning_rate"], batch_size=param["batch_size"],
early_stop="diff")
hetero_nn_0.add_bottom_model(Dense(units=param["bottom_layer_units"], input_shape=(10,), activation="tanh",
kernel_initializer=initializers.RandomUniform(minval=-1, maxval=1, seed=123)))
hetero_nn_0.set_interactve_layer(
Dense(units=param["interactive_layer_units"], input_shape=(param["bottom_layer_units"],), activation="relu",
kernel_initializer=initializers.RandomUniform(minval=-1, maxval=1, seed=123)))
hetero_nn_0.add_top_model(
Dense(units=param["top_layer_units"], input_shape=(param["interactive_layer_units"],),
activation=param["top_act"],
kernel_initializer=initializers.RandomUniform(minval=-1, maxval=1, seed=123)))
opt = getattr(optimizers, param["opt"])(lr=param["learning_rate"])
hetero_nn_0.compile(optimizer=opt, metrics=param["metrics"],
loss=param["loss"])
hetero_nn_1 = HeteroNN(name="hetero_nn_1")
if param["loss"] == "categorical_crossentropy":
eval_type = "multi"
else:
eval_type = "binary"
evaluation_0 = Evaluation(name="evaluation_0", eval_type=eval_type)
pipeline.add_component(reader_0)
pipeline.add_component(dataio_0, data=Data(data=reader_0.output.data))
pipeline.add_component(intersection_0, data=Data(data=dataio_0.output.data))
pipeline.add_component(hetero_nn_0, data=Data(train_data=intersection_0.output.data))
pipeline.add_component(hetero_nn_1, data=Data(test_data=intersection_0.output.data),
model=Model(hetero_nn_0.output.model))
pipeline.add_component(evaluation_0, data=Data(data=hetero_nn_0.output.data))
pipeline.compile()
pipeline.fit()
nn_0_data = pipeline.get_component("hetero_nn_0").get_output_data().get("data")
nn_1_data = pipeline.get_component("hetero_nn_1").get_output_data().get("data")
nn_0_score = extract_data(nn_0_data, "predict_result")
nn_0_label = extract_data(nn_0_data, "label")
nn_1_score = extract_data(nn_1_data, "predict_result")
nn_1_label = extract_data(nn_1_data, "label")
nn_0_score_label = extract_data(nn_0_data, "predict_result", keep_id=True)
nn_1_score_label = extract_data(nn_1_data, "predict_result", keep_id=True)
metric_summary = parse_summary_result(pipeline.get_component("evaluation_0").get_summary())
if eval_type == "binary":
metric_nn = {
"score_diversity_ratio": classification_metric.Distribution.compute(nn_0_score_label, nn_1_score_label),
"ks_2samp": classification_metric.KSTest.compute(nn_0_score, nn_1_score),
"mAP_D_value": classification_metric.AveragePrecisionScore().compute(nn_0_score, nn_1_score, nn_0_label,
nn_1_label)}
metric_summary["distribution_metrics"] = {"hetero_nn": metric_nn}
elif eval_type == "multi":
metric_nn = {
"score_diversity_ratio": classification_metric.Distribution.compute(nn_0_score_label, nn_1_score_label)}
metric_summary["distribution_metrics"] = {"hetero_nn": metric_nn}
data_summary = {"train": {"guest": guest_train_data["name"], "host": host_train_data["name"]},
"test": {"guest": guest_train_data["name"], "host": host_train_data["name"]}
}
return data_summary, metric_summary
