Herramientas de cálculo de chispas

Vector

vectors.txt

1 2.3 4.5
3 3.1 5.6
4 3.2 7.8

Procesar el archivo vectors.txt RDD [String] -> RDD [Vector]

package com.yasuofenglei

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

object Driver01 {
  def main(args: Array[String]): Unit = {
    //创建向量类型，传入的类型是Double类型，如果是Int类型，会自动转换
    val v1=Vectors.dense(1,2,3.1,4,5)
    //
    val v2=Vectors.dense(Array[Double](1,2,3,4))
    
    
    
    val conf=new SparkConf()
    conf.setMaster("local").setAppName("wordcount")
    val sc=new SparkContext(conf)
    val data=sc.textFile("d://data/ml/vectors.txt",2)
    //RDD[String]->RDD[Array[String]]->RDD[Array[Double]]
    val r1=data.map{_.split(" ").map{num => num.toDouble}}
    .map{arr =>Vectors.dense(arr)}
    r1.foreach { println}
    
  }
}

Etiqueta de vector

package com.yasuofenglei

import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object Driver02 {
  def main(args: Array[String]): Unit = {
    val v1=Vectors.dense(2.2,3.1,4.5)
    //创建一个向量标签，1标签值
    val lb1 = LabeledPoint(1, v1)
    println(lb1)
    println(lb1.features)//获取向量标签中的向量
    println(lb1.label)//获取标签值
    
    
    val conf=new SparkConf()
    conf.setMaster("local").setAppName("wordcount")
    val sc=new SparkContext(conf)
    val data=sc.textFile("d://data/ml/vectors.txt",2)
    
    
    val r1=data.map{line=>
      val info=line.split(" ")
      val label=info.head.toDouble
      val features=info.drop(1).map{
        num => num.toDouble
      }
      LabeledPoint(label,Vectors.dense(features))
    }
    
    r1.foreach{println}
  }
}

Herramientas de cálculo de chispas

package com.yasuofenglei

import org.apache.spark._
import org.apache.spark.mllib.linalg._
import org.apache.spark.mllib.stat.Statistics

/**
 * Spark计算工具类
 */
object Driver03 {
  def main(args: Array[String]): Unit = {
    var conf=new SparkConf().setMaster("local").setAppName("statistic")
    var sc=new SparkContext(conf)
    val r1=sc.makeRDD(List(1,2,3,4,5))
    //RDD[Int]->RDD[Vector]
    val r2=r1.map{ num => Vectors.dense(num)}
    val result=Statistics.colStats(r2)
    
    println(result.max)
    println(result.min)
    println(result.mean)//均值
    println(result.variance)//方差
    println(result.count)
    println(result.numNonzeros)//不为0的元素个数
    println(result.normL1)//计算曼哈顿距离
    println(result.normL2)//计算欧式距离
    
  }
}

distancia euclidiana

Distancia euclidiana (Distancia euclidiana) La distancia euclidiana
en el espacio bidimensional y tridimensional es la distancia entre dos puntos.
Distancia euclidiana en un espacio bidimensional: la distancia euclidiana entre
dos puntos a (x1, y1) yb (x2, y2) en un plano bidimensional:

La distancia euclidiana entre dos puntos a (x1, y1, z1) yb (x2, y2, z2) en el espacio tridimensional:

La distancia euclidiana entre dos vectores n-dimensionales a (x11, x12, ..., x1n) yb (x21, x22, ..., x2n):

También se puede expresar como una operación vectorial:

R calcula la
distancia euclidiana . La función para calcular la distancia en R es dist (). El uso más directo es dist (x, método = "euclidiana"), que consiste en calcular la distancia euclidiana. Otros parámetros opcionales incluyen "máximo", " manhattan "," canberra "," binary "," minkowski ", lz ajusta este parámetro para obtener la distancia requerida por lz
Caso 1: R calcula la distancia euclidiana

