def getArgs: String = $()

in vw/src/main/scala/com/microsoft/azure/synapse/ml/vw/VowpalWabbitBase.scala [81:192]

• 66 lines of code
• 8 McCabe index (conditional complexity)

  def getArgs: String = $(args)

  def setArgs(value: String): this.type = set(args, value)

  setDefault(additionalFeatures -> Array())

  // to support Grid search we need to replicate the parameters here...
  val numPasses = new IntParam(this, "numPasses", "Number of passes over the data")
  setDefault(numPasses -> 1)

  def getNumPasses: Int = $(numPasses)

  def setNumPasses(value: Int): this.type = set(numPasses, value)

  // Note on parameters: default values are set in the C++ codebase. To avoid replication
  // and potentially introduce conflicting default values, the Scala exposed parameters
  // are only passed to the native side if they're set.

  val learningRate = new DoubleParam(this, "learningRate", "Learning rate")

  def getLearningRate: Double = $(learningRate)

  def setLearningRate(value: Double): this.type = set(learningRate, value)

  val powerT = new DoubleParam(this, "powerT", "t power value")

  def getPowerT: Double = $(powerT)

  def setPowerT(value: Double): this.type = set(powerT, value)

  val l1 = new DoubleParam(this, "l1", "l_1 lambda")

  def getL1: Double = $(l1)

  def setL1(value: Double): this.type = set(l1, value)

  val l2 = new DoubleParam(this, "l2", "l_2 lambda")

  def getL2: Double = $(l2)

  def setL2(value: Double): this.type = set(l2, value)

  val interactions = new StringArrayParam(this, "interactions", "Interaction terms as specified by -q")

  def getInteractions: Array[String] = $(interactions)

  def setInteractions(value: Array[String]): this.type = set(interactions, value)

  val ignoreNamespaces = new Param[String](this, "ignoreNamespaces", "Namespaces to be ignored (first letter only)")

  def getIgnoreNamespaces: String = $(ignoreNamespaces)

  def setIgnoreNamespaces(value: String): this.type = set(ignoreNamespaces, value)

  val initialModel = new ByteArrayParam(this, "initialModel", "Initial model to start from")

  def getInitialModel: Array[Byte] = $(initialModel)

  def setInitialModel(value: Array[Byte]): this.type = set(initialModel, value)

  // abstract methods that implementors need to provide (mixed in through Classifier,...)
  def labelCol: Param[String]

  def getLabelCol: String

  setDefault(labelCol -> "label")

  def featuresCol: Param[String]

  def getFeaturesCol: String

  setDefault(featuresCol -> "features")

  val useBarrierExecutionMode = new BooleanParam(this, "useBarrierExecutionMode",
    "Use barrier execution mode, on by default.")
  setDefault(useBarrierExecutionMode -> true)

  def getUseBarrierExecutionMode: Boolean = $(useBarrierExecutionMode)

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

  implicit class ParamStringBuilder(sb: StringBuilder) {
    def appendParamIfNotThere[T](optionShort: String, optionLong: String, param: Param[T]): StringBuilder = {
      if (get(param).isEmpty ||
        // boost allow space or =
        s"-$optionShort[ =]".r.findAllIn(sb.toString).hasNext ||
        s"--$optionLong[ =]".r.findAllIn(sb.toString).hasNext) {
        sb
      }
      else {
        param match {
          case _: StringArrayParam =>
            for (q <- get(param).get)
              sb.append(s" --$optionLong $q")
          case _ => sb.append(s" --$optionLong ${get(param).get}")
        }

        sb
      }
    }

    def appendParamIfNotThere[T](optionLong: String): StringBuilder = {
      if (s"--${optionLong}".r.findAllIn(sb.toString).hasNext) {
        sb
      }
      else {
        sb.append(s" --$optionLong")

        sb
      }
    }
  }