def getParallelism: String = $()

in lightgbm/src/main/scala/com/microsoft/azure/synapse/ml/lightgbm/params/LightGBMParams.scala [20:118]

• 70 lines of code
• 1 McCabe index (conditional complexity)

  def getParallelism: String = $(parallelism)
  def setParallelism(value: String): this.type = set(parallelism, value)

  val topK = new IntParam(this, "topK",
    "The top_k value used in Voting parallel, " +
      "set this to larger value for more accurate result, but it will slow down the training speed. " +
      "It should be greater than 0")
  setDefault(topK -> LightGBMConstants.DefaultTopK)

  def getTopK: Int = $(topK)
  def setTopK(value: Int): this.type = set(topK, value)

  val defaultListenPort = new IntParam(this, "defaultListenPort",
    "The default listen port on executors, used for testing")

  def getDefaultListenPort: Int = $(defaultListenPort)
  def setDefaultListenPort(value: Int): this.type = set(defaultListenPort, value)

  setDefault(defaultListenPort -> LightGBMConstants.DefaultLocalListenPort)

  val driverListenPort = new IntParam(this, "driverListenPort",
    "The listen port on a driver. Default value is 0 (random)")

  def getDriverListenPort: Int = $(driverListenPort)
  def setDriverListenPort(value: Int): this.type = set(driverListenPort, value)

  setDefault(driverListenPort -> LightGBMConstants.DefaultDriverListenPort)

  val timeout = new DoubleParam(this, "timeout", "Timeout in seconds")
  setDefault(timeout -> 1200)

  def getTimeout: Double = $(timeout)
  def setTimeout(value: Double): this.type = set(timeout, value)

  val useBarrierExecutionMode = new BooleanParam(this, "useBarrierExecutionMode",
    "Barrier execution mode which uses a barrier stage, off by default.")
  setDefault(useBarrierExecutionMode -> false)

  def getUseBarrierExecutionMode: Boolean = $(useBarrierExecutionMode)
  def setUseBarrierExecutionMode(value: Boolean): this.type = set(useBarrierExecutionMode, value)

  val useSingleDatasetMode = new BooleanParam(this, "useSingleDatasetMode",
    "Use single dataset execution mode to create a single native dataset per executor (singleton) " +
      "to reduce memory and communication overhead. Note this is disabled when running spark in local mode.")
  setDefault(useSingleDatasetMode -> true)

  def getUseSingleDatasetMode: Boolean = $(useSingleDatasetMode)
  def setUseSingleDatasetMode(value: Boolean): this.type = set(useSingleDatasetMode, value)

  val numBatches = new IntParam(this, "numBatches",
    "If greater than 0, splits data into separate batches during training")
  setDefault(numBatches -> 0)

  def getNumBatches: Int = $(numBatches)
  def setNumBatches(value: Int): this.type = set(numBatches, value)

  val repartitionByGroupingColumn = new BooleanParam(this, "repartitionByGroupingColumn",
    "Repartition training data according to grouping column, on by default.")
  setDefault(repartitionByGroupingColumn -> true)

  def getRepartitionByGroupingColumn: Boolean = $(repartitionByGroupingColumn)
  def setRepartitionByGroupingColumn(value: Boolean): this.type = set(repartitionByGroupingColumn, value)

  val numTasks = new IntParam(this, "numTasks",
    "Advanced parameter to specify the number of tasks.  " +
      "SynapseML tries to guess this based on cluster configuration, but this parameter can be used to override.")
  setDefault(numTasks -> 0)

  def getNumTasks: Int = $(numTasks)
  def setNumTasks(value: Int): this.type = set(numTasks, value)

  val chunkSize = new IntParam(this, "chunkSize",
    "Advanced parameter to specify the chunk size for copying Java data to native.  " +
      "If set too high, memory may be wasted, but if set too low, performance may be reduced during data copy." +
      "If dataset size is known beforehand, set to the number of rows in the dataset.")
  setDefault(chunkSize -> 10000)

  def getChunkSize: Int = $(chunkSize)
  def setChunkSize(value: Int): this.type = set(chunkSize, value)

  val matrixType = new Param[String](this, "matrixType",
    "Advanced parameter to specify whether the native lightgbm matrix constructed should be sparse or dense.  " +
      "Values can be auto, sparse or dense. Default value is auto, which samples first ten rows to determine type.")
  setDefault(matrixType -> "auto")

  def getMatrixType: String = $(matrixType)
  def setMatrixType(value: String): this.type = set(matrixType, value)

  val numThreads = new IntParam(this, "numThreads",
    "Number of threads for LightGBM. For the best speed, set this to the number of real CPU cores.")
  setDefault(numThreads -> 0)

  def getNumThreads: Int = $(numThreads)
  def setNumThreads(value: Int): this.type = set(numThreads, value)
}

/** Defines common parameters across all LightGBM learners related to learning score evolution.
  */
trait LightGBMLearnerParams extends Wrappable {