a = c (1,1,3)
b = c (4,5,1)
distancia = sqrt (suma ((ab) ^ 2)); distancia
[1] 5.385165

o:

dist (rbind (a, b), método = "euclidiano")
a
b 5.385165

Es decir, la distancia entre la muestra ay la muestra b es: 5.385165

Caso 2: R calcula la distancia euclidiana entre múltiples muestras

a = matriz (rnorm (15,0,1), c (3,5))
a
[, 1] [, 2] [, 3] [, 4] [, 5]
[1,] 1.8094360 -0.7377281 -2.2285413 0.6091852 -0.1709287
[2,] -0.7308505 -0.3415692 -0.7755661 1.4363829 -0.5686896
[3,] 1.2290613 1.7541220 -0.8617373 0.3623487 -1.1996104
dist (a, método = “euclidiano”)

resultado:

-	1	2
2	3.092508
3	3.087624	3.129251

La distancia entre la primera fila de muestras y la segunda fila de muestras: 3.092508 La distancia entre la
primera fila de muestras y la tercera fila de muestras: 3.087624 La distancia entre la
segunda fila de muestras y la tercera fila de muestras: 3.129251

Distancia de Manhattan (Distancia de Manhattan)

Distancia de taxi o distancia de Manhattan es un vocabulario creado por Herman Minkowski en el siglo 19. Es un término geométrico utilizado en espacios de medición geométrica para indicar dos puntos en un sistema de coordenadas estándar. La suma de las distancias entre ejes absolutas.

En la siguiente figura: la

línea roja representa la distancia de Manhattan, el
verde representa la distancia euclidiana, que es la distancia en línea recta,
y el azul y el amarillo representan la distancia equivalente de Manhattan. Distancia de Manhattan: la distancia entre dos puntos en la dirección norte-sur más la distancia en la dirección este-oeste,
es decir , d (i, j) = | xi-xj | + | yi-yj |.

Para una calle de la ciudad con un trazado regular en la dirección sur y norte, y este y oeste, la distancia de un punto a otro es la distancia recorrida en la dirección norte-sur más la distancia recorrida en la dirección este-oeste, por lo que la distancia de Manhattan también se llama Distancia de taxi, la distancia de Manhattan no es invariante a la distancia, cuando el eje de coordenadas cambia, la distancia entre los puntos será diferente.

Diagrama de distancias de Manhattan En los primeros gráficos por computadora, la pantalla se compone de píxeles, que son números enteros, y las coordenadas de los puntos son generalmente números enteros. La razón es que las operaciones de punto flotante son costosas, lentas y tienen errores. Si usa la distancia euclidiana de AB directamente (Distancia euclidiana: la distancia euclidiana en el espacio bidimensional y tridimensional es la distancia entre dos puntos), debe realizar cálculos de punto flotante, si usa AC y CB, solo necesita calcular la suma y la resta. Sin embargo, esto mejora enormemente la velocidad de cálculo, y no importa cuántas veces se acumule el cálculo, no habrá errores.

Por ejemplo, en un plano, la distancia de Manhattan entre el punto i en las coordenadas (x1, y1) y el punto j en las coordenadas (x2, y2) es:
d (i, j) = | X1-X2 | + | Y1-Y2 |.

Caso: R calcula la distancia de Manhattan entre dos puntos

a <-c (1,2)
b <-c (5,8)
dist (rbind (a, b), method = "manhattan")
a
b 10

Resultado: distancia de Manhattan entre una muestra y una muestra b = 10

Distancia de Chebyshev

Distancia de Chebyshev (Distancia de Chebyshev), en matemáticas, la distancia de Chebyshev o métrica L∞ es una métrica en el espacio vectorial, y la distancia entre dos puntos se define como la diferencia máxima de valor de cada coordenada.

