code: def optimization(base_lr, loss, train_steps, optimizer="sgd"):
      decayed_lr = L.learning_rate_scheduler.polynomial_decay(
          learning_rate=base_lr,
          decay_steps=train_steps,
          end_learning_rate=0.0001 * base_lr,
          power=1.0,
          cycle=False,
      )
      if optimizer == "sgd":
          optimizer = F.optimizer.SGD(decayed_lr)
      elif optimizer == "adam":
          optimizer = F.optimizer.Adam(decayed_lr, lazy_mode=True)
      else:
          raise ValueError
  
      log.info("learning rate:%f" % (base_lr))
      # create the distributed optimizer
  
      # strategy = StrategyFactory.create_sync_strategy()
      strategy = StrategyFactory.create_async_strategy()
      # strategy = StrategyFactory.create_half_async_strategy()
      # strategy = StrategyFactory.create_geo_strategy()
      optimizer = fleet.distributed_optimizer(optimizer, strategy)
      optimizer.minimize(loss)
  
imports: import argparse
  import time
  import os
  import math
  from multiprocessing import Process
  import numpy
  import paddle.fluid
  import paddle.fluid.layers
  from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet
  from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import StrategyFactory
  import paddle.fluid.incubate.fleet.base.role_maker
  import pgl
  from pgl.utils.logger import log
  from pgl import data_loader
  from reader import DeepwalkReader
  from model import DeepwalkModel
  from utils import get_file_list
  from utils import build_graph
  from utils import build_random_graph
  from utils import build_fake_graph
  from utils import build_gen_func
label_desc: Use image node_id 1 for calling a global function with example usage: optimization(base_lr, loss, train_steps, optimizer) without return types