The document provides an agenda for a DevOps advanced class on Spark being held in June 2015. The class will cover topics such as RDD fundamentals, Spark runtime architecture, memory and persistence, Spark SQL, PySpark, and Spark Streaming. It will include labs on DevOps 101 and 102. The instructor has over 5 years of experience providing Big Data consulting and training, including over 100 classes taught.
Apache Spark in Depth: Core Concepts, Architecture & InternalsAnton Kirillov
Slides cover Spark core concepts of Apache Spark such as RDD, DAG, execution workflow, forming stages of tasks and shuffle implementation and also describes architecture and main components of Spark Driver. The workshop part covers Spark execution modes , provides link to github repo which contains Spark Applications examples and dockerized Hadoop environment to experiment with
Apache Spark presentation at HasGeek FifthElelephant
https://fifthelephant.talkfunnel.com/2015/15-processing-large-data-with-apache-spark
Covering Big Data Overview, Spark Overview, Spark Internals and its supported libraries
Scaling Data Analytics Workloads on DatabricksDatabricks
Imagine an organization with thousands of users who want to run data analytics workloads. These users shouldn’t have to worry about provisioning instances from a cloud provider, deploying a runtime processing engine, scaling resources based on utilization, or ensuring their data is secure. Nor should the organization’s system administrators.
In this talk we will highlight some of the exciting problems we’re working on at Databricks in order to meet the demands of organizations that are analyzing data at scale. In particular, data engineers attending this session will walk away with learning how we:
Manage a typical query lifetime through the Databricks software stack
Dynamically allocate resources to satisfy the elastic demands of a single cluster
Isolate the data and the generated state within a large organization with multiple clusters
"The common use cases of Spark SQL include ad hoc analysis, logical warehouse, query federation, and ETL processing. Spark SQL also powers the other Spark libraries, including structured streaming for stream processing, MLlib for machine learning, and GraphFrame for graph-parallel computation. For boosting the speed of your Spark applications, you can perform the optimization efforts on the queries prior employing to the production systems. Spark query plans and Spark UIs provide you insight on the performance of your queries. This talk discloses how to read and tune the query plans for enhanced performance. It will also cover the major related features in the recent and upcoming releases of Apache Spark.
"
Deep Dive: Memory Management in Apache SparkDatabricks
Memory management is at the heart of any data-intensive system. Spark, in particular, must arbitrate memory allocation between two main use cases: buffering intermediate data for processing (execution) and caching user data (storage). This talk will take a deep dive through the memory management designs adopted in Spark since its inception and discuss their performance and usability implications for the end user.
Introduction to Amazon EMR design patterns such as using Amazon S3 instead of HDFS, taking advantage of Spot EC2 instances to reduce costs, and other Amazon EMR architectural best practices.
A Deep Dive into Spark SQL's Catalyst Optimizer with Yin HuaiDatabricks
Catalyst is becoming one of the most important components of Apache Spark, as it underpins all the major new APIs in Spark 2.0 and later versions, from DataFrames and Datasets to Streaming. At its core, Catalyst is a general library for manipulating trees.
In this talk, Yin explores a modular compiler frontend for Spark based on this library that includes a query analyzer, optimizer, and an execution planner. Yin offers a deep dive into Spark SQL’s Catalyst optimizer, introducing the core concepts of Catalyst and demonstrating how developers can extend it. You’ll leave with a deeper understanding of how Spark analyzes, optimizes, and plans a user’s query.
Apache Spark in Depth: Core Concepts, Architecture & InternalsAnton Kirillov
Slides cover Spark core concepts of Apache Spark such as RDD, DAG, execution workflow, forming stages of tasks and shuffle implementation and also describes architecture and main components of Spark Driver. The workshop part covers Spark execution modes , provides link to github repo which contains Spark Applications examples and dockerized Hadoop environment to experiment with
Apache Spark presentation at HasGeek FifthElelephant
https://fifthelephant.talkfunnel.com/2015/15-processing-large-data-with-apache-spark
Covering Big Data Overview, Spark Overview, Spark Internals and its supported libraries
Scaling Data Analytics Workloads on DatabricksDatabricks
Imagine an organization with thousands of users who want to run data analytics workloads. These users shouldn’t have to worry about provisioning instances from a cloud provider, deploying a runtime processing engine, scaling resources based on utilization, or ensuring their data is secure. Nor should the organization’s system administrators.
In this talk we will highlight some of the exciting problems we’re working on at Databricks in order to meet the demands of organizations that are analyzing data at scale. In particular, data engineers attending this session will walk away with learning how we:
Manage a typical query lifetime through the Databricks software stack
Dynamically allocate resources to satisfy the elastic demands of a single cluster
Isolate the data and the generated state within a large organization with multiple clusters
"The common use cases of Spark SQL include ad hoc analysis, logical warehouse, query federation, and ETL processing. Spark SQL also powers the other Spark libraries, including structured streaming for stream processing, MLlib for machine learning, and GraphFrame for graph-parallel computation. For boosting the speed of your Spark applications, you can perform the optimization efforts on the queries prior employing to the production systems. Spark query plans and Spark UIs provide you insight on the performance of your queries. This talk discloses how to read and tune the query plans for enhanced performance. It will also cover the major related features in the recent and upcoming releases of Apache Spark.
"
Deep Dive: Memory Management in Apache SparkDatabricks
Memory management is at the heart of any data-intensive system. Spark, in particular, must arbitrate memory allocation between two main use cases: buffering intermediate data for processing (execution) and caching user data (storage). This talk will take a deep dive through the memory management designs adopted in Spark since its inception and discuss their performance and usability implications for the end user.
Introduction to Amazon EMR design patterns such as using Amazon S3 instead of HDFS, taking advantage of Spot EC2 instances to reduce costs, and other Amazon EMR architectural best practices.
A Deep Dive into Spark SQL's Catalyst Optimizer with Yin HuaiDatabricks
Catalyst is becoming one of the most important components of Apache Spark, as it underpins all the major new APIs in Spark 2.0 and later versions, from DataFrames and Datasets to Streaming. At its core, Catalyst is a general library for manipulating trees.
In this talk, Yin explores a modular compiler frontend for Spark based on this library that includes a query analyzer, optimizer, and an execution planner. Yin offers a deep dive into Spark SQL’s Catalyst optimizer, introducing the core concepts of Catalyst and demonstrating how developers can extend it. You’ll leave with a deeper understanding of how Spark analyzes, optimizes, and plans a user’s query.
Spark + Parquet In Depth: Spark Summit East Talk by Emily Curtin and Robbie S...Spark Summit
What if you could get the simplicity, convenience, interoperability, and storage niceties of an old-fashioned CSV with the speed of a NoSQL database and the storage requirements of a gzipped file? Enter Parquet.
At The Weather Company, Parquet files are a quietly awesome and deeply integral part of our Spark-driven analytics workflow. Using Spark + Parquet, we’ve built a blazing fast, storage-efficient, query-efficient data lake and a suite of tools to accompany it.
We will give a technical overview of how Parquet works and how recent improvements from Tungsten enable SparkSQL to take advantage of this design to provide fast queries by overcoming two major bottlenecks of distributed analytics: communication costs (IO bound) and data decoding (CPU bound).
Memory management is at the heart of any data-intensive system. Spark, in particular, must arbitrate memory allocation between two main use cases: buffering intermediate data for processing (execution) and caching user data (storage). This talk will take a deep dive through the memory management designs adopted in Spark since its inception and discuss their performance and usability implications for the end user.
A Deep Dive into Query Execution Engine of Spark SQLDatabricks
Spark SQL enables Spark to perform efficient and fault-tolerant relational query processing with analytics database technologies. The relational queries are compiled to the executable physical plans consisting of transformations and actions on RDDs with the generated Java code. The code is compiled to Java bytecode, executed at runtime by JVM and optimized by JIT to native machine code at runtime. This talk will take a deep dive into Spark SQL execution engine. The talk includes pipelined execution, whole-stage code generation, UDF execution, memory management, vectorized readers, lineage based RDD transformation and action.
Pyspark Tutorial | Introduction to Apache Spark with Python | PySpark Trainin...Edureka!
** PySpark Certification Training: https://www.edureka.co/pyspark-certification-training**
This Edureka tutorial on PySpark Tutorial will provide you with a detailed and comprehensive knowledge of Pyspark, how it works, the reason why python works best with Apache Spark. You will also learn about RDDs, data frames and mllib.
This slide deck is used as an introduction to the internals of Apache Spark, as part of the Distributed Systems and Cloud Computing course I hold at Eurecom.
Course website:
http://michiard.github.io/DISC-CLOUD-COURSE/
Sources available here:
https://github.com/michiard/DISC-CLOUD-COURSE
Operating and Supporting Delta Lake in ProductionDatabricks
Delta lake is widely adopted. There are things to be aware of when dealing with petabytes of data in Delta Lake. These smart decisions can give the best efficiency and increase the adoption of Delta. Best practices like OPTIMIZE, ZORDER have to wisely chosen. We have support stories where we successfully resolved performance issues by applying the right performance strategy. There are a set of common issues or repeated questions from our strategic customers face when using Delta and in this session we cover them and how to address them.
(BDT318) How Netflix Handles Up To 8 Million Events Per SecondAmazon Web Services
In this session, Netflix provides an overview of Keystone, their new data pipeline. The session covers how Netflix migrated from Suro to Keystone, including the reasons behind the transition and the challenges of zero loss while processing over 400 billion events daily. The session covers in detail how they deploy, operate, and scale Kafka, Samza, Docker, and Apache Mesos in AWS to manage 8 million events & 17 GB per second during peak.
In Spark SQL the physical plan provides the fundamental information about the execution of the query. The objective of this talk is to convey understanding and familiarity of query plans in Spark SQL, and use that knowledge to achieve better performance of Apache Spark queries. We will walk you through the most common operators you might find in the query plan and explain some relevant information that can be useful in order to understand some details about the execution. If you understand the query plan, you can look for the weak spot and try to rewrite the query to achieve a more optimal plan that leads to more efficient execution.
The main content of this talk is based on Spark source code but it will reflect some real-life queries that we run while processing data. We will show some examples of query plans and explain how to interpret them and what information can be taken from them. We will also describe what is happening under the hood when the plan is generated focusing mainly on the phase of physical planning. In general, in this talk we want to share what we have learned from both Spark source code and real-life queries that we run in our daily data processing.
Tuning Apache Spark for Large-Scale Workloads Gaoxiang Liu and Sital KediaDatabricks
Apache Spark is a fast and flexible compute engine for a variety of diverse workloads. Optimizing performance for different applications often requires an understanding of Spark internals and can be challenging for Spark application developers. In this session, learn how Facebook tunes Spark to run large-scale workloads reliably and efficiently. The speakers will begin by explaining the various tools and techniques they use to discover performance bottlenecks in Spark jobs. Next, you’ll hear about important configuration parameters and their experiments tuning these parameters on large-scale production workload. You’ll also learn about Facebook’s new efforts towards automatically tuning several important configurations based on nature of the workload. The speakers will conclude by sharing their results with automatic tuning and future directions for the project.ing several important configurations based on nature of the workload. We will conclude by sharing our result with automatic tuning and future directions for the project.
Coral & Transport UDFs: Building Blocks of a Postmodern Data WarehouseWalaa Eldin Moustafa
These slides describe LinkedIn efforts in building a view virtualization layer that enables compute engines to access Hive views, reason about them semantically, and optionally rewrite them before presenting to various compute engines such as Spark, Hive, and Presto. Namely, we describe two frameworks: Coral for reasoning about views using their logical plans, and Transport UDFs for reasoning about UDFs.
Dynamic Partition Pruning in Apache SparkDatabricks
In data analytics frameworks such as Spark it is important to detect and avoid scanning data that is irrelevant to the executed query, an optimization which is known as partition pruning. Dynamic partition pruning occurs when the optimizer is unable to identify at parse time the partitions it has to eliminate. In particular, we consider a star schema which consists of one or multiple fact tables referencing any number of dimension tables. In such join operations, we can prune the partitions the join reads from a fact table by identifying those partitions that result from filtering the dimension tables. In this talk we present a mechanism for performing dynamic partition pruning at runtime by reusing the dimension table broadcast results in hash joins and we show significant improvements for most TPCDS queries.
Tiny Batches, in the wine: Shiny New Bits in Spark StreamingPaco Nathan
London Spark Meetup 2014-11-11 @Skimlinks
http://www.meetup.com/Spark-London/events/217362972/
To paraphrase the immortal crooner Don Ho: "Tiny Batches, in the wine, make me happy, make me feel fine." http://youtu.be/mlCiDEXuxxA
Apache Spark provides support for streaming use cases, such as real-time analytics on log files, by leveraging a model called discretized streams (D-Streams). These "micro batch" computations operated on small time intervals, generally from 500 milliseconds up. One major innovation of Spark Streaming is that it leverages a unified engine. In other words, the same business logic can be used across multiple uses cases: streaming, but also interactive, iterative, machine learning, etc.
This talk will compare case studies for production deployments of Spark Streaming, emerging design patterns for integration with popular complementary OSS frameworks, plus some of the more advanced features such as approximation algorithms, and take a look at what's ahead — including the new Python support for Spark Streaming that will be in the upcoming 1.2 release.
Also, let's chat a bit about the new Databricks + O'Reilly developer certification for Apache Spark…
Spark + Parquet In Depth: Spark Summit East Talk by Emily Curtin and Robbie S...Spark Summit
What if you could get the simplicity, convenience, interoperability, and storage niceties of an old-fashioned CSV with the speed of a NoSQL database and the storage requirements of a gzipped file? Enter Parquet.
At The Weather Company, Parquet files are a quietly awesome and deeply integral part of our Spark-driven analytics workflow. Using Spark + Parquet, we’ve built a blazing fast, storage-efficient, query-efficient data lake and a suite of tools to accompany it.
We will give a technical overview of how Parquet works and how recent improvements from Tungsten enable SparkSQL to take advantage of this design to provide fast queries by overcoming two major bottlenecks of distributed analytics: communication costs (IO bound) and data decoding (CPU bound).
Memory management is at the heart of any data-intensive system. Spark, in particular, must arbitrate memory allocation between two main use cases: buffering intermediate data for processing (execution) and caching user data (storage). This talk will take a deep dive through the memory management designs adopted in Spark since its inception and discuss their performance and usability implications for the end user.
A Deep Dive into Query Execution Engine of Spark SQLDatabricks
Spark SQL enables Spark to perform efficient and fault-tolerant relational query processing with analytics database technologies. The relational queries are compiled to the executable physical plans consisting of transformations and actions on RDDs with the generated Java code. The code is compiled to Java bytecode, executed at runtime by JVM and optimized by JIT to native machine code at runtime. This talk will take a deep dive into Spark SQL execution engine. The talk includes pipelined execution, whole-stage code generation, UDF execution, memory management, vectorized readers, lineage based RDD transformation and action.
Pyspark Tutorial | Introduction to Apache Spark with Python | PySpark Trainin...Edureka!
** PySpark Certification Training: https://www.edureka.co/pyspark-certification-training**
This Edureka tutorial on PySpark Tutorial will provide you with a detailed and comprehensive knowledge of Pyspark, how it works, the reason why python works best with Apache Spark. You will also learn about RDDs, data frames and mllib.
This slide deck is used as an introduction to the internals of Apache Spark, as part of the Distributed Systems and Cloud Computing course I hold at Eurecom.
Course website:
http://michiard.github.io/DISC-CLOUD-COURSE/
Sources available here:
https://github.com/michiard/DISC-CLOUD-COURSE
Operating and Supporting Delta Lake in ProductionDatabricks
Delta lake is widely adopted. There are things to be aware of when dealing with petabytes of data in Delta Lake. These smart decisions can give the best efficiency and increase the adoption of Delta. Best practices like OPTIMIZE, ZORDER have to wisely chosen. We have support stories where we successfully resolved performance issues by applying the right performance strategy. There are a set of common issues or repeated questions from our strategic customers face when using Delta and in this session we cover them and how to address them.
(BDT318) How Netflix Handles Up To 8 Million Events Per SecondAmazon Web Services
In this session, Netflix provides an overview of Keystone, their new data pipeline. The session covers how Netflix migrated from Suro to Keystone, including the reasons behind the transition and the challenges of zero loss while processing over 400 billion events daily. The session covers in detail how they deploy, operate, and scale Kafka, Samza, Docker, and Apache Mesos in AWS to manage 8 million events & 17 GB per second during peak.
In Spark SQL the physical plan provides the fundamental information about the execution of the query. The objective of this talk is to convey understanding and familiarity of query plans in Spark SQL, and use that knowledge to achieve better performance of Apache Spark queries. We will walk you through the most common operators you might find in the query plan and explain some relevant information that can be useful in order to understand some details about the execution. If you understand the query plan, you can look for the weak spot and try to rewrite the query to achieve a more optimal plan that leads to more efficient execution.
The main content of this talk is based on Spark source code but it will reflect some real-life queries that we run while processing data. We will show some examples of query plans and explain how to interpret them and what information can be taken from them. We will also describe what is happening under the hood when the plan is generated focusing mainly on the phase of physical planning. In general, in this talk we want to share what we have learned from both Spark source code and real-life queries that we run in our daily data processing.
Tuning Apache Spark for Large-Scale Workloads Gaoxiang Liu and Sital KediaDatabricks
Apache Spark is a fast and flexible compute engine for a variety of diverse workloads. Optimizing performance for different applications often requires an understanding of Spark internals and can be challenging for Spark application developers. In this session, learn how Facebook tunes Spark to run large-scale workloads reliably and efficiently. The speakers will begin by explaining the various tools and techniques they use to discover performance bottlenecks in Spark jobs. Next, you’ll hear about important configuration parameters and their experiments tuning these parameters on large-scale production workload. You’ll also learn about Facebook’s new efforts towards automatically tuning several important configurations based on nature of the workload. The speakers will conclude by sharing their results with automatic tuning and future directions for the project.ing several important configurations based on nature of the workload. We will conclude by sharing our result with automatic tuning and future directions for the project.
Coral & Transport UDFs: Building Blocks of a Postmodern Data WarehouseWalaa Eldin Moustafa
These slides describe LinkedIn efforts in building a view virtualization layer that enables compute engines to access Hive views, reason about them semantically, and optionally rewrite them before presenting to various compute engines such as Spark, Hive, and Presto. Namely, we describe two frameworks: Coral for reasoning about views using their logical plans, and Transport UDFs for reasoning about UDFs.
Dynamic Partition Pruning in Apache SparkDatabricks
In data analytics frameworks such as Spark it is important to detect and avoid scanning data that is irrelevant to the executed query, an optimization which is known as partition pruning. Dynamic partition pruning occurs when the optimizer is unable to identify at parse time the partitions it has to eliminate. In particular, we consider a star schema which consists of one or multiple fact tables referencing any number of dimension tables. In such join operations, we can prune the partitions the join reads from a fact table by identifying those partitions that result from filtering the dimension tables. In this talk we present a mechanism for performing dynamic partition pruning at runtime by reusing the dimension table broadcast results in hash joins and we show significant improvements for most TPCDS queries.
Tiny Batches, in the wine: Shiny New Bits in Spark StreamingPaco Nathan
London Spark Meetup 2014-11-11 @Skimlinks
http://www.meetup.com/Spark-London/events/217362972/
To paraphrase the immortal crooner Don Ho: "Tiny Batches, in the wine, make me happy, make me feel fine." http://youtu.be/mlCiDEXuxxA
Apache Spark provides support for streaming use cases, such as real-time analytics on log files, by leveraging a model called discretized streams (D-Streams). These "micro batch" computations operated on small time intervals, generally from 500 milliseconds up. One major innovation of Spark Streaming is that it leverages a unified engine. In other words, the same business logic can be used across multiple uses cases: streaming, but also interactive, iterative, machine learning, etc.
This talk will compare case studies for production deployments of Spark Streaming, emerging design patterns for integration with popular complementary OSS frameworks, plus some of the more advanced features such as approximation algorithms, and take a look at what's ahead — including the new Python support for Spark Streaming that will be in the upcoming 1.2 release.
Also, let's chat a bit about the new Databricks + O'Reilly developer certification for Apache Spark…
Databricks Meetup @ Los Angeles Apache Spark User GroupPaco Nathan
Los Angeles Apache Spark Users Group 2014-12-11 http://meetup.com/Los-Angeles-Apache-Spark-Users-Group/events/218748643/
A look ahead at Spark Streaming in Spark 1.2 and beyond, with case studies, demos, plus an overview of approximation algorithms that are useful for real-time analytics.
Unified Big Data Processing with Apache SparkC4Media
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1yNuLGF.
Matei Zaharia talks about the latest developments in Spark and shows examples of how it can combine processing algorithms to build rich data pipelines in just a few lines of code. Filmed at qconsf.com.
Matei Zaharia is an assistant professor of computer science at MIT, and CTO of Databricks, the company commercializing Apache Spark.
Architecting an Open Source AI Platform 2018 editionDavid Talby
How to build a scalable AI platform using open source software. The end-to-end architecture covers data integration, interactive queries & visualization, machine learning & deep learning, deploying models to production, and a full 24x7 operations toolset in a high-compliance environment.
Presented at IDEAS SoCal on Oct 20, 2018. I discuss main approaches of deploying data science engines to production and provide sample code for the comprehensive approach of real time scoring with MLeap and Spark ML.
Author: Stefan Papp, Data Architect at “The unbelievable Machine Company“. An overview of Big Data Processing engines with a focus on Apache Spark and Apache Flink, given at a Vienna Data Science Group meeting on 26 January 2017. Following questions are addressed:
• What are big data processing paradigms and how do Spark 1.x/Spark 2.x and Apache Flink solve them?
• When to use batch and when stream processing?
• What is a Lambda-Architecture and a Kappa Architecture?
• What are the best practices for your project?
Deep Learning and Streaming in Apache Spark 2.x with Matei ZahariaDatabricks
2017 continues to be an exciting year for Apache Spark. I will talk about new updates in two major areas in the Spark community this year: stream processing with Structured Streaming, and deep learning with high-level libraries such as Deep Learning Pipelines and TensorFlowOnSpark. In both areas, the community is making powerful new functionality available in the same high-level APIs used in the rest of the Spark ecosystem (e.g., DataFrames and ML Pipelines), and improving both the scalability and ease of use of stream processing and machine learning.
Deep Learning and Streaming in Apache Spark 2.x with Matei ZahariaJen Aman
2017 continues to be an exciting year for Apache Spark. I will talk about new updates in two major areas in the Spark community this year: stream processing with Structured Streaming, and deep learning with high-level libraries such as Deep Learning Pipelines and TensorFlowOnSpark. In both areas, the community is making powerful new functionality available in the same high-level APIs used in the rest of the Spark ecosystem (e.g., DataFrames and ML Pipelines), and improving both the scalability and ease of use of stream processing and machine learning.
My talk at Data Science Labs conference in Odessa.
Training a model in Apache Spark while having it automatically available for real-time serving is an essential feature for end-to-end solutions.
There is an option to export the model into PMML and then import it into a separated scoring engine. The idea of interoperability is great but it has multiple challenges, such as code duplication, limited extensibility, inconsistency, extra moving parts. In this talk we discussed an alternative solution that does not introduce custom model formats and new standards, not based on export/import workflow and shares Apache Spark API.
TDWI Accelerate, Seattle, Oct 16, 2017: Distributed and In-Database Analytics...Debraj GuhaThakurta
Event: TDWI Accelerate, Seattle, Oct 16, 2017
Topic: Distributed and In-Database Analytics with R
Presenter: Debraj GuhaThakurta
Tags: R, Spark, SQL Server
TWDI Accelerate Seattle, Oct 16, 2017: Distributed and In-Database Analytics ...Debraj GuhaThakurta
Event: TDWI Accelerate Seattle, October 16, 2017
Topic: Distributed and In-Database Analytics with R
Presenter: Debraj GuhaThakurta
Description: How to develop scalable and in-DB analytics using R in Spark and SQL-Server
FPGA-Based Acceleration Architecture for Spark SQL Qi Xie and Quanfu Wang Spark Summit
In this session we will present a Configurable FPGA-Based Spark SQL Acceleration Architecture. It is target to leverage FPGA highly parallel computing capability to accelerate Spark SQL Query and for FPGA’s higher power efficiency than CPU we can lower the power consumption at the same time. The Architecture consists of SQL query decomposition algorithms, fine-grained FPGA based Engine Units which perform basic computation of sub string, arithmetic and logic operations. Using SQL query decomposition algorithm, we are able to decompose a complex SQL query into basic operations and according to their patterns each is fed into an Engine Unit. SQL Engine Units are highly configurable and can be chained together to perform complex Spark SQL queries, finally one SQL query is transformed into a Hardware Pipeline. We will present the performance benchmark results comparing the queries with FGPA-Based Spark SQL Acceleration Architecture on XEON E5 and FPGA to the ones with Spark SQL Query on XEON E5 with 10X ~ 100X improvement and we will demonstrate one SQL query workload from a real customer.
VEGAS: The Missing Matplotlib for Scala/Apache Spark with DB Tsai and Roger M...Spark Summit
In this talk, we’ll present techniques for visualizing large scale machine learning systems in Spark. These are techniques that are employed by Netflix to understand and refine the machine learning models behind Netflix’s famous recommender systems that are used to personalize the Netflix experience for their 99 millions members around the world. Essential to these techniques is Vegas, a new OSS Scala library that aims to be the “missing MatPlotLib” for Spark/Scala. We’ll talk about the design of Vegas and its usage in Scala notebooks to visualize Machine Learning Models.
This presentation introduces how we design and implement a real-time processing platform using latest Spark Structured Streaming framework to intelligently transform the production lines in the manufacturing industry. In the traditional production line there are a variety of isolated structured, semi-structured and unstructured data, such as sensor data, machine screen output, log output, database records etc. There are two main data scenarios: 1) Picture and video data with low frequency but a large amount; 2) Continuous data with high frequency. They are not a large amount of data per unit. However the total amount of them is very large, such as vibration data used to detect the quality of the equipment. These data have the characteristics of streaming data: real-time, volatile, burst, disorder and infinity. Making effective real-time decisions to retrieve values from these data is critical to smart manufacturing. The latest Spark Structured Streaming framework greatly lowers the bar for building highly scalable and fault-tolerant streaming applications. Thanks to the Spark we are able to build a low-latency, high-throughput and reliable operation system involving data acquisition, transmission, analysis and storage. The actual user case proved that the system meets the needs of real-time decision-making. The system greatly enhance the production process of predictive fault repair and production line material tracking efficiency, and can reduce about half of the labor force for the production lines.
Improving Traffic Prediction Using Weather Data with Ramya RaghavendraSpark Summit
As common sense would suggest, weather has a definite impact on traffic. But how much? And under what circumstances? Can we improve traffic (congestion) prediction given weather data? Predictive traffic is envisioned to significantly impact how driver’s plan their day by alerting users before they travel, find the best times to travel, and over time, learn from new IoT data such as road conditions, incidents, etc. This talk will cover the traffic prediction work conducted jointly by IBM and the traffic data provider. As a part of this work, we conducted a case study over five large metropolitans in the US, 2.58 billion traffic records and 262 million weather records, to quantify the boost in accuracy of traffic prediction using weather data. We will provide an overview of our lambda architecture with Apache Spark being used to build prediction models with weather and traffic data, and Spark Streaming used to score the model and provide real-time traffic predictions. This talk will also cover a suite of extensions to Spark to analyze geospatial and temporal patterns in traffic and weather data, as well as the suite of machine learning algorithms that were used with Spark framework. Initial results of this work were presented at the National Association of Broadcasters meeting in Las Vegas in April 2017, and there is work to scale the system to provide predictions in over a 100 cities. Audience will learn about our experience scaling using Spark in offline and streaming mode, building statistical and deep-learning pipelines with Spark, and techniques to work with geospatial and time-series data.
A Tale of Two Graph Frameworks on Spark: GraphFrames and Tinkerpop OLAP Artem...Spark Summit
Graph is on the rise and it’s time to start learning about scalable graph analytics! In this session we will go over two Spark-based Graph Analytics frameworks: Tinkerpop and GraphFrames. While both frameworks can express very similar traversals, they have different performance characteristics and APIs. In this Deep-Dive by example presentation, we will demonstrate some common traversals and explain how, at a Spark level, each traversal is actually computed under the hood! Learn both the fluent Gremlin API as well as the powerful GraphFrame Motif api as we show examples of both simultaneously. No need to be familiar with Graphs or Spark for this presentation as we’ll be explaining everything from the ground up!
No More Cumbersomeness: Automatic Predictive Modeling on Apache Spark Marcin ...Spark Summit
Building accurate machine learning models has been an art of data scientists, i.e., algorithm selection, hyper parameter tuning, feature selection and so on. Recently, challenges to breakthrough this “black-arts” have got started. In cooperation with our partner, NEC Laboratories America, we have developed a Spark-based automatic predictive modeling system. The system automatically searches the best algorithm, parameters and features without any manual work. In this talk, we will share how the automation system is designed to exploit attractive advantages of Spark. The evaluation with real open data demonstrates that our system can explore hundreds of predictive models and discovers the most accurate ones in minutes on a Ultra High Density Server, which employs 272 CPU cores, 2TB memory and 17TB SSD in 3U chassis. We will also share open challenges to learn such a massive amount of models on Spark, particularly from reliability and stability standpoints. This talk will cover the presentation already shown on Spark Summit SF’17 (#SFds5) but from more technical perspective.
Apache Spark and Tensorflow as a Service with Jim DowlingSpark Summit
In Sweden, from the Rise ICE Data Center at www.hops.site, we are providing to reseachers both Spark-as-a-Service and, more recently, Tensorflow-as-a-Service as part of the Hops platform. In this talk, we examine the different ways in which Tensorflow can be included in Spark workflows, from batch to streaming to structured streaming applications. We will analyse the different frameworks for integrating Spark with Tensorflow, from Tensorframes to TensorflowOnSpark to Databrick’s Deep Learning Pipelines. We introduce the different programming models supported and highlight the importance of cluster support for managing different versions of python libraries on behalf of users. We will also present cluster management support for sharing GPUs, including Mesos and YARN (in Hops Hadoop). Finally, we will perform a live demonstration of training and inference for a TensorflowOnSpark application written on Jupyter that can read data from either HDFS or Kafka, transform the data in Spark, and train a deep neural network on Tensorflow. We will show how to debug the application using both Spark UI and Tensorboard, and how to examine logs and monitor training.
Apache Spark and Tensorflow as a Service with Jim DowlingSpark Summit
In Sweden, from the Rise ICE Data Center at www.hops.site, we are providing to reseachers both Spark-as-a-Service and, more recently, Tensorflow-as-a-Service as part of the Hops platform. In this talk, we examine the different ways in which Tensorflow can be included in Spark workflows, from batch to streaming to structured streaming applications. We will analyse the different frameworks for integrating Spark with Tensorflow, from Tensorframes to TensorflowOnSpark to Databrick’s Deep Learning Pipelines. We introduce the different programming models supported and highlight the importance of cluster support for managing different versions of python libraries on behalf of users. We will also present cluster management support for sharing GPUs, including Mesos and YARN (in Hops Hadoop). Finally, we will perform a live demonstration of training and inference for a TensorflowOnSpark application written on Jupyter that can read data from either HDFS or Kafka, transform the data in Spark, and train a deep neural network on Tensorflow. We will show how to debug the application using both Spark UI and Tensorboard, and how to examine logs and monitor training.
MMLSpark: Lessons from Building a SparkML-Compatible Machine Learning Library...Spark Summit
With the rapid growth of available datasets, it is imperative to have good tools for extracting insight from big data. The Spark ML library has excellent support for performing at-scale data processing and machine learning experiments, but more often than not, Data Scientists find themselves struggling with issues such as: low level data manipulation, lack of support for image processing, text analytics and deep learning, as well as the inability to use Spark alongside other popular machine learning libraries. To address these pain points, Microsoft recently released The Microsoft Machine Learning Library for Apache Spark (MMLSpark), an open-source machine learning library built on top of SparkML that seeks to simplify the data science process and integrate SparkML Pipelines with deep learning and computer vision libraries such as the Microsoft Cognitive Toolkit (CNTK) and OpenCV. With MMLSpark, Data Scientists can build models with 1/10th of the code through Pipeline objects that compose seamlessly with other parts of the SparkML ecosystem. In this session, we explore some of the main lessons learned from building MMLSpark. Join us if you would like to know how to extend Pipelines to ensure seamless integration with SparkML, how to auto-generate Python and R wrappers from Scala Transformers and Estimators, how to integrate and use previously non-distributed libraries in a distributed manner and how to efficiently deploy a Spark library across multiple platforms.
Next CERN Accelerator Logging Service with Jakub WozniakSpark Summit
The Next Accelerator Logging Service (NXCALS) is a new Big Data project at CERN aiming to replace the existing Oracle-based service.
The main purpose of the system is to store and present Controls/Infrastructure related data gathered from thousands of devices in the whole accelerator complex.
The data is used to operate the machines, improve their performance and conduct studies for new beam types or future experiments.
During this talk, Jakub will speak about NXCALS requirements and design choices that lead to the selected architecture based on Hadoop and Spark. He will present the Ingestion API, the abstractions behind the Meta-data Service and the Spark-based Extraction API where simple changes to the schema handling greatly improved the overall usability of the system. The system itself is not CERN specific and can be of interest to other companies or institutes confronted with similar Big Data problems.
Powering a Startup with Apache Spark with Kevin KimSpark Summit
In Between (A mobile App for couples, downloaded 20M in Global), from daily batch for extracting metrics, analysis and dashboard. Spark is widely used by engineers and data analysts in Between, thanks to the performance and expendability of Spark, data operating has become extremely efficient. Entire team including Biz Dev, Global Operation, Designers are enjoying data results so Spark is empowering entire company for data driven operation and thinking. Kevin, Co-founder and Data Team leader of Between will be presenting how things are going in Between. Listeners will know how small and agile team is living with data (how we build organization, culture and technical base) after this presentation.
Improving Traffic Prediction Using Weather Datawith Ramya RaghavendraSpark Summit
As common sense would suggest, weather has a definite impact on traffic. But how much? And under what circumstances? Can we improve traffic (congestion) prediction given weather data? Predictive traffic is envisioned to significantly impact how driver’s plan their day by alerting users before they travel, find the best times to travel, and over time, learn from new IoT data such as road conditions, incidents, etc. This talk will cover the traffic prediction work conducted jointly by IBM and the traffic data provider. As a part of this work, we conducted a case study over five large metropolitans in the US, 2.58 billion traffic records and 262 million weather records, to quantify the boost in accuracy of traffic prediction using weather data. We will provide an overview of our lambda architecture with Apache Spark being used to build prediction models with weather and traffic data, and Spark Streaming used to score the model and provide real-time traffic predictions. This talk will also cover a suite of extensions to Spark to analyze geospatial and temporal patterns in traffic and weather data, as well as the suite of machine learning algorithms that were used with Spark framework. Initial results of this work were presented at the National Association of Broadcasters meeting in Las Vegas in April 2017, and there is work to scale the system to provide predictions in over a 100 cities. Audience will learn about our experience scaling using Spark in offline and streaming mode, building statistical and deep-learning pipelines with Spark, and techniques to work with geospatial and time-series data.
Hiding Apache Spark Complexity for Fast Prototyping of Big Data Applications—...Spark Summit
In many cases, Big Data becomes just another buzzword because of the lack of tools that can support both the technological requirements for developing and deploying of the projects and/or the fluency of communication between the different profiles of people involved in the projects.
In this talk, we will present Moriarty, a set of tools for fast prototyping of Big Data applications that can be deployed in an Apache Spark environment. These tools support the creation of Big Data workflows using the already existing functional blocks or supporting the creation of new functional blocks. The created workflow can then be deployed in a Spark infrastructure and used through a REST API.
For better understanding of Moriarty, the prototyping process and the way it hides the Spark environment to the Big Data users and developers, we will present it together with a couple of examples based on a Industry 4.0 success cases and other on a logistic success case.
How Nielsen Utilized Databricks for Large-Scale Research and Development with...Spark Summit
Large-scale testing of new data products or enhancements to existing products in a research and development environment can be a technical challenge for data scientists. In some cases, tools available to data scientists lack production-level capacity, whereas other tools do not provide the algorithms needed to run the methodology. At Nielsen, the Databricks platform provided a solution to both of these challenges. This breakout session will cover a specific Nielsen business case where two methodology enhancements were developed and tested at large-scale using the Databricks platform. Development and large-scale testing of these enhancements would not have been possible using standard database tools.
Spline: Apache Spark Lineage not Only for the Banking Industry with Marek Nov...Spark Summit
Data lineage tracking is one of the significant problems that financial institutions face when using modern big data tools. This presentation describes Spline – a data lineage tracking and visualization tool for Apache Spark. Spline captures and stores lineage information from internal Spark execution plans and visualizes it in a user-friendly manner.
Goal Based Data Production with Sim SimeonovSpark Summit
Since the invention of SQL and relational databases, data production has been about specifying how data is transformed through queries. While Apache Spark can certainly be used as a general distributed query engine, the power and granularity of Spark’s APIs enables a revolutionary increase in data engineering productivity: goal-based data production. Goal-based data production concerns itself with specifying WHAT the desired result is, leaving the details of HOW the result is achieved to a smart data warehouse running on top of Spark. That not only substantially increases productivity, but also significantly expands the audience that can work directly with Spark: from developers and data scientists to technical business users. With specific data and architecture patterns spanning the range from ETL to machine learning data prep and with live demos, this session will demonstrate how Spark users can gain the benefits of goal-based data production.
Preventing Revenue Leakage and Monitoring Distributed Systems with Machine Le...Spark Summit
Have you imagined a simple machine learning solution able to prevent revenue leakage and monitor your distributed application? To answer this question, we offer a practical and a simple machine learning solution to create an intelligent monitoring application based on simple data analysis using Apache Spark MLlib. Our application uses linear regression models to make predictions and check if the platform is experiencing any operational problems that can impact in revenue losses. The application monitor distributed systems and provides notifications stating the problem detected, that way users can operate quickly to avoid serious problems which directly impact the company’s revenue and reduce the time for action. We will present an architecture for not only a monitoring system, but also an active actor for our outages recoveries. At the end of the presentation you will have access to our training program source code and you will be able to adapt and implement in your company. This solution already helped to prevent about US$3mi in losses last year.
Getting Ready to Use Redis with Apache Spark with Dvir VolkSpark Summit
Getting Ready to use Redis with Apache Spark is a technical tutorial designed to address integrating Redis with an Apache Spark deployment to increase the performance of serving complex decision models. To set the context for the session, we start with a quick introduction to Redis and the capabilities Redis provides. We cover the basic data types provided by Redis and cover the module system. Using an ad serving use-case, we look at how Redis can improve the performance and reduce the cost of using complex ML-models in production. Attendees will be guided through the key steps of setting up and integrating Redis with Spark, including how to train a model using Spark then load and serve it using Redis, as well as how to work with the Spark Redis module. The capabilities of the Redis Machine Learning Module (redis-ml) will be discussed focusing primarily on decision trees and regression (linear and logistic) with code examples to demonstrate how to use these feature. At the end of the session, developers should feel confident building a prototype/proof-of-concept application using Redis and Spark. Attendees will understand how Redis complements Spark and how to use Redis to serve complex, ML-models with high performance.
Deduplication and Author-Disambiguation of Streaming Records via Supervised M...Spark Summit
Here we present a general supervised framework for record deduplication and author-disambiguation via Spark. This work differentiates itself by – Application of Databricks and AWS makes this a scalable implementation. Compute resources are comparably lower than traditional legacy technology using big boxes 24/7. Scalability is crucial as Elsevier’s Scopus data, the biggest scientific abstract repository, covers roughly 250 million authorships from 70 million abstracts covering a few hundred years. – We create a fingerprint for each content by deep learning and/or word2vec algorithms to expedite pairwise similarity calculation. These encoders substantially reduce compute time while maintaining semantic similarity (unlike traditional TFIDF or predefined taxonomies). We will briefly discuss how to optimize word2vec training with high parallelization. Moreover, we show how these encoders can be used to derive a standard representation for all our entities namely such as documents, authors, users, journals, etc. This standard representation can simplify the recommendation problem into a pairwise similarity search and hence it can offer a basic recommender for cross-product applications where we may not have a dedicate recommender engine designed. – Traditional author-disambiguation or record deduplication algorithms are batch-processing with small to no training data. However, we have roughly 25 million authorships that are manually curated or corrected upon user feedback. Hence, it is crucial to maintain historical profiles and hence we have developed a machine learning implementation to deal with data streams and process them in mini batches or one document at a time. We will discuss how to measure the accuracy of such a system, how to tune it and how to process the raw data of pairwise similarity function into final clusters. Lessons learned from this talk can help all sort of companies where they want to integrate their data or deduplicate their user/customer/product databases.
MatFast: In-Memory Distributed Matrix Computation Processing and Optimization...Spark Summit
The use of large-scale machine learning and data mining methods is becoming ubiquitous in many application domains ranging from business intelligence and bioinformatics to self-driving cars. These methods heavily rely on matrix computations, and it is hence critical to make these computations scalable and efficient. These matrix computations are often complex and involve multiple steps that need to be optimized and sequenced properly for efficient execution. This work presents new efficient and scalable matrix processing and optimization techniques based on Spark. The proposed techniques estimate the sparsity of intermediate matrix-computation results and optimize communication costs. An evaluation plan generator for complex matrix computations is introduced as well as a distributed plan optimizer that exploits dynamic cost-based analysis and rule-based heuristics The result of a matrix operation will often serve as an input to another matrix operation, thus defining the matrix data dependencies within a matrix program. The matrix query plan generator produces query execution plans that minimize memory usage and communication overhead by partitioning the matrix based on the data dependencies in the execution plan. We implemented the proposed matrix techniques inside the Spark SQL, and optimize the matrix execution plan based on Spark SQL Catalyst. We conduct case studies on a series of ML models and matrix computations with special features on different datasets. These are PageRank, GNMF, BFGS, sparse matrix chain multiplications, and a biological data analysis. The open-source library ScaLAPACK and the array-based database SciDB are used for performance evaluation. Our experiments are performed on six real-world datasets are: social network data ( e.g., soc-pokec, cit-Patents, LiveJournal), Twitter2010, Netflix recommendation data, and 1000 Genomes Project sample. Experiments demonstrate that our proposed techniques achieve up to an order-of-magnitude performance.
Quantitative Data AnalysisReliability Analysis (Cronbach Alpha) Common Method...2023240532
Quantitative data Analysis
Overview
Reliability Analysis (Cronbach Alpha)
Common Method Bias (Harman Single Factor Test)
Frequency Analysis (Demographic)
Descriptive Analysis
06-04-2024 - NYC Tech Week - Discussion on Vector Databases, Unstructured Data and AI
Discussion on Vector Databases, Unstructured Data and AI
https://www.meetup.com/unstructured-data-meetup-new-york/
This meetup is for people working in unstructured data. Speakers will come present about related topics such as vector databases, LLMs, and managing data at scale. The intended audience of this group includes roles like machine learning engineers, data scientists, data engineers, software engineers, and PMs.This meetup was formerly Milvus Meetup, and is sponsored by Zilliz maintainers of Milvus.
Chatty Kathy - UNC Bootcamp Final Project Presentation - Final Version - 5.23...John Andrews
SlideShare Description for "Chatty Kathy - UNC Bootcamp Final Project Presentation"
Title: Chatty Kathy: Enhancing Physical Activity Among Older Adults
Description:
Discover how Chatty Kathy, an innovative project developed at the UNC Bootcamp, aims to tackle the challenge of low physical activity among older adults. Our AI-driven solution uses peer interaction to boost and sustain exercise levels, significantly improving health outcomes. This presentation covers our problem statement, the rationale behind Chatty Kathy, synthetic data and persona creation, model performance metrics, a visual demonstration of the project, and potential future developments. Join us for an insightful Q&A session to explore the potential of this groundbreaking project.
Project Team: Jay Requarth, Jana Avery, John Andrews, Dr. Dick Davis II, Nee Buntoum, Nam Yeongjin & Mat Nicholas
Data Centers - Striving Within A Narrow Range - Research Report - MCG - May 2...pchutichetpong
M Capital Group (“MCG”) expects to see demand and the changing evolution of supply, facilitated through institutional investment rotation out of offices and into work from home (“WFH”), while the ever-expanding need for data storage as global internet usage expands, with experts predicting 5.3 billion users by 2023. These market factors will be underpinned by technological changes, such as progressing cloud services and edge sites, allowing the industry to see strong expected annual growth of 13% over the next 4 years.
Whilst competitive headwinds remain, represented through the recent second bankruptcy filing of Sungard, which blames “COVID-19 and other macroeconomic trends including delayed customer spending decisions, insourcing and reductions in IT spending, energy inflation and reduction in demand for certain services”, the industry has seen key adjustments, where MCG believes that engineering cost management and technological innovation will be paramount to success.
MCG reports that the more favorable market conditions expected over the next few years, helped by the winding down of pandemic restrictions and a hybrid working environment will be driving market momentum forward. The continuous injection of capital by alternative investment firms, as well as the growing infrastructural investment from cloud service providers and social media companies, whose revenues are expected to grow over 3.6x larger by value in 2026, will likely help propel center provision and innovation. These factors paint a promising picture for the industry players that offset rising input costs and adapt to new technologies.
According to M Capital Group: “Specifically, the long-term cost-saving opportunities available from the rise of remote managing will likely aid value growth for the industry. Through margin optimization and further availability of capital for reinvestment, strong players will maintain their competitive foothold, while weaker players exit the market to balance supply and demand.”
1. DEVOPS ADVANCED CLASS
June 2015: Spark Summit West 2015
http://training.databricks.com/devops.pdf
www.linkedin.com/in/blueplastic
2. making big data simple
Databricks Cloud:
“A unified platform for building Big Data pipelines
– from ETL to Exploration and Dashboards, to
Advanced Analytics and Data Products.”
• Founded in late 2013
• by the creators of Apache Spark
• Original team from UC Berkeley AMPLab
• Raised $47 Million in 2 rounds
• ~55 employees
• We’re hiring!
• Level 2/3 support partnerships with
• Hortonworks
• MapR
• DataStax
(http://databricks.workable.com)
3. The Databricks team contributed more than 75% of the code added to Spark in the past year
4. AGENDA
• History of Spark
• RDD fundamentals
• Spark Runtime Architecture
Integration with Resource Managers
(Standalone, YARN)
• GUIs
• Lab: DevOps 101
Before Lunch
• Memory and Persistence
• Jobs -> Stages -> Tasks
• Broadcast Variables and
Accumulators
• PySpark
• DevOps 102
• Shuffle
• Spark Streaming
After Lunch
5. Some slides will be skipped
Please keep Q&A low during class
(5pm – 5:30pm for Q&A with instructor)
2 anonymous surveys: Pre and Post class
Lunch: noon – 1pm
2 breaks (before lunch and after lunch)
6. LinkedIn: https://www.linkedin.com/in/blueplastic
- 1 year: Client Services Engineer @ Databricks
- 2 years: Freelance Big Data Consulting + Training
- Taught 100+ classes
- Traveled to 20+ countries and 50+ cities
- 5 months: Systems Architect @ Hortonworks
- 1.5 years: Emerging Data Platforms Consultant @ Accenture R&D
- 2 years: Storage & Clustering Software Consultant @ Symantec
- 2.5 years: Tech Support Engineer @ Symantec
Wakeboarding / Snowboarding / Scuba Diving / Free-diving /
Kayaking / Running / Hiking / Canoeing / Surfing / Tennis
7. 0 10 20 30 40 50 60 70 80 90 100
Sales / Marketing
Data Scientist
Management / Exec
Administrator / Ops
Developer
Survey completed by
89 out of 215 students
8. SF Bay Area
25%
CA
12%
West US
17%
East US
19%
Europe
8%
Asia
10%
Intern. - O
9%
Survey completed by
89 out of 215 students
9. 0 10 20 30 40 50 60 70
Advertising / PR
Healthcare / Medical
Academia / University
Telecom
Science & Tech
Banking / Finance
IT / Systems
Survey completed by
89 out of 215 students
10. 0 10 20 30 40 50 60 70 80
SparkSummit
Vendor Training
SparkCamp
AmpCamp
None
Survey completed by
89 out of 215 students
11. Survey completed by
89 out of 215 students
Zero
6%
< 1 week
16%
< 1 month
35%
1-6 months
43%
17. 0 10 20 30 40 50 60 70 80 90
Use Cases
Architecture
Administrator / Ops
Development
Survey completed by
89 out of 215 students
18. @
• AMPLab project was launched in Jan 2011, 6 year planned duration
• Personnel: ~65 students, postdocs, faculty & staff
• Funding from Government/Industry partnership, NSF Award, Darpa, DoE,
20+ companies
• Created BDAS, Mesos, SNAP. Upcoming projects: Succinct & Velox.
“Unknown to most of the world, the University of California, Berkeley’s AMPLab
has already left an indelible mark on the world of information technology, and
even the web. But we haven’t yet experienced the full impact of the
group[…] Not even close”
- Derrick Harris, GigaOm, Aug 2014
Algorithms
Machines
People
29. CPUs:
10 GB/s
100 MB/s
0.1 ms random access
$0.45 per GB
600 MB/s
3-12 ms random access
$0.05 per GB
1 Gb/s or
125 MB/s
Network
0.1 Gb/s
Nodes in
another
rack
Nodes in
same rack
1 Gb/s or
125 MB/s
30. June 2010
http://www.cs.berkeley.edu/~matei/papers/2010/hotcloud_spark.pdf
“The main abstraction in Spark is that of a resilient dis-
tributed dataset (RDD), which represents a read-only
collection of objects partitioned across a set of
machines that can be rebuilt if a partition is lost.
Users can explicitly cache an RDD in memory across
machines and reuse it in multiple MapReduce-like
parallel operations.
RDDs achieve fault tolerance through a notion of
lineage: if a partition of an RDD is lost, the RDD has
enough information about how it was derived from
other RDDs to be able to rebuild just that partition.”
31. April 2012
http://www.cs.berkeley.edu/~matei/papers/2012/nsdi_spark.pdf
“We present Resilient Distributed Datasets (RDDs), a
distributed memory abstraction that lets
programmers perform in-memory computations on
large clusters in a fault-tolerant manner.
RDDs are motivated by two types of applications
that current computing frameworks handle
inefficiently: iterative algorithms and interactive data
mining tools.
In both cases, keeping data in memory can improve
performance by an order of magnitude.”
“Best Paper Award and Honorable Mention for Community Award”
- NSDI 2012
- Cited 392 times!
45. • Introduced Spark SQL
• Introduced support for Hadoop Security and
PySpark on YARN
• Added Spark Submit
• Added History Server web UI
• MLlib improvements: sparse feature vectors,
scalable decision trees, SVD, PCA, L-BFGS
• Substantial performance boosts in GraphX
• Added flume support in Streaming
• Support for Java 8 lambda syntax
May 2014
1.0.0version
contributions from
117 developers
46. • New sort based Shuffle for very large scale
workloads (10k + reducers)
• Spark SQL additions: JDBC/ODBC server,
JSON support, UDFs
• New statistics library for MLlib and 2-3x speed
improvement for many algorithms
• New in Spark Streaming: partial HA, Amazon
Kinesis, Flume pull, streaming linear regression,
rate limiting
• PySpark now supports HBase, C*, Avro,
SequenceFiles
Sept 2014
1.1.0version
contributions from
171 developers
47. • New Netty based network transfer subsystem
for very large shuffles
• Scala 2.11 support
• Streaming: Python API, driver HA, WAL
• MLlib: ML Pipelines (multiple algorithms are
run in sequence with varying parameters),
major python improvements
• Spark SQL: External data sources API, Hive
0.13 support
• GraphX: graduates from alpha and adds a
stable API
• PySpark: broadcast variables > 2 GB
Dec 2014
1.2.0version
contributions from
172 developers
60+ institutions
48. • DataFrame API released
• SparkSQL graduates from an alpha project
• Core: reduce performance, error reporting,
some SSL encryption, GC metrics in UI
• MLlib: LDA for topic modeling, GMM,
multinomial logistic regression, FP-growth
• Streaming: direct Kafka API
• PySpark: Support for ML Pipelines
Mar 2015
1.3.0version
contributions from
174 developers
49. • Introduced SparkR
• Core: DAG visualization, Python 3 support,
REST API, serialized shuffle, beginning of
Tungsten
• SQL/DF: ORCFile format support, UI for JDBC
server
• ML pipelines graduates from alpha
• Many new ML algorithms
• Streaming: visual graphs in UI, better Kafka +
Kinesis support
Jun 2015
1.4.0version
contributions from
210 developers
Benchmark & Integration
testing by:
• Intel
• Palantir
• Cloudera
• Mesosphere
• Huawei
• Shopify
• Netflix
• Yahoo
• UC Berkeley
• Databricks
70+ institutions
56. Error, ts, msg1
Warn, ts, msg2
Error, ts, msg1
RDD w/ 4 partitions
Info, ts, msg8
Warn, ts, msg2
Info, ts, msg8
Error, ts, msg3
Info, ts, msg5
Info, ts, msg5
Error, ts, msg4
Warn, ts, msg9
Error, ts, msg1
An RDD can be created 2 ways:
- Parallelize a collection
- Read data from an external source (S3, C*, HDFS, etc)
logLinesRDD
57. # Parallelize in Python
wordsRDD = sc.parallelize([“fish", “cats“, “dogs”])
// Parallelize in Scala
val wordsRDD= sc.parallelize(List("fish", "cats", "dogs"))
// Parallelize in Java
JavaRDD<String> wordsRDD = sc.parallelize(Arrays.asList(“fish", “cats“, “dogs”));
- Take an existing in-memory
collection and pass it to
SparkContext’s parallelize
method
- Not generally used outside of
prototyping and testing since it
requires entire dataset in
memory on one machine
58. # Read a local txt file in Python
linesRDD = sc.textFile("/path/to/README.md")
// Read a local txt file in Scala
val linesRDD = sc.textFile("/path/to/README.md")
// Read a local txt file in Java
JavaRDD<String> lines = sc.textFile("/path/to/README.md");
- There are other methods
to read data from HDFS,
C*, S3, HBase, etc.
70. 1) Create some input RDDs from external data or parallelize a
collection in your driver program.
2) Lazily transform them to define new RDDs using
transformations like filter() or map()
3) Ask Spark to cache() any intermediate RDDs that will need to
be reused.
4) Launch actions such as count() and collect() to kick off a
parallel computation, which is then optimized and executed
by Spark.
71. map() intersection() cartesion()
flatMap() distinct() pipe()
filter() groupByKey() coalesce()
mapPartitions() reduceByKey() repartition()
mapPartitionsWithIndex() sortByKey() partitionBy()
sample() join() ...
union() cogroup() ...
(lazy)
- Most transformations are element-wise (they work on one element at a time), but this is not
true for all transformations
76. 1) Set of partitions (“splits”)
2) List of dependencies on parent RDDs
3) Function to compute a partition given parents
4) Optional preferred locations
5) Optional partitioning info for k/v RDDs (Partitioner)
This captures all current Spark operations!
*
*
*
*
*
81. Start the Spark shell by passing in a custom cassandra.input.split.size:
ubuntu@ip-10-0-53-24:~$ dse spark –Dspark.cassandra.input.split.size=2000
Welcome to
____ __
/ __/__ ___ _____/ /__
_ / _ / _ `/ __/ '_/
/___/ .__/_,_/_/ /_/_ version 0.9.1
/_/
Using Scala version 2.10.3 (Java HotSpot(TM) 64-Bit Server VM, Java
1.7.0_51)
Type in expressions to have them evaluated.
Type :help for more information.
Creating SparkContext...
Created spark context..
Spark context available as sc.
Type in expressions to have them evaluated.
Type :help for more information.
scala>
The cassandra.input.split.size parameter defaults to 100,000. This is the approximate
number of physical rows in a single Spark partition. If you have really wide rows
(thousands of columns), you may need to lower this value. The higher the value, the
fewer Spark tasks are created. Increasing the value too much may limit the parallelism
level.”
(for dealing with wide rows)
86. https://classwest03.cloud.databricks.com https://classwest10.cloud.databricks.com
- 60 user accounts - 60 user accounts
- 60 user clusters
- 1 community cluster
- 60 user clusters
- 1 community cluster
https://classwest20.cloud.databricks.com https://classwest30.cloud.databricks.com
- 60 user accounts - 60 user accounts
- 60 user clusters
- 1 community cluster
- 60 user clusters
- 1 community cluster
94. JVM: Ex + Driver
Disk
RDD, P1 Task
3 options:
- local
- local[N]
- local[*]
RDD, P2
RDD, P1
RDD, P2
RDD, P3
Task
Task
Task
Task
Task
CPUs:
Task
Task
Task
Task
Task
Task
Internal
Threads
val conf = new SparkConf()
.setMaster("local[12]")
.setAppName(“MyFirstApp")
.set("spark.executor.memory", “3g")
val sc = new SparkContext(conf)
> ./bin/spark-shell --master local[12]
> ./bin/spark-submit --name "MyFirstApp"
--master local[12] myApp.jar
Worker Machine
95.
96. Ex
RDD, P1
W
Driver
RDD, P2
RDD, P1
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Ex
RDD, P4
W
RDD, P6
RDD, P1
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Ex
RDD, P7
W
RDD, P8
RDD, P2
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Spark
Master
Ex
RDD, P5
W
RDD, P3
RDD, P2
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
T T
T T
different spark-env.sh
- SPARK_WORKER_CORES
vs.> ./bin/spark-submit --name “SecondApp"
--master spark://host1:port1
myApp.jar - SPARK_LOCAL_DIRSspark-env.sh
97. Ex
RDD, P1
W
Driver
RDD, P2
RDD, P1
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Ex
RDD, P4
W
RDD, P6
RDD, P1
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Ex
RDD, P7
W
RDD, P8
RDD, P2
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Spark
Master
Ex
RDD, P5
W
RDD, P3
RDD, P2
T T
T T
T T
Internal
Threads
SSD SSDOS Disk
SSD SSD
Spark
Master
T T
T T
different spark-env.sh
- SPARK_WORKER_CORES
vs.
I’m HA via
ZooKeeper
> ./bin/spark-submit --name “SecondApp"
--master spark://host1:port1,host2:port2
myApp.jar
Spark
Master
More
Masters
can be
added live
- SPARK_LOCAL_DIRSspark-env.sh
99. Driver
SSDOS Disk SSDOS Disk SSDOS Disk
Spark
Master
W
SSDOS Disk
(single app)
Ex
W
Ex
W
Ex
W
Ex
W
Ex
W
Ex
W
Ex
W
Ex
SPARK_WORKER_INSTANCES: [default: 1] # of worker instances to run on each machine
SPARK_WORKER_CORES: [default: ALL] # of cores to allow Spark applications to use on the machine
SPARK_WORKER_MEMORY: [default: TOTAL RAM – 1 GB] Total memory to allow Spark applications to use on the machineconf/spark-env.sh
SPARK_DAEMON_MEMORY: [default: 512 MB] Memory to allocate to the Spark master and worker daemons themselves
100. Standalone settings
- Apps submitted will run in FIFO mode by default
spark.cores.max: maximum amount of CPU cores to request for the
application from across the cluster
spark.executor.memory: Memory for each executor
117. YARN settings
--num-executors: controls how many executors will be allocated
--executor-memory: RAM for each executor
--executor-cores: CPU cores for each executor
127. Spark Central Master Who starts Executors? Tasks run in
Local [none] Human being Executor
Standalone Standalone Master Worker JVM Executor
YARN YARN App Master Node Manager Executor
Mesos Mesos Master Mesos Slave Executor
128. spark-submit provides a uniform interface for
submitting jobs across all cluster managers
bin/spark-submit --master spark://host:7077
--executor-memory 10g
my_script.py
Source: Learning Spark
129. PySpark at a Glance
Write Spark jobs
in Python
Run interactive
jobs in the shell
Supports C
extensions
132. Data is stored as Pickled objects in an RDD[Array[Byte]]HadoopRDD
MappedRDD
PythonRDD RDD[Array[ ] ], , ,
(100 KB – 1MB each picked object)
133. pypy
• JIT, so faster
• less memory
• CFFI support
CPython
(default python)
Choose Your Python Implementation
Spark
Context
Driver Machine
Worker Machine
$ PYSPARK_DRIVER_PYTHON=pypy PYSPARK_PYTHON=pypy ./bin/pyspark
$ PYSPARK_DRIVER_PYTHON=pypy PYSPARK_PYTHON=pypy ./bin/spark-submit wordcount.py
OR
134. Job CPython 2.7 PyPy 2.3.1 Speed up
Word Count 41 s 15 s 2.7 x
Sort 46 s 44 s 1.05 x
Stats 174 s 3.6 s 48 x
The performance speed up will depend on work load (from 20% to 3000%).
Here are some benchmarks:
Here is the code used for benchmark:
rdd = sc.textFile("text")
def wordcount():
rdd.flatMap(lambda x:x.split('/'))
.map(lambda x:(x,1)).reduceByKey(lambda x,y:x+y).collectAsMap()
def sort():
rdd.sortBy(lambda x:x, 1).count()
def stats():
sc.parallelize(range(1024), 20).flatMap(lambda x: xrange(5024)).stats()
https://github.com/apache/spark/pull/2144
135.
136. Task 3
Executor 1 Executor 2 Executor 3
Task 2
Task 1
Task 5
Task 4
Task 9
Task 8
Task 7
JOB 1
In Spark, each executor is long-running and runs many small tasks
142. Each Spark application scales the number of
executors up and down based on workload
- If executors are idle, remove them
- If we need more executors, request them
144. LONG-RUNNING ETL JOBS
E.G. PARSING JSON INTO PARQUET IN S3
INTERACTIVE APPLICATIONS / SERVER
E.G. SPARK SHELL, OOYALA JOB SERVER
ANY APPLICATION WITH LARGE SHUFFLES
145. * this team
only
• 100 TB cluster with 1500+ nodes
• 15+ PB S3 warehouse (7 PB Parquet)
• Dynamic allocation with up to 10,000 executors
• Enabled dynamic allocation for all Spark applications*
• Run Spark alongside Hive, Pig, MapReduce
• Used for ad-hoc query and experimentation
* this team only
146. * this team
only
• 400+ TB cluster with 8,000+ nodes
• 150 PB data warehouse
• Use dynamic allocation with up to 1,500 executors
• Primary use cases are ETL and SQL
• Run Spark alongside Storm, MapReduce, Pig
147. • Support for Mesos mode
• Support for Standalone mode
• Better support for caching
• Pluggable scaling heuristics
SPARK-4922 (PR ready)
SPARK-4751 (PR soon)
SPARK-7955 (PR ready)
148.
149.
150. Ex
RDD, P1
RDD, P2
RDD, P1
T T
T T
T T
Internal
Threads
Recommended to use at most only 75% of a machine’s memory
for Spark
Minimum Executor heap size should be 8 GB
Max Executor heap size depends… maybe 40 GB (watch GC)
Memory usage is greatly affected by storage level and
serialization format
162. Persistence description
MEMORY_ONLY Store RDD as deserialized Java objects in
the JVM
MEMORY_AND_DISK Store RDD as deserialized Java objects in
the JVM and spill to disk
MEMORY_ONLY_SER Store RDD as serialized Java objects (one
byte array per partition)
MEMORY_AND_DISK_SER Spill partitions that don't fit in memory to
disk instead of recomputing them on the fly
each time they're needed
DISK_ONLY Store the RDD partitions only on disk
MEMORY_ONLY_2, MEMORY_AND_DISK_2 Same as the levels above, but replicate
each partition on two cluster nodes
OFF_HEAP Store RDD in serialized format in Tachyon
163. Bringing Spark Closer to Bare Metal
Project Tungsten will be the largest change to Spark’s execution engine since the project’s inception.
TLDR:
Problem #1:
- “abcd” takes 4 bytes to store in UTF-8, but JVM takes 48 bytes to store it
Problem #2:
- JVM cannot be as smart as Spark to manage GC b/c Spark knows more
about life cycle of memory blocks
Solution:
- Manage memory with Spark using JVM internal API sun.misc.Unsafe, to directly
manipulate memory without safety checks (hence “unsafe”)
164. Bringing Spark Closer to Bare Metal
Project Tungsten will be the largest change to Spark’s execution engine since the project’s inception.
TLDR:
Problem:
- A large fraction of CPU time is spent waiting for data to be fetched from
main memory
Solution:
- Use cache-aware computation to improve speed of data processing via
L1/L2/L3 CPU caches
166. ?
- If RDD fits in memory, choose MEMORY_ONLY
- If not, use MEMORY_ONLY_SER w/ fast serialization library
- Don’t spill to disk unless functions that computed the datasets
are very expensive or they filter a large amount of data.
(recomputing may be as fast as reading from disk)
- Use replicated storage levels sparingly and only if you want fast
fault recovery (maybe to serve requests from a web app)
167. Intermediate data is automatically persisted during shuffle operations
Remember!
168. PySpark: stored objects will always be serialized with Pickle library, so it does
not matter whether you choose a serialized level.
=
169. 60%20%
20%
Default Memory Allocation in Executor JVM
Cached RDDs
User Programs
(remainder)
Shuffle memory
spark.storage.memoryFraction
spark.shuffle.memoryFraction
170. RDD Storage: when you call .persist() or .cache(). Spark will limit the amount of
memory used when caching to a certain fraction of the JVM’s overall heap, set by
spark.storage.memoryFraction
Shuffle and aggregation buffers: When performing shuffle operations, Spark will
create intermediate buffers for storing shuffle output data. These buffers are used to
store intermediate results of aggregations in addition to buffering data that is going
to be directly output as part of the shuffle.
User code: Spark executes arbitrary user code, so user functions can themselves
require substantial memory. For instance, if a user application allocates large arrays
or other objects, these will content for overall memory usage. User code has access
to everything “left” in the JVM heap after the space for RDD storage and shuffle
storage are allocated.
Spark uses memory for:
171. 1. Create an RDD
2. Put it into cache
3. Look at SparkContext logs
on the driver program or
Spark UI
INFO BlockManagerMasterActor: Added rdd_0_1 in memory on mbk.local:50311 (size: 717.5 KB, free: 332.3 MB)
logs will tell you how much memory each
partition is consuming, which you can
aggregate to get the total size of the RDD
172.
173. Serialization is used when:
Transferring data over the network
Spilling data to disk
Caching to memory serialized
Broadcasting variables
174. Java serialization Kryo serializationvs.
• Uses Java’s ObjectOutputStream framework
• Works with any class you create that implements
java.io.Serializable
• You can control the performance of serialization
more closely by extending java.io.Externalizable
• Flexible, but quite slow
• Leads to large serialized formats for many classes
• Recommended serialization for production apps
• Use Kyro version 2 for speedy serialization (10x) and
more compactness
• Does not support all Serializable types
• Requires you to register the classes you’ll use in
advance
• If set, will be used for serializing shuffle data between
nodes and also serializing RDDs to disk
conf.set(“spark.serializer”, "org.apache.spark.serializer.KryoSerializer")
175. To register your own custom classes with Kryo, use the
registerKryoClasses method:
val conf = new SparkConf().setMaster(...).setAppName(...)
conf.registerKryoClasses(Seq(classOf[MyClass1], classOf[MyClass2]))
val sc = new SparkContext(conf)
- If your objects are large, you may need to increase
spark.kryoserializer.buffer.mb config property
- The default is 2, but this value needs to be large enough to
hold the largest object you will serialize.
176. . . . Ex
RDD
W
RDD
Ex
RDD
W
RDD
High churn Low churn
177. . . . Ex
RDD
W
RDD
RDD
High churn
Cost of GC is proportional to the # of
Java objects
(so use an array of Ints instead of a
LinkedList)
-verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps
To measure GC impact:
178. Parallel Old GC CMS GC G1 GC
-XX:+UseParallelOldGC -XX:+UseConcMarkSweepGC -XX:+UseG1GC
- Uses multiple threads
to do both young gen
and old gen GC
- Also a multithreading
compacting collector
- HotSpot does
compaction only in
old gen
Parallel GC
-XX:+UseParallelGC
- Uses multiple threads to
do young gen GC
- Will default to Serial on
single core machines
- Aka “throughput
collector”
- Good for when a lot of
work is needed and
long pauses are
acceptable
- Use cases: batch
processing
-XX:ParallelGCThreads=<#> -XX:ParallelCMSThreads=<#>
- Concurrent Mark
Sweep aka
“Concurrent low
pause collector”
- Tries to minimize
pauses due to GC by
doing most of the work
concurrently with
application threads
- Uses same algorithm
on young gen as
parallel collector
- Use cases:
- Garbage First is available
starting Java 7
- Designed to be long term
replacement for CMS
- Is a parallel, concurrent
and incrementally
compacting low-pause
GC
180. The key to tuning spark apps is a sound grasp of Spark’s internal mechanisms
181. ?
How does a user program get translated into units of physical execution?
application -> jobs, stages, tasks
182. // Read input file
val input = sc.textFile("input.txt")
val tokenized = input
.map(line => line.split(" "))
.filter(words => words.size > 0) // remove empty lines
val counts = tokenized // frequency of log levels
.map(words => (words(0), 1))
.reduceByKey{ (a, b) => a + b, 2 }
INFO Server started
INFO Bound to port 8080
WARN Cannot find srv.conf
input.txt
183. // Read input file
val input = sc.textFile( )
val tokenized = input
.map( )
.filter( ) // remove empty lines
val counts = tokenized // frequency of log levels
.map( )
.reduceByKey{ }
186. DAG’s are materialized through a method sc.runJob:
def runJob[T, U](
rdd: RDD[T], 1. RDD to compute
partitions: Seq[Int], 2. Which partitions
func: (Iterator[T]) => U)) 3. Fn to produce results
: Array[U] results for each part.
187. Mapped RDD
Partition 1
Partition 2
Partition 3
Partition 1
Partition 2
Partition 3
Mapped RDD
Partition 1
Partition 2
Partition 3
Partition 1
Partition 2
Hadoop RDD
Partition 1
Partition 2
Partition 3
input tokenized counts
Filtered RDD Shuffle RDD
Needs to compute my parents, parents, parents, etc all the way back to
an RDD with no dependencies (e.g. HadoopRDD).
runJob(counts)
188. Mapped RDD
Partition 1
Partition 2
Partition 3
Partition 1
Partition 2
Partition 3
Mapped RDD
Partition 1
Partition 2
Partition 3
Partition 1
Partition 2
Hadoop RDD
Partition 1
Partition 2
Partition 3
input tokenized counts
Filtered RDD Shuffle RDD
Needs to compute my parents, parents, parents, etc all the way back to
an RDD with no dependencies (e.g. HadoopRDD).
runJob(counts)
190. scala> counts.toDebugString
res84: String =
(2) ShuffledRDD[296] at reduceByKey at <console>:17
+-(3) MappedRDD[295] at map at <console>:17
| FilteredRDD[294] at filter at <console>:15
| MappedRDD[293] at map at <console>:15
| input.text MappedRDD[292] at textFile at <console>:13
| input.text HadoopRDD[291] at textFile at <console>:13
(indentations indicate a shuffle boundary)
206. “This distinction is useful for two reasons:
1) Narrow dependencies allow for pipelined execution on one cluster node,
which can compute all the parent partitions. For example, one can apply a
map followed by a filter on an element-by-element basis.
In contrast, wide dependencies require data from all parent partitions to be
available and to be shuffled across the nodes using a MapReduce-like
operation.
2) Recovery after a node failure is more efficient with a narrow dependency, as
only the lost parent partitions need to be recomputed, and they can be
recomputed in parallel on different nodes. In contrast, in a lineage graph with
wide dependencies, a single failed node might cause the loss of some partition
from all the ancestors of an RDD, requiring a complete re-execution.”
Dependencies: Narrow vs Wide
207. scala> input.toDebugString
res85: String =
(2) data.text MappedRDD[292] at textFile at <console>:13
| data.text HadoopRDD[291] at textFile at <console>:13
scala> counts.toDebugString
res84: String =
(2) ShuffledRDD[296] at reduceByKey at <console>:17
+-(2) MappedRDD[295] at map at <console>:17
| FilteredRDD[294] at filter at <console>:15
| MappedRDD[293] at map at <console>:15
| data.text MappedRDD[292] at textFile at <console>:13
| data.text HadoopRDD[291] at textFile at <console>:13
To display the lineage of an RDD, Spark provides a toDebugString method:
208. How do you know if a shuffle will be called on a Transformation?
Note that repartition just calls coalese w/ True:
- repartition , join, cogroup, and any of the *By or *ByKey transformations
can result in shuffles
- If you declare a numPartitions parameter, it’ll probably shuffle
- If a transformation constructs a shuffledRDD, it’ll probably shuffle
- combineByKey calls a shuffle (so do other transformations like
groupByKey, which actually end up calling combineByKey)
def repartition(numPartitions: Int)(implicit
ord: Ordering[T] = null): RDD[T] = {
coalesce(numPartitions, shuffle = true)
}
RDD.scala
209. How do you know if a shuffle will be called on a Transformation?
Transformations that use “numPartitions” like distinct will probably shuffle:
def distinct(numPartitions: Int)(implicit ord: Ordering[T] =
null): RDD[T] =
map(x => (x, null)).reduceByKey((x, y) => x,
numPartitions).map(_._1)
210. - An extra parameter you can pass a k/v transformation to let Spark know
that you will not be messing with the keys at all
- All operations that shuffle data over network will benefit from partitioning
- Operations that benefit from partitioning:
cogroup, groupWith, join, leftOuterJoin, rightOuterJoin, groupByKey,
reduceByKey, combineByKey, lookup, . . .
https://github.com/apache/spark/blob/master/core/src/main/scala/org/apache/spark/rdd/RDD.scala#L302
211. Driver
Ex
RDD, P1
RDD, P2
RDD, P1
T T
T T
T T
Internal
Threads
SparkContext
DAG Scheduler Task Scheduler SparkEnv
- cacheManager
- blockManager
- shuffleManager
- securityManager
- broadcastManager
- mapOutputTracker
CoarseGrainedExecutorBackend
SparkEnv
- cacheManager
- blockManager
- shuffleManager
- securityManager
- broadcastManager
- mapOutputTracker
219. • Broadcast variables – Send a large read-only lookup table to all the nodes, or
send a large feature vector in a ML algorithm to all nodes
• Accumulators – count events that occur during job execution for debugging
purposes. Example: How many lines of the input file were blank? Or how many
corrupt records were in the input dataset?
++ +
220. Spark supports 2 types of shared variables:
• Broadcast variables – allows your program to efficiently send a large, read-only
value to all the worker nodes for use in one or more Spark operations. Like
sending a large, read-only lookup table to all the nodes.
• Accumulators – allows you to aggregate values from worker nodes back to
the driver program. Can be used to count the # of errors seen in an RDD of
lines spread across 100s of nodes. Only the driver can access the value of an
accumulator, tasks cannot. For tasks, accumulators are write-only.
++ +
221. Broadcast variables let programmer keep a read-
only variable cached on each machine rather than
shipping a copy of it with tasks
For example, to give every node a copy of a large
input dataset efficiently
Spark also attempts to distribute broadcast variables
using efficient broadcast algorithms to reduce
communication cost
229. Accumulators are variables that can only be “added” to through
an associative operation
Used to implement counters and sums, efficiently in parallel
Spark natively supports accumulators of numeric value types and
standard mutable collections, and programmers can extend
for new types
Only the driver program can read an accumulator’s value, not the
tasks
++ +
233. Spark sorted the same data 3X faster
using 10X fewer machines
than Hadoop MR in 2013.
Work by Databricks engineers: Reynold Xin, Parviz Deyhim, Xiangrui Meng, Ali Ghodsi, Matei Zaharia
100TB Daytona Sort Competition 2014
More info:
http://sortbenchmark.org
http://databricks.com/blog/2014/11/05/spark-
officially-sets-a-new-record-in-large-scale-sorting.html
All the sorting took place on disk (HDFS) without
using Spark’s in-memory cache!
234.
235. - Stresses “shuffle” which underpins everything from SQL to Mllib
- Sorting is challenging b/c there is no reduction in data
- Sort 100 TB = 500 TB disk I/O and 200 TB network
Engineering Investment in Spark:
- Sort-based shuffle (SPARK-2045)
- Netty native network transport (SPARK-2468)
- External shuffle service (SPARK-3796)
Clever Application level Techniques:
- GC and cache friendly memory layout
- Pipelining
236. Ex
RDD
W
RDD
T
T
EC2: i2.8xlarge
(206 workers)
- Intel Xeon CPU E5 2670 @ 2.5 GHz w/ 32 cores
- 244 GB of RAM
- 8 x 800 GB SSD and RAID 0 setup formatted with /ext4
- ~9.5 Gbps (1.1 GBps) bandwidth between 2 random nodes
- Each record: 100 bytes (10 byte key & 90 byte value)
- OpenJDK 1.7
- HDFS 2.4.1 w/ short circuit local reads enabled
- Apache Spark 1.2.0
- Speculative Execution off
- Increased Locality Wait to infinite
- Compression turned off for input, output & network
- Used Unsafe to put all the data off-heap and managed
it manually (i.e. never triggered the GC)
- 32 slots per machine
- 6,592 slots total
239. - Must turn this on for dynamic allocation in YARN
- Worker JVM serves files
- Node Manager serves files
240. - Was slow because it had to copy the data 3 times
Map output file
on local dir
Linux
kernel
buffer
Ex
NIC
buffer
241. - Uses a technique called zero-copy
- Is a map-side optimization to serve data very
quickly to requesting reducers
Map output file
on local dir
NIC
buffer
242. Map() Map() Map() Map()
Reduce() Reduce() Reduce()
- Entirely bounded
by I/O reading from
HDFS and writing out
locally sorted files
- Mostly network bound
< 10,000 reducers
- Notice that map
has to keep 3 file
handles open
TimSort
= 5 blocks
243. Map() Map() Map() Map()
(28,000 unique blocks)
RF = 2
250,000+ reducers!
- Only one file handle
open at a time
= 3.6 GB
247. UserID Name Age Location Pet
28492942 John Galt 32 New York Sea Horse
95829324 Winston Smith 41 Oceania Ant
92871761 Tom Sawyer 17 Mississippi Raccoon
37584932 Carlos Hinojosa 33 Orlando Cat
73648274 Luis Rodriguez 34 Orlando Dogs
250. SchemaRDD
- RDD of Row objects, each representing a record
- Row objects = type + col. name of each
- Stores data very efficiently by taking advantage of the schema
- SchemaRDDs are also regular RDDs, so you can run
transformations like map() or filter()
- Allows new operations, like running SQL on objects
251.
252.
253. • Announced Feb 2015
• Inspired by data frames in R
and Pandas in Python
• Works in:
Features
• Scales from KBs to PBs
• Supports wide array of data formats and
storage systems (Hive, existing RDDs, etc)
• State-of-the-art optimization and code
generation via Spark SQL Catalyst optimizer
• APIs in Python, Java
• a distributed collection of data organized into
named columns
• Like a table in a relational database
What is a Dataframe?
254. Step 1: Construct a DataFrame
from pyspark.sql import SQLContext
sqlContext = SQLContext(sc)
df = sqlContext.jsonFile("examples/src/main/resources/people.json")
# Displays the content of the DataFrame to stdout
df.show()
## age name
## null Michael
## 30 Andy
## 19 Justin
255. Step 2: Use the DataFrame
# Print the schema in a tree format
df.printSchema()
## root
## |-- age: long (nullable = true)
## |-- name: string (nullable = true)
# Select only the "name" column
df.select("name").show()
## name
## Michael
## Andy
## Justin
# Select everybody, but increment the age by 1
df.select("name", df.age + 1).show()
## name (age + 1)
## Michael null
## Andy 31
## Justin 20
257. SQL + RDD Integration
2 methods for converting existing RDDs into DataFrames:
1. Use reflection to infer the schema of an RDD that
contains different types of objects
2. Use a programmatic interface that allows you to
construct a schema and then apply it to an existing
RDD.
(more concise)
(more verbose)
258. SQL + RDD Integration: via reflection
# sc is an existing SparkContext.
from pyspark.sql import SQLContext, Row
sqlContext = SQLContext(sc)
# Load a text file and convert each line to a Row.
lines = sc.textFile("examples/src/main/resources/people.txt")
parts = lines.map(lambda l: l.split(","))
people = parts.map(lambda p: Row(name=p[0], age=int(p[1])))
# Infer the schema, and register the DataFrame as a table.
schemaPeople = sqlContext.inferSchema(people)
schemaPeople.registerTempTable("people")
259. SQL + RDD Integration: via reflection
# SQL can be run over DataFrames that have been registered as a table.
teenagers = sqlContext.sql("SELECT name FROM people WHERE age >= 13 AND age <= 19")
# The results of SQL queries are RDDs and support all the normal RDD operations.
teenNames = teenagers.map(lambda p: "Name: " + p.name)
for teenName in teenNames.collect():
print teenName
260. SQL + RDD Integration: via programmatic schema
DataFrame can be created programmatically with 3 steps:
1. Create an RDD of tuples or lists from the original RDD
2. Create the schema represented by a StructType matching the
structure of tuples or lists in the RDD created in the step 1
3. Apply the schema to the RDD via createDataFrame method
provided by SQLContext
261. Step 1: Construct a DataFrame
# Constructs a DataFrame from the users table in Hive.
users = context.table("users")
# from JSON files in S3
logs = context.load("s3n://path/to/data.json", "json")
262. Step 2: Use the DataFrame
# Create a new DataFrame that contains “young users” only
young = users.filter(users.age < 21)
# Alternatively, using Pandas-like syntax
young = users[users.age < 21]
# Increment everybody’s age by 1
young.select(young.name, young.age + 1)
# Count the number of young users by gender
young.groupBy("gender").count()
# Join young users with another DataFrame called logs
young.join(logs, logs.userId == users.userId, "left_outer")
266. Tathagata Das (TD)
- Lead developer of Spark Streaming + Committer
on Apache Spark core
- Helped re-write Spark Core internals in 2012 to
make it 10x faster to support Streaming use cases
- On leave from UC Berkeley PhD program
- Ex: Intern @ Amazon, Intern @ Conviva, Research
Assistant @ Microsoft Research India
- 1 guy; does not scale
- Scales to 100s of nodes
- Batch sizes as small as half a second
- End to end Processing latency as low as 1 second
- Exactly-once semantics no matter what fails
267. Page views Kafka for buffering Spark for processing
(live statistics)
274. // Create a StreamingContext with a 1-second batch size from a SparkConf
val ssc = new StreamingContext(conf, Seconds(1))
// Create a DStream using data received after connecting to port 7777 on the local machine
val linesStream = ssc.socketTextStream("localhost", 7777)
// Filter our DStream for lines with "error"
val errorLinesStream = linesStream.filter(_.contains("error"))
// Print out the lines with errors
errorLinesStream.print()
// Start our streaming context and wait for it to "finish"
ssc.start()
// Wait for the job to finish
ssc.awaitTermination()
linesStream
errorLinesStream
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.StreamingContext._
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.Duration
275. Terminal #1 Terminal #2
$ nc localhost 7777
all is good
there was an error
good good
error 4 happened
all good now
$ spark-submit --class com.examples.Scala.StreamingLogInput
$ASSEMBLY_JAR local[4]
. . .
--------------------------
Time: 2015-05-26 15:25:21
--------------------------
there was an error
--------------------------
Time: 2015-05-26 15:25:22
--------------------------
error 4 happened
276. Remember!
• Once a StreamingContext has been started, no new streaming
computations can be added to it
• Once a StreamingContext has been stopped, it cannot be restarted
• Only one StreamingContext can be active in a JVM at a time
• Stop() on StreamingContext also stops the SparkContext. (You can stop
only the StreamingContext by setting the optional parameter
stopSparkContext to false)
• A SparkContext can be reused to create multiple StreamingContexts, as
long as the previous StreamingContext is stopped (without stopping the
SparkContext)
277. Ex
RDD, P1
W
Driver
RDD, P2
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
RDD, P3
W
RDD, P4
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Batch interval = 600 ms
R
localhost 9999
278. Ex
RDD, P1
W
Driver
RDD, P2
block, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
RDD, P3
W
RDD, P4
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
200 ms later
Ex
W
block, P2 T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
block, P2
Batch interval = 600 ms
279. Ex
RDD, P1
W
Driver
RDD, P2
block, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
RDD, P1
W
RDD, P2
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
200 ms later
Ex
W
block, P2
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
block, P2
Batch interval = 600 ms
block, P3
block, P3
280. Ex
RDD, P1
W
Driver
RDD, P2
RDD, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
RDD, P1
W
RDD, P2
RDD, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Ex
W
RDD, P2
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
RDD, P2
Batch interval = 600 ms
RDD, P3
RDD, P3
281. Ex
RDD, P1
W
Driver
RDD, P2
RDD, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
RDD, P1
W
RDD, P2
RDD, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Ex
W
RDD, P2
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
RDD, P2
Batch interval = 600 ms
RDD, P3
RDD, P3
285. Ex
W
Driver
block, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
W
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Batch interval = 600 ms
Ex
W
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
R
block, P1
2 input DStreams
286. Ex
W
Driver
block, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
W
block, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Ex
W
block, P1 T
Internal
Threads
SSD SSDOS Disk
T T
T T
R
block, P1
Batch interval = 600 ms
block, P2
block, P3
block, P2
block, P3
block, P2
block, P3
block, P2 block, P3
287. Ex
W
Driver
RDD, P1
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
W
RDD, P1
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Ex
W
RDD, P1 T
Internal
Threads
SSD SSDOS Disk
T T
T T
R
RDD, P1
Batch interval = 600 ms
RDD, P2
RDD, P3
RDD, P2
RDD, P3
RDD, P2
RDD, P3
RDD, P2 RDD, P3
Materialize!
288. Ex
W
Driver
RDD, P3
T R
Internal
Threads
SSD SSDOS Disk
T T
T T Ex
W
RDD, P4
T
Internal
Threads
SSD SSDOS Disk
T T
T T
T
Ex
W
RDD, P3 T
Internal
Threads
SSD SSDOS Disk
T T
T T
R
RDD, P6
Batch interval = 600 ms
RDD, P4
RDD, P5
RDD, P2
RDD, P2
RDD, P5
RDD, P1
RDD, P1 RDD, P6
Union!
289. Stream–stream Unions
val numStreams = 5
val kafkaStreams = (1 to numStreams).map { i => KafkaUtils.createStream(...) }
val unifiedStream = streamingContext.union(kafkaStreams)
unifiedStream.print()
290. Stream–stream Joins
val stream1: DStream[String, String] = ...
val stream2: DStream[String, String] = ...
val joinedStream = stream1.join(stream2)
291. - File systems
- Socket Connections
- Kafka
- Flume
- Twitter
Sources directly available
in StreamingContext API
Requires linking against
extra dependencies
- Anywhere
Requires implementing
user-defined receiver
val logData = ssc.textFileStream(logDirectory)
296. updateStateByKey( )
To use:
1) Define the state
(an arbitrary data type)
2) Define the state update function
(specify with a function how to update the state using the
previous state and new values from the input stream)
: allows you to maintain arbitrary state while
continuously updating it with new information
def updateFunction(newValues, runningCount):
if runningCount is None:
runningCount = 0
return sum(newValues, runningCount) # add the
# new values with the previous running count
# to get the new count
To maintain a running count of each word seen
in a text data stream (here running count is an
integer type of state):
runningCounts = pairs.updateStateByKey(updateFunction)
pairs = (word, 1)
(cat, 1)
*
* Requires a checkpoint directory to be
configured
297. For example:
- Functionality to join every batch in a
data stream with another dataset is not
directly exposed in the DStream API.
- If you want to do real-time data
cleaning by joining the input data
stream with pre-computed spam
information and then filtering based on it.
: can be used to apply any RDD operation that
is not exposed in the DStream API.
spamInfoRDD = sc.pickleFile(...) # RDD containing spam information
# join data stream with spam information to do data cleaning
cleanedDStream = wordCounts.transform(lambda rdd:
rdd.join(spamInfoRDD).filter(...))
transform( )
RDD
RDD
or
MLlib GraphX
298. Original
DStream
RDD 4 RDD 5 RDD 6
Windowed
DStream
RDD 1 RDD 2 RDD 3
RDD X
time 1 time 2 time 3 time 4 time 5 time 6
RDD Y
RDD @ 3
RDD @ 5
Window Length: 3 time units
Sliding Interval: 2 time units
*
*
*Both of these must be multiples of the
batch interval of the source DSTream