En el ajedrez, el rey puede moverse a cualquiera de las 8 casillas adyacentes en un paso. ¿Cuántos pasos necesita el rey para caminar desde la cuadrícula (x1, y1) a la cuadrícula (x2, y2)? Inténtalo tú mismo.
Encontrará que el número mínimo de pasos es siempre max (| x2-x1 |, | y2-y1 |) pasos. Este método de medición de distancia se llama distancia de Chebyshev.

Caso: R simula la distancia de Chebyshev de f6 (王) a c4
a <-c (3,4)
b <-c (6,6)
dist (rbind (a, b), method = “maximum”)
a
b 3

Es decir, Wang da al menos 3 pasos hacia c4.
Caso completo

package com.yasuofenglei

object Driver04 {
  def main(args: Array[String]): Unit = {
    val a1=Array(1,2)
    val a2=Array(4,7)
    //计算出a1和a2之间的欧式距离
    //拉链方法：zip
    //开方方法Math.sqrt()
    val r1=a1.zip(a2).map(x => (x._1-x._2)*(x._1-x._2)).sum
    println(Math.sqrt(r1))
    
    //计算两点间的夹角余弦
    val a1a2Fenzi=a1.zip(a2).map{x => x._1*x._2}.sum
    val a1Fenmu =Math.sqrt(a1.map{x => x*x}.sum)
    val a2Fenmu =Math.sqrt(a2.map{x => x*x}.sum)
    
    val a1a2Cos=a1a2Fenzi/(a1Fenmu*a2Fenmu)
    println(a1a2Cos)
    
  }
}

Método de mínimos cuadrados

Introducción El
método de mínimos cuadrados (también conocido como método de mínimos cuadrados) es una técnica de optimización matemática. Encuentra la mejor función coincidente de los datos minimizando la suma de cuadrados de errores. El método de mínimos cuadrados se puede utilizar para obtener fácilmente datos desconocidos y minimizar la suma de cuadrados de los errores entre los datos obtenidos y los datos reales. El método de mínimos cuadrados también se puede utilizar para el ajuste de curvas. Algunos otros problemas de optimización también se pueden expresar mediante el método de mínimos cuadrados minimizando la energía o maximizando la entropía.

Antecedentes El
método de mínimos cuadrados (LSE) es un método relativamente antiguo, derivado de las necesidades de aplicación de la astronomía y la geodesia. En el desarrollo temprano de la estadística matemática, estas dos ciencias jugaron un papel muy importante. El estadístico danés Hall las llamó las "madres de la estadística matemática". Desde entonces, se ha utilizado ampliamente en experimentos científicos y tecnología de ingeniería durante casi trescientos años. El historiador estadístico estadounidense SM Stigler señaló que el método de mínimos cuadrados fue el tema principal de la estadística matemática en el siglo XIX. En 1815, este método se había convertido en una herramienta estándar en astronomía y geodesia en Francia, Italia y Prusia, y en 1825 se había utilizado ampliamente en Gran Bretaña.

Giuseppe Piazzi

El astrónomo italiano Giuseppe Piazzi, que data de 1801, descubrió el primer asteroide Ceres. Después de 40 días de seguimiento, Piazzi perdió la posición de Ceres porque Ceres se movió detrás del sol. Luego, los científicos de todo el mundo comenzaron a buscar a Ceres utilizando los datos de observación de Piazzi, pero la búsqueda de Ceres basada en los resultados de los cálculos de la mayoría de las personas no dio resultado.

A la edad de 24 años, Gauss también calculó la órbita de Ceres. El astrónomo austríaco Heinrich Olbers redescubrió Ceres basándose en la órbita calculada por Gauss. Gauss en su libro de 1809 "Teoría del movimiento planetario alrededor del Sol". En este libro, afirmó que había utilizado el método de mínimos cuadrados desde 1799, lo que desató una disputa de prioridad con Legendre.

