Clústeres de aprendizaje automático Spark

El algoritmo de clustering es una tarea de aprendizaje no supervisada que se utiliza para clasificar objetos en grupos con alta similitud. La idea del algoritmo de clustering es simplemente clasificar objetos. La agrupación es que cuanto más cerca estén los puntos con las mismas propiedades en el espacio, más cerca estarán. Se utiliza principalmente para la exploración de datos y la detección de anomalías. Uno de los algoritmos de agrupación más utilizados es el algoritmo de agrupación de k-medias.

Principio del algoritmo

El método de cálculo de k-medias es el siguiente. medias) algoritmo de agrupamiento

Principio del algoritmo

El método de cálculo de kmeans es el siguiente:

1 Seleccione k puntos centrales

2 Para all Repita los datos y clasifique cada dato al punto central más cercano

3 Calcule el promedio de cada grupo y utilícelo como el nuevo punto central

4 Repita 2 -3 hasta que estos Los k puntos centrales ya no cambian (convergen), o el número de iteraciones es suficiente.

El límite superior de la complejidad temporal de este algoritmo es O (n*k*t), donde k es el grupo de entrada. El número de, n es la cantidad de datos y t es el número de iteraciones.

En general, t, k, n pueden considerarse constantes, y la complejidad del tiempo y el espacio se puede simplificar a O (n), es decir, práctica de codificación lineal

Spark ml

se puede encontrar en Modificar y depurar el siguiente código en el entorno Spark-Shell. Puede usar datos comerciales reales para pruebas y evaluaciones. Los datos comerciales generalmente tienen varias columnas. Puede usar columnas de dimensión y VectorAssembler para ensamblar columnas vectoriales. columnas del algoritmo Kmeans. Considere escenarios de aplicación reales, como la detección de datos anormales, los datos normales se dividen en una categoría, los datos anormales se dividen en varias categorías y el número y la proporción de datos normales y datos anormales se cuentan respectivamente. p>

<span style="font-size ：", "font-size:", "font-size:", "font-size:" y "font-size:".18px;">importar org.apache.spark.ml.clustering.KMeans

import org.apache.spark.mllib.linalg.Vectors

val dataset = sqlContext.createDataFrame(Seq(

(1, Vectores.densos(0.0, 0.0, 0.0)),

(2, Vectores.densos(0.1, 0.1, 0.1)),

(3, Vectores.dense(0.2, 0.2, 0.2)),

(4, Vectores.dense(9.0, 9.0, 9.0)),

(5, Vectores.dense( 1.1, 1.1, 0.1)),

( 6, Vectores.denso(12, 14, 100)),

(6, Vectores.denso(1.1, 0.1, 0.2) ),

(6, Vectores.dense( -2, -3, -4)),

(6, Vectores.dense(1.6, 0.6, 0.2)))

)).toDF("id", "features")

// Entrena un modelo de K-medias

val kmeans = new KMeans().setK (3).setMaxIter(20).setFeaturesCol("features"). setPredictionCol("prediction")

val model = kmeans.fit(dataset)

// Mostrar resultados

println("Centros finales: ")

model.clusterCenters.foreach(println)

model.clusterCenters.zipWithIndex.foreach(println)

val myres = model.transform(dataset).select(" características", "predicción")

myres.show()

Algoritmo de agrupación es un tipo de algoritmo de aprendizaje automático no supervisado ¿Cómo evaluar el efecto de la agrupación? ¿Cómo ajustar los parámetros del entrenamiento del modelo? Al probarse, MLLib completará automáticamente diferentes combinaciones de estos parámetros y la canalización creará un flujo de trabajo, una sola vez, ajuste completo de todo el modelo en lugar de hacer cada uno de forma independiente.

Ajuste de parámetros, esto también debe volver a confirmarse, consulte SPARK-14516 Parece que no existe una métrica de efecto de agrupamiento automático y universal

Un código similar a este (pero todavía hay problemas con este código). ahora):

importar org.apache.spark.ml.clustering.KMeans

importar org.apache.spark.mllib .linalg.Vectors

importar org.apache.spark.ml.tuning.{ ParamGridBuilder, CrossValidator }.

importar org.apache.spark.ml.{ Pipeline , PipelineStage }

conjunto de datos val = sqlContext.createDataFrame(Seq(

(1, Vectors.dense( 0.0, 0.0, 0.0)),

(2 , Vectores.dense (0.1, 0.1, 0.1)),

(3, Vectores.dense(0.2, 0.2, 0.2)),

(4, Vectores.dense(9.0 , 9.0, 9.0 )),

(5, Vectores.dense(1.1, 1.1, 0.1)),

(6, Vectores.dense(12, 14, 100)) ,

(6, Vectores.dense(1.1, 0.1, 0.2)),

(6, Vectores.dense(-2, -3, -4)),

(6, Vectors.dense(1.6, 0.6, 0.2))

)).toDF("id", "features")

val kmeans = nuevo KMeans(). setK(2).setMaxIter(20).setFeaturesCol("features").setPredictionCol("prediction")

// El principal problema aquí es que el evaluador de la columna de etiquetas no está set

val evaluador = new BinaryClassificationEvaluator().setLabelCol("prediction")

val paramGrid = new ParamGridBuilder().addGrid(kmeans.initMode, Array("random")) .addGrid(kmeans.k, Array(3, 4)).addGrid(kmeans.maxIter, Array(20, 60)).addGrid(kmeans.seed, Array(1L, 2L)).build()

pasos de val: Array[PipelineStage] = Array(kmeans)

val pipeline = new Pipeline().setStages(steps)

val cv = new CrossValidator().setEstimator (canalización).setEvaluator(evaluador).setEstimatorParamMaps(paramGrid)

.setNumFolds(10)

// Entrena un modelo

val pipelineFittedModel = cv.fit(dataset)