es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Datos de entrenamiento/prueba con SparkML en Scala.

He estado enfrentando un problema durante las últimas horas. En teoría, cuando dividimos los datos para entrenamiento y pruebas, debemos estandarizar los datos de entrenamiento de forma independiente, para no introducir sesgos, y luego de haber entrenado el modelo estandarizamos el conjunto de pruebas usando los mismos valores “parámetros” que en el conjunto de entrenamiento.

Hasta ahora solo he logrado hacerlo sin el pipeline, de la siguiente manera:

val training = splitData(0)
val test = splitData(1)
val assemblerTraining = new VectorAssembler()
 .setInputCols(training.columns)
 .setOutputCol("features")
val standardScaler = new StandardScaler()
 .setInputCol("features")
 .setOutputCol("normFeatures")
 .setWithStd(true)
 .setWithMean(true)
val scalerModel = standardScaler.fit(training)
val scaledTrainingData = scalerModel.transform(training)
val scaledTestData = scalerModel.transform(test)

¿Cómo podría implementarlo con pipelines? Mi problema es que si creo un pipeline como este:

val pipelineTraining = new Pipeline()
 .setStages(
     Array(
         assemblerTraining,
         standardScaler,
         lr
     )
 )

donde lr es un LinearRegression, entonces no hay forma de acceder al modelo de escala desde dentro del pipeline.

También he pensado en usar un pipeline intermedio para hacer la escala así:

val pipelineScalingModel = new Pipeline()
 .setStages(Array(assemblerTraining, standardScaler))
 .fit(training)

val pipelineTraining = new Pipeline()
 .setStages(Array(pipelineScalingModel,lr))

val scaledTestData = pipelineScalingModel.transform(test)

Pero no sé si esta es la forma correcta de hacerlo.

Cualquier sugerencia sería muy apreciada.

Tags:  , , ,

Answer

  1. Avatar for davy.ai

    Solución para la estandarización de datos usando una tubería

    Al utilizar una tubería, queremos asegurarnos de que nuestro proceso de estandarización de datos sea consistente en todas las etapas de la tubería. Así es como se implementa el proceso de estandarización utilizando una tubería:

    // Tubería para la estandarización
    val scaler = new StandardScaler()
      .setInputCol("features")
      .setOutputCol("scaledFeatures")
      .setWithStd(true)
      .setWithMean(true)
    
    // Crear etapas de la tubería
    val assembler = new VectorAssembler()
      .setInputCols(training.columns)
      .setOutputCol("features")
    val lr = new LinearRegression()
      .setLabelCol("label")
      .setFeaturesCol("scaledFeatures")
    
    // Definir la tubería
    val pipeline = new Pipeline()
      .setStages(Array(assembler, scaler, lr))
    
    // Ajustar la tubería en los datos de entrenamiento
    val pipelineModel = pipeline.fit(training)
    
    // Realizar predicciones en los datos de prueba
    val predictions = pipelineModel.transform(test)
    
    

    Esta implementación implica definir un objeto StandardScaler como una etapa separada de la tubería. La etapa del escalador toma la columna features generada por la etapa del ensamblador y la escala en consecuencia.

    Luego creamos la tubería y establecemos las etapas en los objetos VectorAssembler, StandardScaler y LinearRegression. Las funciones setInputCol y setOutputCol se utilizan para especificar las columnas de entrada y salida en cada etapa.

    Luego se llama al método pipeline.fit() en los datos de entrenamiento, que ejecuta los datos a través de todas las etapas definidas en la tubería.

    Finalmente, se llama al método transform() en los datos de prueba utilizando el pipelineModel generado a partir del método pipeline.fit().

    Esta implementación garantiza que la estandarización de datos sea consistente en todas las etapas de la tubería y que la etapa del escalador pueda ser accedida y modificada según sea necesario.

Comments are closed.