Después de estudiar los documentos originales, los estudiosos modernos creen que los dos pueden haber inventado este método de forma independiente, pero se vio por primera vez en forma escrita, y Legendre fue el primero. Sin embargo, hoy en día los libros de texto y las obras a menudo atribuyen esta invención a Gauss. La razón, además de la mayor reputación de Gauss, se debe principalmente a la importancia de su teoría del error normal para este método. Legendre explicó las ventajas del método de mínimos cuadrados en sus obras. Sin embargo, hay una falta de análisis de errores. No sabemos cuál es el error causado por el uso de este método, necesitamos establecer una teoría de análisis de errores. En 1823, Gauss demostró una propiedad óptima del método de mínimos cuadrados bajo el supuesto de una distribución de errores independiente e idéntica e1, ..., en: ¡Entre todas las clases de estimación lineal insesgadas, el método de mínimos cuadrados es el mínimo cuadrado!

El método actual de mínimos cuadrados fue propuesto por AM Legendre en su libro "Un nuevo método para calcular las órbitas de los cometas" en 1805. Su idea principal es seleccionar parámetros desconocidos para minimizar la suma de cuadrados de la diferencia entre el valor teórico y el valor observado:

principio y proceso de derivación
Echemos un vistazo a la situación lineal más simple.
Como se muestra en la figura siguiente, para un determinado conjunto de datos (xi, yi) (i = 0,1, ..., n), necesitamos encontrar una línea de tendencia (la línea de puntos en la figura) que pueda expresar el conjunto de datos (xi, yi) La dirección que apuntan estos puntos.



Resuelva un conjunto de k y b de modo que la suma del error de los cuadrados sea la más pequeña (la suma de las diferencias de los cuadrados RSS) para obtener la solución óptima correspondiente.

Suplemento de concepto relacionado con el modelado

• Establezca una ecuación objetivo que se ajuste a los datos de la muestra, la agenda objetivo no es fija. Puede ser una ecuación lineal o una ecuación no lineal.
• Resuelve los coeficientes de la ecuación objetivo. El propósito es encontrar la solución óptima de los coeficientes de la ecuación objetivo. Entonces es necesario averiguar la función de costo (función de pérdida, ecuación de costo) de la ecuación objetivo
• La solución óptima se obtiene mediante la función de pérdida.
• La función de pérdida no es fija y la ecuación objetivo es diferente y la función de pérdida cambia en consecuencia.

Caso de pronóstico de demanda de materias primas

lritem.txt

100|5 1000
75|7 600
80|6 1200
70|6 500
50|8 30
65|7 400
90|5 1300
100|4 1100
110|3 1300
60|9 300

Para el caso de pronosticar la demanda de productos básicos, hemos establecido un modelo de regresión lineal múltiple

• Para la predicción se utiliza el modelo de regresión Para el tipo de modelo de regresión: 1 regresión de mínimos cuadrados. 2 Regresión de descenso de gradiente. 3 Ridge regresa. 4Lasso regresa. ...
• Si solo hay una variable independiente, es un yuan. Si la variable independiente supera uno. Ambos pueden llamarse pluralismo.
• Ecuación objetivo. Ecuaciones lineales, ecuaciones planas, ecuaciones hiperplanas. La forma de la agenda lineal es fija: por ejemplo, la ecuación lineal y = β1X1 + β0 , la ecuación plana Y = β1X1 + β2X2 + β0 , la ecuación del hiperplano Y = β1X1 + β2X2 +… + βnXn + β0
• La agenda objetivo también puede ser una ecuación no lineal. La forma de la ecuación no lineal no es fija y no es adecuada para resolverla.

Descenso de gradiente

El método de mínimos cuadrados es aplicable a la situación en la que la ecuación del modelo tiene una solución analítica. Si no hay una solución analítica para una función, no se puede utilizar el método de mínimos cuadrados, en este momento, la solución real solo se puede aproximar mediante una solución numérica (iterativa).

No existe una solución analítica para la ecuación anterior y cada coeficiente no se puede expresar en expresiones variables.
El método de descenso de gradiente es más aplicable que el método de mínimos cuadrados

