Puntos clave: Utilizar Apache Spark para mantenimiento predictivo aprovecha el aprendizaje automático para identificar máquinas que necesitan servicio. La guía explica cómo enviar trabajos de Spark para predicciones, con fragmentos de código y instrucciones esenciales.
- Envía trabajos de Spark para hacer predicciones de mantenimiento.
- Utiliza el aprendizaje automático para identificar máquinas que requieren mantenimiento.
En la primera parte explicamos cómo Crea un modelo de entrenamiento. En esta parte mostramos cómo Haz predicciones para mostrar qué máquinas de nuestro conjunto de datos deben ser retiradas del servicio para mantenimiento.
Primero, aquí están cómo enviar el trabajo a Spark con spark-submit:
- jar que contiene com.bmc.lr.makePrediction
- qué archivo leer, es decir, el que acaba de generar te en la Parte I (poner enlace al artículo anterior)
- ¿qué modelo utiliza es decir, el que te generado en la Parte I (poner enlace al artículo anterior)
spark-submit
--clase com.bmc.lr.makePrediction
--maestro local[*]
hdfs://localhost:9000/maintenance/lr-assembly-1.0.jar
hdfs://localhost:9000/maintenance/2018.04.20.15.48.54.csv
hdfs://localhost:9000/maintenance/maintenance_model
spark-submit --class com.bmc.lr.makePrediction --master local[*] hdfs://localhost:9000/maintenance/lr-assembly-1.0.jar hdfs://localhost:9000/maintenance/2018.04.20.15.48.54.csv hdfs://localhost:9000/maintenance/maintenance_model
Código
Aquí son los nombres habituales de importación y paquete.
package com.bmc.lr
import org.apache.spark.sql.SQLContext
import org.apache.spark.ml.classification.{BinaryLogisticRegressionSummary, LogisticRegression}
import org.apache.spark.mllib.linalg.{Vector, Vectors}
import org.apache.spark.ml.evaluation.BinaryClassificationEvaluator
import org.apache.spark.ml.feature.{VectorAssembler, StringIndexer}
import org.apache.spark.ml.classification.LogisticRegressionModel
import org.apache.spark.SparkConf
import org.apache.spark.sql.SQLContext
import org.apache.spark.SparkContext
Lee los argumentos de la línea de comandos y configura el contexto de Spark y SQL. Crea el objeto makePrediction para poder instanciar la clase com.bmc.lr.makePrediction desde spark-submit.
object makePrediction {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("lr")
val sc = new SparkContext(conf)
var modelFile = args(1);
var file = args(0);
val sqlContext = new SQLContext(sc)
utiliza bloques de datos para leer el archivo de entrada y Crea un org.apache.spark.sql.DataFrame. Los bloques de datos posteriores serán útiles para guardar la salida en Hadoop, ya que solo requiere una línea de código.
val df = sqlContext.read.format("com.databricks.spark.csv").option("header", "true").option("inferSchema", "true").option("delimiter",";").load(file)
val df = sqlContext.read.format("com.databricks.spark.csv").option("header", "true").option("inferSchema", "true").option("delimiter",";").load(file)
En este punto, el df se ve así:
lifetime|broken| pressureInd| moistureInd| temperatureInd|team| provider|
+------------------+------+------------------+------------------+--------------
|17.792044609594086| 0|104.25543343273085| 88.67373165099184|122.75111030066334| 47|Ford F-750|
| 69.39805687060903| 0| 93.34561942201603| 86.62996015487022| 84.9796059428202| 34|Ford F-750|
| 84.53664924532875| 0|110.64579687466193|125.89351825805036| 58.34915688191312| 8|Ford F-750|
org.apache.spark.ml.featureVectorAssembler transforma las características en featureCols en una columna vectorial. Necesitamos que esté en este formato para conectarlo a LogisticRegressionModel.transform(), que toma las características (lifetime, pressureInd, moistureInd, temperatureInd) y las etiquetas (rotas que renombramos a etiqueta para mayor claridad) como paso para predecir qué máquinas fallarán.
Luego tomamos la etiqueta rota (1 o 0) y la ponemos en org.apache.spark.ml.feature.StringIndexer para contener un único valor, la etiqueta. org.apache.spark.ml.feature.StringIndexer.fit() ajusta los datos al modelo, es decir, Haz las predicciones.
You can see what the features vectors look like after we create df3 (see below).
val featureCols = Array("lifetime", "pressureInd", "moistureInd", "temperatureInd")
val assembler = new VectorAssembler().setInputCols(featureCols).setOutputCol("features")
val labelIndexer = new StringIndexer().setInputCol("broken").setOutputCol("label")
val df2 = assembler.transform(df)
val df3 = labelIndexer.fit(df2).transform(df2)
Aquí mostramos la columna de características (aunque están cortada en la pantalla). Si te acuerdas, esto es como los vectores densos que hemos estado usando para conectar los modelos de entrenamiento.
df3.select("features").show()
+--------------------+
| features|
+--------------------+
|[17.7920446095940...|
|[69.3980568706090...|
|[84.5366492453287...|
|[71.6002965259175...|
|[46.8176995523900...|
Carga el modelo org.apache.spark.ml.classification.LogisticRegressionModel guardado desde el sistema de archivos Hadoop. Entrenamos este modelo en el primer programa.
val model = LogisticRegressionModel.load(modelFile)
val model = LogisticRegressionModel.load(modelFile)
Aquí seleccionamos solo las columnas que queremos (eliminando características, ya que están difíciles de imprimir y visualizar y también redundantes). Luego mostramos solo aquellas máquinas que requieren mantenimiento, es decir, aquellas cuyo valor predicho de fallo están 1 (verdadero).
val predictions = model.transform(df3)
var df4 = predictions.select ("team", "provider", "pressureInd", "moistureInd", "temperatureInd", "label", "prediction")
val df5 = df4.filter("prediction=1")
df5.show()
Con df5.show() Ve que 4 máquinas necesitan mantenimiento:
+----+----------+------------------+------------------+-----------------+-----+----------+
|team| provider| pressureInd| moistureInd| temperatureInd|label|prediction|
+----+----------+------------------+------------------+-----------------+-----+----------+
| 34|Ford F-750| 93.34561942201603| 86.62996015487022| 84.9796059428202| 0.0| 1.0|
| 8|Ford F-750|110.64579687466193|125.89351825805036|58.34915688191312| 0.0| 1.0|
| 83|Ford F-750| 55.77009802003853| 66.832777175712|125.2982705340028| 0.0| 1.0|
| 2|Ford F-750| 84.1763960666348| 82.1342684415311|57.73202884026434| 0.0| 1.0|
+----+----------+------------------+------------------+-----------------+-----+----------+
Ahora Ve otro ejemplo de cómo los bloqueadores de datos están al permitirnos escribir las predicciones en un .csv en Hadoop. Guardamos la salida en un archivo cuyo nombre están la fecha. Ten en cuenta también que importamos java.util.date porque están la forma más fácil de Crea diferentes formatos de fecha.
import java.util.Date
import java.text.SimpleDateFormat
val date = new Date()
var dformat:SimpleDateFormat = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss");
val csvFile = "hdfs://localhost:9000/maintenance/" + dformat.format(date) + ".csv"
df5.write.format("com.databricks.spark.csv").option("header", "true").save(csvFile)
}
}
Ahora mostramos los datos:
hadoop fs -cat hdfs://localhost:9000/maintenance/2018.05.16.09.07.33.csv/part-00000-7a9a4de6-ab90-4cd4-b9f5-d0d30c881b2c-c000.csv
equipo, proveedor, presiónInd,humedadInd,temperaturaInd,etiqueta, predicción
34,Ford F-750,93.34561942201603,86.62996015487022,84.9796059428202,0.0,1.0
8,Ford F-750,110.64579687466193,125.89351825805036,58.34915688191312,0.0,1.0
83,Ford F-750,55.77009802003853,66.832777175712,125.2982705340028,0.0,1.0
2,Ford F-750,84.1763960666348,82.1342684415311,57.73202884026434,0.0,1.0
hadoop fs -cat hdfs://localhost:9000/maintenance/2018.05.16.09.07.33.csv/part-00000-7a9a4de6-ab90-4cd4-b9f5-d0d30c881b2c-c000.csv team,provider,pressureInd,moistureInd,temperatureInd,label,prediction 34,Ford F-750,93.34561942201603,86.62996015487022,84.9796059428202,0.0,1.0 8,Ford F-750,110.64579687466193,125.89351825805036,58.34915688191312,0.0,1.0 83,Ford F-750,55.77009802003853,66.832777175712,125.2982705340028,0.0,1.0 2,Ford F-750,84.1763960666348,82.1342684415311,57.73202884026434,0.0,1.0
Guía Apache Spark
- La Canalización de Aprendizaje Automático de Apache Spark: Una introducción
- Ejemplo de regresión lineal SGD con Apache Spark
- Clasificador de árbol de decisión de chispa
- Uso de regresión logística, scala y chispa
- Cómo utilizar cuadernos Jupyter con Apache Spark
- Uso de aprendizaje automático en Python y Spark para hacer clasificación
- Cómo escribir UDFs (funciones definidas por el usuario) de Spark en Python
- Ejemplo de Python Spark ML K-Means
- Cómo aplicar el aprendizaje automático a la ciberseguridad
- Apache Spark: Trabajando con Streams
- K-significa agrupación con Apache Spark
- Usando Chispa con Colmena
- Cómo utilizar Apache Spark para Haz predicciones para el mantenimiento preventivo
Estas publicaciones son mías y no representan necesariamente la posición, estrategias u opinión de BMC.