Capítulo 1: Uso de Scala para usar Spark para el aprendizaje automático práctico
En este capítulo, vamos a introducir:
descargar e instalar el JDK
para descargar e instalar IntelliJ
para descargar e instalar la chispa
configurado para utilizar IntelliJ Spark Spark ML y ejecutar código de ejemplo
de los códigos ML Spark ejecución de ejemplo
la identificación de la máquina real aprendizaje de las fuentes de datos
se utiliza con IntelliJ Apache Spark 2.0 de IDE ejecuta su primer programa
Cómo agregar gráficos a los programas Spark
Introducción
Con los últimos desarrollos en informática en clúster y el auge de los grandes datos, el campo del aprendizaje automático se ha puesto a la vanguardia de la informática. Durante mucho tiempo, la necesidad de una plataforma interactiva para la ciencia de datos a gran escala ha sido un sueño, y ahora se ha convertido en una realidad.
Las siguientes tres áreas promueven y aceleran conjuntamente el desarrollo de la ciencia de datos interactivos:
Apache chispa: una plataforma unificada de datos científicos y técnicos, la estructura de datos rápida y tolerante a fallos del motor incorporado en productos bien diseñados e integrados en el cálculo de
la máquina de aprendizaje: un campo de la inteligencia artificial, que permite a la máquina para imitar el cerebro humano retiene algo de la original especiales Algunas tareas
Scala: un lenguaje moderno basado en JVM basado en lenguajes tradicionales, pero que combina funcionalidad y conceptos orientados a objetos sin la verbosidad de otros lenguajes.
Primero, necesitamos configurar un entorno de desarrollo, que incluirá los siguientes componentes:
Las recetas de este capítulo le proporcionarán instrucciones detalladas sobre cómo instalar y configurar IntelliJ IDE, el complemento Scala y Spark. Después de configurar el entorno de desarrollo, continuaremos ejecutando uno de los códigos de muestra de Spark ML para probar la configuración.
Spark proporciona un marco distribuido fácil de usar en la pila de tecnología unificada, lo que la convierte en la plataforma preferida para proyectos de ciencia de datos, que generalmente no requieren algoritmos iterativos que eventualmente puedan combinarse en soluciones. Debido a sus principios de funcionamiento internos, estos algoritmos producirán una gran cantidad de resultados intermedios, que deben transferirse de una etapa a la siguiente en los pasos intermedios. La necesidad de herramientas interactivas con una biblioteca robusta de aprendizaje automático distribuido local (MLlib) impide el enfoque basado en disco de la mayoría de los proyectos de ciencia de datos.
Spark tiene diferentes métodos para la computación en clúster. Resuelve este problema en forma de una pila de tecnología en lugar de un ecosistema. La combinación de una gran cantidad de bibliotecas administradas centralmente y el motor informático ultrarrápido que puede soportar estructuras de datos tolerantes a fallas hace que Spark reemplace a Hadoop y se convierta en la plataforma preferida de análisis de big data.
Spark tiene un enfoque modular, como se muestra en la siguiente figura:
Aprendizaje automático
El propósito del aprendizaje automático es producir máquinas y dispositivos que puedan imitar la inteligencia humana y automatizar ciertas tareas tradicionalmente dejadas al cerebro humano. El objetivo de diseño de los algoritmos de aprendizaje automático es explorar conjuntos de datos muy grandes en un tiempo relativamente corto y proporcionar respuestas aproximadas, lo que hará que los humanos pasen más tiempo procesando.
El campo del aprendizaje automático se puede dividir en muchas formas y, en un nivel superior, se puede dividir en aprendizaje supervisado y aprendizaje no supervisado. Los algoritmos de aprendizaje supervisados son un tipo de algoritmos de ML que utilizan un conjunto de entrenamiento (es decir, datos etiquetados) para calcular distribuciones de probabilidad o modelos gráficos, de modo que puedan clasificar nuevos puntos de datos sin mayor intervención humana. El aprendizaje no supervisado es un algoritmo de aprendizaje automático utilizado para extraer inferencias de un conjunto de datos compuesto por datos de entrada sin respuestas de etiqueta.
Fuera de la caja, Spark proporciona un amplio conjunto de algoritmos de ML que se pueden implementar en grandes conjuntos de datos sin codificación adicional. La siguiente figura describe el algoritmo MLlib de Spark como un mapa mental. El MLlib de Spark está diseñado para aprovechar el paralelismo mientras tiene estructuras de datos distribuidos tolerantes a fallas. Spark se refiere a estructuras de datos tales como conjuntos de datos distribuidos elásticos o RDD:
Scala
Scala es un lenguaje de programación moderno que está reemplazando los lenguajes de programación tradicionales como Java y C ++. Scala es un lenguaje basado en JVM que no solo proporciona una sintaxis concisa sin el código repetitivo tradicional, sino que también combina programación orientada a objetos y funcional en un lenguaje extremadamente seguro y potente.
Scala utiliza un enfoque flexible y expresivo, lo que lo hace ideal para interactuar con MLlib de Spark. El hecho de que Spark esté escrito en Scala proporciona una fuerte evidencia de que el lenguaje Scala es un lenguaje de programación de servicio completo que puede usarse para crear código de sistema complejo con requisitos de alto rendimiento.
Scala se basa en la tradición de Java al resolver algunas de las deficiencias de Java, evitando el enfoque de todo o nada. El código Scala se compila en código de bytes Java para que pueda coexistir con bibliotecas Java ricas indistintamente. La capacidad de usar bibliotecas Java en combinación con Scala (o viceversa) proporciona a los ingenieros de software un entorno continuo y rico que les permite construir sistemas modernos y complejos de aprendizaje automático sin romper por completo con la tradición y la base de código de Java.
Scala es totalmente compatible con el paradigma de programación funcional rico en funciones, y tiene soporte estándar para lambdas, curry, interfaces de tipo, inmutabilidad, evaluación diferida y paradigmas de coincidencia de patrones, que recuerdan a Perl sin usar una sintaxis misteriosa. Scala admite tipos de datos compatibles con álgebra, funciones anónimas, covarianza, varianza inversa y funciones de orden superior, por lo que es muy adecuado para la programación de aprendizaje automático.
Este es el programa hello world en Scala:
object HelloWorld extends App {
println("Hello World! ")
}
Compile y ejecute Hello World en Scala de la siguiente manera:
scalac HelloWorld.scala
scala HelloWorld
La Guía de aprendizaje automático Apache Spark utiliza un enfoque práctico que brinda a los desarrolladores una perspectiva multidisciplinaria. Este libro se centra en el aprendizaje automático, la interacción y la cohesión de Apache Spark y Scala. También hemos tomado medidas adicionales para enseñarle cómo configurar y ejecutar un entorno de desarrollo integral con el que los desarrolladores están familiarizados, y proporcionar fragmentos de código que debe ejecutar en un shell interactivo sin utilizar las características modernas proporcionadas por el IDE:
apache spark ---> machine learning -->IDE --->scala
Versiones de software y bibliotecas utilizadas en este libro.
La siguiente tabla proporciona una lista detallada de las versiones de software y bibliotecas utilizadas en este libro. Si sigue las instrucciones de instalación en este capítulo, incluirá la mayoría de los elementos enumerados aquí. Cualquier otro archivo JAR o biblioteca que se requiera para una receta específica se introduce a través de otras instrucciones de instalación en la receta correspondiente:
Los otros JAR requeridos son los siguientes:
Varios
JAR Versión bliki-core 3.0.19
breeze-viz 0.12
Cloud9 1.5.0
Hadoop-streaming
2.2.0
JCommon
1.0.23
JFreeChart
1.0.19 lucene
-analyzers-common
6.0.0
Lucene-Core
6.0.0
scopt
3.3.0
spark -streaming-flume-assembly
2.0.0
spark-streaming-kafka-0-8-assembly2.0.0
También probamos todas las recetas en este libro en Spark 2.1.1 y descubrimos que el programa funcionó como se esperaba. Se recomienda utilizar las versiones y bibliotecas de software enumeradas en estas tablas con fines de aprendizaje. Para mantenerse al día con el panorama y la documentación de Spark en constante cambio, los enlaces de la API a la documentación de Spark mencionados en este libro apuntan a la última versión de Spark 2.xx, pero la referencia de la API en la receta se dirige específicamente a Spark 2.0.0. Todos los enlaces de documentación de Spark proporcionados en este libro apuntarán a la última documentación en el sitio web de Spark. Si desea encontrar la documentación de una versión específica de Spark (por ejemplo, Spark 2.0.0), utilice la siguiente URL para encontrar documentos relacionados en el sitio web de Spark:
Para mayor claridad, hemos hecho que el código sea lo más simple posible, en lugar de demostrar las características avanzadas de Scala.
La siguiente es una lista de datos de código abierto. Si desea desarrollar aplicaciones en esta área, vale la pena explorar:
https://archive.ics.uci.edu/ml/index.php --- repositorio de aprendizaje automático UCI
https://www.kaggle.com/competitions - Conjuntos de datos de Kaggle
MLdata.org - MLdata.org
Tendencias de Google --http: / / www. Google. Com / tendencias / explorar.
El CIA World Factbook - https: // www. cia. gobierno / biblioteca / publicaciones / the-world-factbook /
Ver también
Repositorio de aprendizaje automático UCI: esta es una extensa biblioteca con
funcionalidad de búsqueda . Al momento de escribir, había más de 350 conjuntos de datos. Puede hacer
clic en el archivo https: //. ics uci. edu / ml / índice. Enlace HTML para ver todos los
conjuntos de datos o buscar un conjunto específico mediante una búsqueda simple (Ctrl + F).
Conjuntos de datos de Kaggle: debe crear una cuenta, pero puede descargar cualquier conjunto para
aprender y competir en competencias de aprendizaje automático. El
https: // www. kaggle El enlace com / competiciones proporciona detalles para explorar y
aprender más sobre Kaggle y el funcionamiento interno de las
competencias de aprendizaje automático .
MLdata.org: un sitio público abierto a todos con un repositorio de conjuntos de datos para máquina
entusiastas del aprendizaje.
Tendencias de Google: puede encontrar estadísticas sobre el volumen de búsqueda (como proporción de la
búsqueda total ) para cualquier término dado desde 2004 en http: / / www. Google. Com / tendencias /
explorar.
El World Factbook de la CIA:
https: // www. cia. gov / library / collections / the-world-factbook / link
proporciona información sobre la historia, la población, la economía, el gobierno, la
infraestructura y el ejército de 267 países.
Otras fuentes de datos de aprendizaje automático:
datos de spam de SMS: http: // www. dt. cuota. unicamp br / ~ tiago / smsspamcollection / Conjunto
de datos financieros de Lending Club
https: // www. club de prestamistas com / info / download-data. acción
Datos de investigación de Yahoo http: // webscope. salvadera. Yahoo. com / index. php
conjunto de datos públicos de Amazon AWS http: // aws. Amazonas. com / public-data-sets /
Datos visuales etiquetados de Image Net http: // www. imagen-net. org Conjuntos de
datos censales http: // www. censo. gov
Compilado conjunto de datos de YouTube http: // netsg. cs. sfu ca / youtubedata /
Datos de calificación recopilados del sitio MovieLens
http: // grouplens. org / datasets / movielens /
Enron dataset disponible para el público http: // www. cs. cmu. edu / ~ enron /
Dataset para los elementos clásicos del libro del aprendizaje estadístico
http: // statweb. Stanford edu / ~ tibs / ElemStatLearn / data. Conjunto de
datos de película htmlIMDB http: // www. imdb com / interfaces
Million Song dataset http: // labrosa. ee. Columbia. edu / millionsong /
Conjunto de datos para voz y audio http: // labrosa. ee. Columbia. edu / projects /
Datos de reconocimiento facial http: // www. face-rec. org / bases de datos /
Datos de ciencias sociales http: // www. icpsr. umich. edu / icpsrweb / ICPSR / studies Conjuntos de
datos masivos de la Universidad de Cornell http: // arxiv. org / help / bulk_data_s3 Conjuntos de
datos del proyecto Guttenberg
http: // www. Gutenberg. org / wiki / Gutenberg: Offline_Catalogs
Conjuntos de datos del Banco Mundial http: // data. Banco Mundial. org
Base de datos léxica de World Net http: // wordnet. princeton edu
Datos de colisión de NYPD http: // nypd. Opencrape. com / # /
Dataset para llamadas de fila del Congreso y otras http: // voteview. com / dwnl. htm
Grandes conjuntos de datos gráficos de Stanford
http: // snap. Stanford edu / data / index. html
Conjunto rico de datos de datahub https: // datahub. io / dataset
Conjunto de datos académicos de Yelp https: // www. gañido. com / academic_dataset
Fuente de datos de GitHub
https: // github. com / caesar0301 / awesome-public-datasets
Archivos de conjuntos de datos de Reddit https: // www. reddit com / r / datasets /
Existen algunos conjuntos de datos especializados (por ejemplo, análisis de texto en español y
datos genéticos y del FMI) que pueden ser de su interés:
Conjuntos de datos de Colombia (en español):
http: // www. datos. gobernador co / frm / buscador / frmBuscador. aspx
Dataset de estudios de cáncer
http: // www. Broadinstitute. org / cgi-bin / cancer / datasets. cgi
Datos de investigación de Pew http: // www. Pewinternet. org / datasets /
Datos del estado de Illinois / EE. UU. https: // data. Illinois. gov
Datos de freebase.com http: // www. base libre. com
Conjuntos de datos de la ONU y sus agencias asociadas http: // data. Naciones Unidas. org
Conjuntos de datos del Fondo Monetario Internacional http: // www. imf. org / external / data. htm
Datos del gobierno del Reino Unido https: // data. gobernador Reino Unido
Datos abiertos de Estonia
http: // pub. stat. ee / px-web. 2001 / Diálogo / archivo de estadísticas 1. asp
Muchas bibliotecas ML en R que contienen datos que pueden exportarse como CSV
https: // www. proyecto-r. org
Conjuntos de datos de expresión génica http: // www. ncbi. nlm. nih gov / geo /
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.2</version>
</dependency>
<!--spark-mllib-->
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-mllib_2.11</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>org.jfree</groupId>
<artifactId>jfreechart</artifactId>
<version>1.5.0</version>
</dependency>
</dependencies>
import org.apache.log4j.Logger
import org.apache.log4j.Level
import org.apache.spark.sql.SparkSession
object MyFirstSpark20 {
def main(args: Array[String]): Unit = {
Logger.getLogger("org").setLevel(Level.ERROR)
val session: SparkSession = SparkSession.builder().master("local[*]").appName("myFirstSpark20").config("spark.sql.warehouse.dir", ".")
.getOrCreate()
session
val x = Array(1.0,5.0,8.0,10.0,15.0,21.0,27.0,30.0,38.0,45.0,50.0,64.0)
val y = Array(5.0,1.0,4.0,11.0,25.0,18.0,33.0,20.0,30.0,43.0,55.0,57.0)
val xRDD = session.sparkContext.parallelize(x)
val yRDD = session.sparkContext.parallelize(y)
val zipRdd = xRDD.zip(yRDD)
for (elem <- zipRdd.collect()) {
println(elem)
}
val xSum: Double = xRDD.sum()
val ySum: Double=yRDD.sum()
val sumRdd = zipRdd.map(item=>item._1*item._2).sum
val sumCount = zipRdd.count()
println(xSum)
println(ySum)
println(sumRdd)
println(sumCount)
session.stop()
}
}
import java.awt.Color
import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.SparkSession
import org.jfree.chart.plot.{PlotOrientation, XYPlot}
import org.jfree.chart.{ChartFactory, ChartFrame, JFreeChart}
import org.jfree.data.xy.{XYSeries, XYSeriesCollection}
import scala.util.Random
object MyChart {
def show(chart: JFreeChart) {
val frame = new ChartFrame("plot", chart)
frame.pack()
frame.setVisible(true)
}
def configurePlot(plot: XYPlot): Unit = {
plot.setBackgroundPaint(Color.WHITE)
plot.setDomainGridlinePaint(Color.BLACK)
plot.setRangeGridlinePaint(Color.BLACK)
plot.setOutlineVisible(false)
}
def main(args: Array[String]): Unit = {
Logger.getLogger("org").setLevel(Level.ERROR)
// setup SparkSession to use for interactions with Spark
val spark = SparkSession
.builder
.master("local[*]")
.appName("myChart")
.config("spark.sql.warehouse.dir", ".")
.getOrCreate()
val data = spark.sparkContext.parallelize(Random.shuffle(1 to 15).zipWithIndex)
data.foreach(println)
val xy = new XYSeries("")
data.collect().foreach{ case (y: Int, x: Int) => xy.add(x,y) }
val dataset = new XYSeriesCollection(xy)
val chart = ChartFactory.createXYLineChart(
"MyChart", // chart title
"x", // x axis label
"y", // y axis label
dataset, // data
PlotOrientation.VERTICAL,
false, // include legend
true, // tooltips
false // urls
)
val plot = chart.getXYPlot()
configurePlot(plot)
show(chart)
spark.stop()
}
}