El método de descenso de gradiente pasa una solución numérica (múltiples iteraciones) y finalmente converge a la solución verdadera. Muchos modelos utilizan el descenso de gradientes para resolver los coeficientes en la capa inferior. Por ejemplo: modelo de regresión logística, red neuronal BP para retroalimentación de errores. Por lo tanto, la aplicación del método de descenso de gradiente es más extensa que el método de multiplicación de dos (porque el método de multiplicación de dos solo es aplicable a la situación en la que la ecuación del modelo tiene una solución analítica y la agenda del modelo en el entorno de producción es más complicada. Muchos de ellos no tienen una solución analítica)
gradiente desde un sentido geométrico , Es la dirección en la que la función cambia más rápido. Si sigue la dirección positiva del gradiente, puede encontrar el valor máximo de la función a la velocidad más rápida.
Si sigue la dirección del degradado, puede encontrar el valor máximo de la función más rápidamente. -> Método de ascenso de gradiente
Si sigue la dirección negativa del gradiente, puede encontrar el valor mínimo de la función más rápidamente. -> Método de descenso de gradiente
A menudo usamos el método de descenso de gradiente, la razón:
usando el método de descenso de gradiente, encuentre el valor mínimo de la función de pérdida (RSS), obtenga el coeficiente correspondiente al RSS principal.
El proceso de algoritmo del método de descenso de gradiente:

1. Seleccione aleatoriamente la posición inicial de 0
2. Multiplique el tamaño del paso (definido por el programador) por el gradiente de la función de pérdida para obtener la distancia descendente y luego actualice 0.
3. Repetir el segundo paso varias veces hasta que converja al valor mínimo de la función de pérdida (min RSS), obteniendo así la solución óptima.
   Hay dos elementos clave en el proceso anterior: 1 tamaño de paso y 2 gradientes de la función de pérdida.

package com.yasuofenglei.sgd

import org.apache.spark._
import org.apache.spark.sql.SQLContext
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.regression.LinearRegressionWithSGD
/*
1,0 1
2,0 2
3,0 3
5,1 4
7,6 1
9,4 5
6,3 3
 */
object Driver {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("sgd")
    val sc=new SparkContext(conf)
    
    val data=sc.textFile("d://data/ml/testSGD.txt")
    //1转换
    val parseData=data.map{line=>
      val info=line.split(",")
      val Y=info(0).toDouble
      val X1=info(1).split(" ")(0).toDouble
      val X2=info(1).split(" ")(1).toDouble
      LabeledPoint(Y,Vectors.dense(X1,X2))
    }
    //parseData.foreach{println}
    //建模，参数：迭代次数，步长
    //如果迭代次数过少，可能会导致还未收敛就结束了，误差很大。如果过多，会浪费CPU，导致计算代价过大
    //如果步长过小，会导致迭代很多次仍不收敛，如果过大，会导致围绕真实解来回震荡而不收敛
    //综上，建议：年代次数多一点，步长小一点（经验：0.05~0.5）
    val model=LinearRegressionWithSGD.train(parseData,20,0.05)
    
    //提取模型的自变量系数
    val coef=model.weights
    //通过模型实现预测
    //回代样本集预测，要求传入的数据类型RDD[Vector(X1,X2)]
    val predict=model.predict(parseData.map{x=> x.features})
    predict.foreach{println}
  }
}

Hay tres tipos de métodos de descenso de gradientes

1. Método de descenso de gradiente por lotes-BGD
   cada vez que se actualiza el coeficiente, todas las muestras deben participar en el cálculo.
   La ventaja es que se necesitan algunas generaciones para converger.
   La desventaja es que si el tamaño de la muestra es grande, se necesita mucho tiempo para iterar una vez.
   Este método generalmente no se usa en entornos de producción (debido a la gran cantidad de datos)
