| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
jueves, 17 de mayo de 2018
Vue Mastery
Quiero compartir este mail sobre la pagina Vue Mastery dado que hay muchos recursos del framework Vue.js, y nada más ...
martes, 15 de mayo de 2018
Machine Learning Yearning
Como les conté en un post anterior. Andrew Ng esta sacando un libro sobre machine learning.
Me llego otro mail del amigo Andrew Ng sobre su nuevo libro:
Me llego otro mail del amigo Andrew Ng sobre su nuevo libro:
| ||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||
|
domingo, 13 de mayo de 2018
Dstream
Dstream es la abstracción básica en Spark Streaming y representa una stream continuo de datos.
DStream se puede crear a partir de flujos de datos de entrada procedentes de fuentes como Kafka, Flume y Kinesis, o aplicando operaciones en otros DStream. Internamente, un DStream se representa como una secuencia de objetos RDD.
Similar a RDD el DStream soporta:
- map
- flatMap
- filter
- count
- reduce
- countByValue
- reduceByKey
- join
- updateStateByKey
jueves, 10 de mayo de 2018
Apache Spark Streaming
Con el procesamiento de datos en streaming podemos analizar los datos en tiempo real, lo cual es muy útil en muchas situaciones. Apache Spark provee una librería para procesar streaming, que como no era necesarío un nombre difícil o original lo bautizaron Apache Spark Streaming.
El procesamiento de streaming se utiliza para analizar información que viene de sensores, iot, busquedas, logs de paginas web, el trafico a servidores, etc. Ejemplos de su uso podrian ser: monitorización de servidores o del comportamiento de usuarios en paginas web, etc.
Spark Streaming es una extensión de Apache Spark API y como ya digimos Apache Spark Streaming hace facil la creación de procesos tolerante a fallos para procesar información en tiempo real.
Desde la versión 2.0, Spark streaming soporta una nueva librería de streaming llamada
Structured Streaming, el cual ofrece un procesamiento de streaming escalable y tolerante a fallos basado en Spark SQL. Podemos utilizar dataset and la Api de dataframe en Scala, Java, Python o R para escribir agregaciones de streamings. Structured Streaming provee un camino para el procesamiento sin que tengamos que razonar mucho sobre el procesamiento.
Spark Streaming funciona dividiendo la transmisión en pequeñas porciones de datos (llamados micro-batches) en un intervalo predefinido (N segundos) y luego convierte cada micro-batch en un RDD. Nosotros podemos procesar estos RDD con las operaciones : map , reduce , reduceByKey , join , y window. Los resultados de estas operaciones RDD se devuelven en lotes. Por lo general, almacenamos estos resultados en un almacén de datos para un análisis posterior, para generar informes, o para enviar alertas basadas en eventos.
Es importante configurar correctamente el intervalo de tiempo para Spark Streaming, en función del caso de uso y los requisitos de procesamiento de datos. Si el valor de N es demasiado bajo, entonces los micropaquetes no tendrán suficientes datos para dar resultados significativos durante el análisis.
Los datos de streaming pueden ser procesados desde diferentes fuentes :
- Kafka,
- Flume,
- Twitter,
- ZeroMQ,
- Amazon’s Kinesis, and
- TCP sockets
martes, 8 de mayo de 2018
UNION vs UNION ALL
Principalmente el problema es que ambos tienen funcionalidades distintas. El UNION y el UNION ALL parecen funcionar igual pero tienen una pequeña diferencia. El UNION descarta los resultados en común entre los dos SELECT, en cambio, el UNION ALL no hace ningún tipo de verificación.
Por este motivo, el UNION ALL es más eficiente que el UNION.
Si sabemos que las 2 consultas a unir no van a tener repetidos es buena práctica usar el UNION ALL
LAG y LEAD en Oracle
Estas dos funciones “LAG y LEAD” lo permiten sin tener que realizar una self join.
LAG() devuelve el valor de la anterior fila y LEAD() el valor de la siguiente fila.
SELECT DNI,
LEAD(DNI) OVER (ORDER BY DNI) POSTERIOR,
LAG(DNI) OVER (ORDER BY DNI) ANTERIOR
FROM PRUEBA;
DNI POSTERIOR ANTERIOR
0001 0002
0002 0003 0001
0003 0004 0002
0004 0005 0003
0005 0006 0004
0006 0007 0005
domingo, 6 de mayo de 2018
Probando Ubuntu Budgie 18
A mi entender la mejor característica es la librería de aplicaciones snap. Podemos instalar con un solo click : Spotify, Slack, Skype, Telegram, Steam, y hasta el mismo tema de la comunidad que cambia la apariencia por una más moderna, pueden instalarse de la forma más sencilla posible.
Un sabor nuevo es Ubuntu Budgie que es una distribución oficial del proyecto Ubuntu, que utiliza el entorno de escritorio Budgie, basado en GNOME. Esta distribución ofrece una interfaz sencilla y fluida, que tiene un bajo consumo de recursos.
Y me sentí obligado a probarla:
Dejo video:
Dejo link: https://ubuntubudgie.org/
Ejemplo de Apache Spark Sql - parte 2
El siguiente ejemplo de código muestra cómo especificar el esquema utilizando las clases de tipo de datos StructType, StringType y StructField.
//
// Programmatically Specifying the Schema
//
// Create SQLContext from the existing SparkContext.
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
// Create an RDD
val rddCustomers = sc.textFile(“/home/emanuel/eje.csv”)
// The schema is encoded in a string
val schemaString = “customer_id name city state zip_code”
// Import Spark SQL data types and Row.
import org.apache.spark.sql._
import org.apache.spark.sql.types._;
// Generate the schema based on the string of schema
val schema = StructType(schemaString.split(“ “).map(fieldName => StructField(fieldName, StringType, true)))
// Convert records of the RDD (rddCustomers) to Rows.
val rowRDD = rddCustomers.map(_.split(“,”)).map(p => Row(p(0).trim,p(1),p(2),p(3),p(4)))
// Apply the schema to the RDD.
val dfCustomers = sqlContext.createDataFrame(rowRDD, schema)
// Register the DataFrames as a table.
dfCustomers.registerTempTable(“customers”)
// SQL statements can be run by using the sql methodsprovided by sqlContext.
val custNames = sqlContext.sql(“SELECT name FROM customers”)
// The results of SQL queries are DataFrames and support all the normal RDD operations.
// The columns of a row in the result can be accessed by ordinal.
custNames.map(t => “Name: “ + t(0)).collect().foreach(println)
// SQL statements can be run by using the sql methods provided by sqlContext.
val customersByCity = sqlContext.sql(“SELECT name,zip_code FROM customers ORDER BY zip_code”)
// The results of SQL queries are DataFrames and support all the normal RDD operations.
// The columns of a row in the result can be accessed by ordinal.
customersByCity.map(t => t(0) + “,” + t(1)).collect().
foreach(println)
También podemos cargar los datos de otras fuentes de datos como archivos de datos JSON, tablas Hive o incluso tablas de bases de datos relacionales que utilizan la fuente de datos JDBC.
Spark SQL proporciona una agradable interfaz SQL para interactuar con datos que se cargan desde diversas fuentes de datos, utilizando la conocida sintaxis de consulta SQL.
Esto es especialmente útil para miembros de proyectos no técnicos, como analistas de datos y DBA.
Ejemplo de Apache Spark Sql
Para este ejemplo, cargaremos datos de clientes de un archivo de texto y crearemos un objeto DataFrame a partir del conjunto de datos. Entonces podemos ejecutar las funciones de DataFrame como consultas específicas para seleccionar los datos.
Veamos el archivo customers.txt.
100,John Smith, Austin, TX, 78727
200,Joe Johnson, Dallas, TX, 75201
300,Bob Jones, Houston, TX, 77028
400,Andy Davis, San Antonio, TX, 78227
500,James Williams, Austin, TX, 78727
El siguiente código muestra los comandos Spark SQL que podemos ejecutar en la consola del shell Spark.
// Create the SQLContext first from the existing Spark Context
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
// Import statement to implicitly convert an RDD to a DataFrame
import sqlContext.implicits._
// Create a custom class to represent the Customer
case class Customer(customer_id: Int, name: String, city: String, state: String, zip_code: String)
// Create a DataFrame of Customer objects from the data set text file.
val dfCustomers = sc.textFile(“/home/emanuel/eje.csv”).map(_.split(“,”)).map(p => Customer(p(0).trim.toInt, p(1), p(2), p(3), p(4))).toDF()
// Register DataFrame as a table.
dfCustomers.registerTempTable(“customers”)
// Display the content of DataFrame
dfCustomers.show()
// Print the DF schema
dfCustomers.printSchema()
// Select customer name column
dfCustomers.select(“name”).show()
// Select customer name and city columns
dfCustomers.select(“name”, “city”).show()
// Select a customer by id
dfCustomers.filter(dfCustomers(“customer_id”).equalTo(500)).show()
// Count the customers by zip code
dfCustomers.groupBy(“zip_code”).count().show()
Veamos el archivo customers.txt.
100,John Smith, Austin, TX, 78727
200,Joe Johnson, Dallas, TX, 75201
300,Bob Jones, Houston, TX, 77028
400,Andy Davis, San Antonio, TX, 78227
500,James Williams, Austin, TX, 78727
El siguiente código muestra los comandos Spark SQL que podemos ejecutar en la consola del shell Spark.
// Create the SQLContext first from the existing Spark Context
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
// Import statement to implicitly convert an RDD to a DataFrame
import sqlContext.implicits._
// Create a custom class to represent the Customer
case class Customer(customer_id: Int, name: String, city: String, state: String, zip_code: String)
// Create a DataFrame of Customer objects from the data set text file.
val dfCustomers = sc.textFile(“/home/emanuel/eje.csv”).map(_.split(“,”)).map(p => Customer(p(0).trim.toInt, p(1), p(2), p(3), p(4))).toDF()
// Register DataFrame as a table.
dfCustomers.registerTempTable(“customers”)
// Display the content of DataFrame
dfCustomers.show()
// Print the DF schema
dfCustomers.printSchema()
// Select customer name column
dfCustomers.select(“name”).show()
// Select customer name and city columns
dfCustomers.select(“name”, “city”).show()
// Select a customer by id
dfCustomers.filter(dfCustomers(“customer_id”).equalTo(500)).show()
// Count the customers by zip code
dfCustomers.groupBy(“zip_code”).count().show()
Apache Spark Sql - JDBC Data Source
Spark sql contiene un origen de datos jdbc. Con él podemos leer una base de datos relacional. Este enfoque es preferible al uso de JdbcRDD porque el origen de datos devuelve los resultados como un DataFrame que puede procesarse en Spark SQL o mezclarse con datos de otras fuentes de datos.
Veamos un ejemplo:
import org.apache.spark.sql.SQLContext
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
val url = "jdbc:mysql://127.0.0.1:3306/amarokdb"
val df = spark.read.format("jdbc").option("url", url).option("dbtable", "albums").option("user", "root").option("password","pass").load()
df.printSchema() // Looks the schema of this DataFrame.
df.show()
df.count()
jueves, 3 de mayo de 2018
Apache Spark Sql
Como habíamos dicho en un ambiente Spark SQL, los 2 componentes más importantes son el DataFrame y el SQLContext.
DataFrame: Un dataframe es una colección de datos distribuida organizada dentro de nombres de columnas. Esto basado en el concepto de dataframe del Lenguaje R y similar al concepto de tablas de las base de datos relacionales.
SchemaRDD, que se encuentra en versiones anteriores de Spark SQL API y se ha renombrado como DataFrame.
DataFrames puede ser convertido en un RDDs, por medio de un método de RDD, el RDD resultante tiene las filas del DataFrames.
Los DataFrames pueden ser creados dados los siguientes origenes de datos:
- RDDs existentes
- un archivo estructurado
- un Json
- una tabla HIVE
- y una base de datos externa.
Spark SQL y DataFrame APIs esta disponible en Scala, Java, Python y R.
Además de DataFrame, Spark también proporciona la API Dataset. Un Dataset es una colección distribuida de datos similar a los RDD pero que utiliza un codificador para serializar los objetos. La API Dataset está disponible en Scala y Java. Spark SQL admite métodos para convertir RDD existentes en conjuntos de datos.
SQLContext: Spark SQL proporciona SQLContext para encapsular toda la funcionalidad relacional en Spark. Se crea el SQLContext a partir del SparkContext existente, veamos un ejemplo:
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
También hay HiveContext, que proporciona un superconjunto de la funcionalidad proporcionada por SQLContext. Se puede usar para escribir consultas usando el analizador HiveQL y para leer datos de tablas de Hive.
Notemos que no necesitamos un entorno Hive existente para usar HiveContext en los programas Spark.
Suscribirse a:
Entradas (Atom)
