code: def main(config="../config.yaml", namespace=""):
      if isinstance(config, str):
          config = test_utils.load_job_config(config)
      parties = config.parties
      guest = parties.guest[0]
      host = parties.host[0]
      arbiter = parties.arbiter[0]
  
      pipeline = FateFlowPipeline().set_parties(
          guest=guest, host=host, arbiter=arbiter
      )
      if config.task_cores:
          pipeline.conf.set("task_cores", config.task_cores)
      if config.timeout:
          pipeline.conf.set("timeout", config.timeout)
  
      reader_0 = Reader(
          "reader_0", runtime_parties=dict(guest=guest, host=host)
      )
      reader_0.guest.task_parameters(
          namespace=f"experiment{namespace}", name="breast_hetero_guest"
      )
      reader_0.hosts[0].task_parameters(
          namespace=f"experiment{namespace}", name="breast_hetero_host"
      )
      psi_0 = PSI("psi_0", input_data=reader_0.outputs["output_data"])
      lr_0 = CoordinatedLR(
          "lr_0",
          epochs=10,
          batch_size=300,
          optimizer={
              "method": "SGD",
              "optimizer_params": {"lr": 0.1},
              "penalty": "l2",
              "alpha": 0.001,
          },
          init_param={"fit_intercept": True, "method": "zeros"},
          train_data=psi_0.outputs["output_data"],
          learning_rate_scheduler={
              "method": "linear",
              "scheduler_params": {
                  "start_factor": 0.7,
                  "total_iters": 100,
              },
          },
      )
  
      evaluation_0 = Evaluation(
          "evaluation_0",
          runtime_parties=dict(guest=guest),
          default_eval_setting="binary",
          input_data=lr_0.outputs["train_output_data"],
      )
  
      pipeline.add_tasks([reader_0, psi_0, lr_0, evaluation_0])
  
      pipeline.compile()
      pipeline.fit()
  
      lr_model = pipeline.get_task_info("lr_0").get_output_model()
      param = lr_model["output_model"]["data"]["estimator"]["param"]
      dtype = getattr(torch, param["dtype"])
      coef = torch.transpose(
          torch.tensor(param["coef_"], dtype=dtype), 0, 1
      )
      intercept = torch.tensor(param["intercept_"], dtype=dtype)
  
      import pandas as pd
  
      input_data = pd.read_csv(
          "../../data/breast_hetero_guest.csv", index_col="id"
      )
      input_data.drop(["y"], axis=1, inplace=True)
      input_data = torch.tensor(input_data.values, dtype=dtype)
  
      pytorch_model = LogisticRegression(coef)
      with torch.no_grad():
          pytorch_model.linear.weight.copy_(coef)
          pytorch_model.linear.bias.copy_(intercept)
          predict_result = pytorch_model(input_data)
      print(f"predictions shape: {predict_result.shape}")
  
file_path: FATE/examples/pipeline/coordinated_lr/test_lr_predict_w_torch.py
imports: import argparse
  import torch
  from fate_client.pipeline import FateFlowPipeline
  from fate_client.pipeline.components.fate import CoordinatedLR, PSI, Reader
  from fate_client.pipeline.components.fate import Evaluation
  from fate_client.pipeline.utils import test_utils
label_desc: Use image node_id 1 for calling a global function with example usage: main(config, namespace) without return types