2. El método de descenso de gradiente estocástico-SGD
   cada vez que se actualiza el coeficiente, se selecciona aleatoriamente una muestra de todas las muestras para participar en la actualización.
   Las ventajas de cada actualización con
   deficiencias de coeficiente de tiempo muy corto necesitan más iteraciones para converger.
   Entonces, el entorno de producción actual usa esto para resolver el coeficiente.
3. Método de descenso de gradiente de lotes pequeños
   Este algoritmo es equivalente a una combinación de los dos anteriores, seleccionando un lote pequeño de datos para participar en la actualización de la muestra.

Modelo de regresión logística

Los modelos de regresión logística pueden responder a datos discretos, por lo que este modelo se aplica a problemas de clasificación seca. Anteriormente, aprendí el modelo de regresión lineal, que respondía a datos continuos y no podía responder a los datos de Lisu. .
conceptos básicos

• Datos continuos, dado un intervalo, puede tomar cualquier valor real en el intervalo
• Los datos discretos, dado un intervalo, solo pueden tomar un número limitado de valores reales en el intervalo.

Función sigmoidea

El papel de esta función: cualquier valor real se puede asignar a 0 o 1. Discretice cualquier dato continuo a 0 o 1.

En la figura anterior, e es un número trascendental, aproximadamente igual a 2.718. e = (1 + 1 / n) ^ n, cuando n se acerca al infinito, el valor obtenido es el número trascendental.

package com.yasuofenglei.logistic

import org.apache.spark._
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.classification.LogisticRegressionWithSGD
import org.apache.spark.mllib.classification.LogisticRegressionWithLBFGS
/*
建立逻辑回归模型，应用场景：用于二分类问题
因变量（离散的，取值情况有两种，1or0）
 */
/*样本数据
17	1	1	1
44	0	0	1
48	1	0	1
55	0	0	1
75	1	1	1
35	0	1	0
42	1	1	0
57	0	0	0
28	0	1	0
20	0	1	0
38	1	0	0
45	0	1	0
47	1	1	0
52	0	0	0
55	0	1	0
68	1	0	1
18	1	0	1
68	0	0	1
48	1	1	1
17	0	0	1
 * */
object Driver {
  def main(args: Array[String]): Unit = {
    val conf= new SparkConf().setMaster("local").setAppName("logistic");
    val sc=new SparkContext(conf)
    val data=sc.textFile("d://data/ml/logistic.txt")
    //第一步，为了满足建模需要，需要做数据转换
    //RDD[String]->RDD[LabelPoint]
    val parseData=data.map{line => 
      val info=line.split("\t")
      val Y=info.last.toDouble;
      val featuresArray=info.take(3).map{_.toDouble};
      LabeledPoint(Y,Vectors.dense(featuresArray))
    }
    //parseData.foreach{println}
    //第二步建立逻辑回归模型,底层用的是随机梯度下降法来解出系数
//    val model= LogisticRegressionWithSGD.train(parseData, 500,1) //参数不好调
    //建立逻辑回归模型，底层用的是拟牛顿法来解出系数,
    /*这种算法通过数值解逼近真实解（迭代算法），属于快速迭代法，并且不需要指定步长
     * 优点：迭代次数少，而且不需要指定步长
     * 缺点：每迭代一次，计算量较大，所以如果数据量较大，还是建议使用SGD
     * */
    val model=new LogisticRegressionWithLBFGS().run(parseData) 
    //模型系数
    val coef=model.weights
    //第三步，回代样本，做预测（分类）
    val predict=model.predict(parseData.map{x=>x.features})
    predict.foreach{println}
    /*
     * 预测数据
18	0	0
35	1	1
40	0	1
22	1	0
     * */
    val testData=sc.textFile("d://data/ml/testLogistic.txt")
    val parseTestData=testData.map{line=>line.split("\t").map{num => num.toDouble}}
      .map{arr=>Vectors.dense(arr)}
      
    val testPredict=model.predict(parseTestData)
    testPredict.foreach { println}
  }
}