PySpark persist is a way of caching the intermediate results in specified storage levels so that any operations on persisted results would improve the performance in terms of memory usage and time. Since each action triggers all transformations that were performed on the lineage, if you have not designed the jobs to reuse the repeating computations you will see degrade in performance when you are dealing with billions or trillions of data.
Hence, we may need to look at the stages and use optimization techniques as one of the ways to improve performance.
Related: PySpark cache() with example
Though PySpark provides computation 100 x times faster than traditional Map Reduce jobs, If you have not designed the jobs to reuse the repeating computations you will see degrade in performance when you are dealing with billions or trillions of data. Hence, we may need to look at the stages and use optimization techniques as one of the ways to improve performance.
persist() method, PySpark provides an optimization mechanism to store the intermediate computation of a PySpark DataFrame so they can be reused in subsequent actions.
When you persist a dataset, each node stores its partitioned data in memory and reuses them in other actions on that dataset. And PySpark persisted data on nodes are fault-tolerant meaning if any partition of a Dataset is lost, it will automatically be recomputed using the original transformations that created it.
1. Advantages for PySpark persist() of DataFrame
Below are the advantages of using PySpark persist() methods
- Cost-efficient – PySpark computations are very expensive hence reusing the computations are used to save cost.
- Time-efficient – Reusing repeated computations saves lots of time.
- Execution time – Saves execution time of the job and we can perform more jobs on the same cluster.
2. Usage of persist() on DataFrame.
PySpark persist() method is used to store the DataFrame to one of the storage levels
MEMORY_AND_DISK_2 and more.
Caching or persisting of PySpark DataFrame is a lazy operation, meaning a DataFrame will not be cached until you trigger an action.
# persist() Syntax DataFrame.persist(storageLevel: pyspark.storagelevel.StorageLevel = StorageLevel(True, True, False, True, 1))
PySpark persist has two signature first signature doesn’t take any argument which by default saves it to
MEMORY_AND_DISK storage level and the second signature which takes
StorageLevel as an argument to store it to different storage levels.
# Persist the DataFrame dfPersist = df.persist() dfPersist.show(false)
Using the second signature you can save DataFrame to any storage level.
# Persist the DataFrame dfPersist = df.persist(StorageLevel.MEMORY_ONLY) dfPersist.show(false)
This stores DataFrame in Memory.
Note that PySpark cache() is an alias for
Unpersist syntax and Example
PySpark automatically monitors every
persist() call you make and it checks usage on each node and drops persisted data if not used or by using the least-recently-used (LRU) algorithm. You can also manually remove using
unpersist() method. unpersist() marks the DataFrame as non-persistent, and removes all blocks for it from memory and disk.
# unpresist() Syntax DataFrame.unpersist(blocking: bool = False) → pyspark.sql.dataframe.DataFrame
# unpersist the DataFrame dfPersist = dfPersist.unpersist()
unpersist(Boolean) with boolean as argument blocks until all blocks are deleted.
PySpark Persist storage levels
All different storage level PySpark supports are available at
org.apache.spark.storage.StorageLevel class. The storage level specifies how and where to persist or cache a PySpark DataFrame.
MEMORY_ONLY – This is the default behavior of the RDD
cache() method and stores the RDD or DataFrame as deserialized objects to JVM memory. When there is not enough memory available it will not save DataFrame of some partitions and these will be re-computed as and when required. This takes more memory. but unlike RDD, this would be slower than MEMORY_AND_DISK level as it recomputes the unsaved partitions, and recomputing the in-memory columnar representation of the underlying table is expensive
MEMORY_ONLY_SER – This is the same as
MEMORY_ONLY but the difference being it stores RDD as serialized objects to JVM memory. It takes lesser memory (space-efficient) than MEMORY_ONLY as it saves objects as serialized and takes an additional few more CPU cycles in order to deserialize.
MEMORY_ONLY_2 – Same as
MEMORY_ONLY storage level but replicate each partition to two cluster nodes.
MEMORY_ONLY_SER_2 – Same as
MEMORY_ONLY_SER storage level but replicate each partition to two cluster nodes.
MEMORY_AND_DISK – This is the default behavior of the DataFrame. In this Storage Level, The DataFrame will be stored in JVM memory as a deserialized object. When required storage is greater than available memory, it stores some of the excess partitions into a disk and reads the data from the disk when required. It is slower as there is I/O involved.
MEMORY_AND_DISK_SER – This is the same as
MEMORY_AND_DISK storage level difference being it serializes the DataFrame objects in memory and on disk when space is not available.
MEMORY_AND_DISK_2 – Same as
MEMORY_AND_DISK storage level but replicate each partition to two cluster nodes.
MEMORY_AND_DISK_SER_2 – Same as
MEMORY_AND_DISK_SER storage level but replicate each partition to two cluster nodes.
DISK_ONLY – In this storage level, DataFrame is stored only on disk and the CPU computation time is high as I/O is involved.
DISK_ONLY_2 – Same as
DISK_ONLY storage level but replicate each partition to two cluster nodes.
In this article, you have learned PySpark
persist() method is used as an optimization technique to save interim computation results of DataFrame and reuse them subsequently.
- PySpark Broadcast Variable
- PySpark Broadcast Join with examples
- PySpark lag() Function
- PySpark Random Sample with Example
- PySpark reduceByKey usage with example
- Pyspark – Get substring() from a column
- Show First Top N Rows in Spark | PySpark
- PySpark Create DataFrame from List
- PySpark Concatenate Columns
- PySpark Refer Column Name With Dot (.)