Skip to content

Data Science › Data Engineering › Spark 與 PySpark

Spark 與 PySpark ​

Apache Spark 是分散式資料處理引擎:把資料切成 partition 分散到多台機器,以 lazy evaluation 最佳化整條計算再執行。前半是 PySpark 的核心模型(RDD、DataFrame、清理、特徵工程),後半是 Spark SQL。R 介面見 sparklyr;基因體資料見 Spark 處理基因體資料;單機放不下但不需要叢集時先看 超出記憶體的處理。

什麼時候需要 Spark ​

適合不適合
資料量或運算超過單機能處理的範圍(數百 GB 以上)資料放得進單機:pandas / Polars / DuckDB 更快更簡單
ETL 需要平行化、資料在 HDFS / S3 / Delta團隊沒有叢集維運能力、只是偶爾跑一次
想把 SQL、轉換、部分 ML 放在同一平台需要低延遲的單筆查詢(用資料庫)
名詞意義
Cluster computing多台機器的資源一起工作
Parallel computing同時做多個計算
Distributed computing網路上的多個節點合作完成任務
系統特性
Hadoop MapReduce可擴充、容錯;每步寫回磁碟,偏傳統 batch
Apache Spark記憶體內運算、較高階的 API;batch、SQL、streaming、ML 同一生態;支援 Python、Scala、Java、R、SQL

執行架構 ​

text
Driver(你的程式、SparkSession、規劃 DAG)
   │  切成 stages / tasks
   ├── Executor 1:處理 partition 1, 4, ...
   ├── Executor 2:處理 partition 2, 5, ...
   └── Executor 3:...
概念意義影響
Partition資料的邏輯切分單位,一個 task 處理一個決定平行度;太少用不滿核心,太多 overhead 大
Transformation產生新的 DataFrame / RDD(select、filter、join)lazy:只記錄步驟
Action觸發計算或回傳結果(count、show、collect、write)真正執行
Narrow vs widenarrow(filter、select)不需搬資料;wide(groupBy、join、orderBy)需要 shuffleshuffle 是最主要的效能成本

lazy evaluation 讓 Spark 把多個步驟合併、把篩選推到讀取階段 (predicate pushdown)、只讀需要的欄。代價是錯誤常在 action 時才出現,而且同一個 DataFrame 被多次 action 會重算整條鏈。

模式用途
Local mode單機,測試、除錯、原型
Cluster mode多台機器(YARN、Kubernetes、Databricks),正式資料

程式通常不必大改就能從 local 搬到 cluster。

入口:SparkSession ​

python
from pyspark.sql import SparkSession

spark = (SparkSession.builder
         .appName("expr-etl")
         .config("spark.sql.shuffle.partitions", "200")   # shuffle 後的 partition 數
         .getOrCreate())                                   # 已有 session 就重用
sc = spark.sparkContext                                    # RDD 世界的入口(較少直接用)
spark.version

SparkContext(sc)是傳統的 RDD 入口;SparkSession(spark)是 DataFrame 與 SQL 的入口,現代工作流都從這裡開始。

RDD vs DataFrame ​

面向RDD (Resilient Distributed Dataset)DataFrame
抽象層級低:分散的 Python 物件集合高:有 schema、具名欄位的分散表格
最佳化幾乎沒有(Spark 看不懂你的 lambda)Catalyst 最佳化器 + Tungsten 執行
Python 效能資料要在 JVM 與 Python 間序列化,慢內建函式在 JVM 執行,快
用途理解分散式模型、特殊低階處理ETL、分析、特徵整理、SQL
python
# RDD:了解即可
rdd = sc.parallelize(range(10), numSlices=4)
rdd.map(lambda x: x * x).filter(lambda x: x % 2 == 0).collect()   # [0, 4, 16, 36, 64]
rdd.getNumPartitions()                                             # 4

讀取與 schema ​

python
from pyspark.sql.types import StructType, StructField, StringType, DoubleType, IntegerType

schema = StructType([
    StructField("sample_id", StringType(), nullable=False),
    StructField("gene", StringType(), nullable=False),
    StructField("count", IntegerType(), nullable=True),
    StructField("tpm", DoubleType(), nullable=True),
])

df = spark.read.csv("expr/*.csv.gz", header=True, schema=schema, comment="#")
# 沒給 schema 也沒 inferSchema=True 時,所有欄位都是字串
df = spark.read.parquet("expr_parquet/")        # Parquet 自帶 schema,最常用
df = spark.read.json("events.jsonl")            # 每行一筆 JSON

df.printSchema(); df.columns; df.count(); df.show(5); df.describe("tpm").show()
明確定義 schema 的好處不定義的代價
讀取快(不必掃一遍推斷型別)inferSchema 要多掃一次資料
一開始就擋下格式不對的資料錯誤延後到下游才出現
ID 欄保持字串("001" 不變 1)型別推斷因檔案而異

中間結果寫成 Parquet 後,下游不必再猜 schema;這通常比 cache() 更穩。

DataFrame 常用操作與清理 ​

python
from pyspark.sql import functions as F

clean = (df
    .where(F.col("gene").isNotNull())
    .dropDuplicates(["sample_id", "gene"])                     # 不保證保留哪一筆
    .withColumn("gene", F.upper(F.trim("gene")))
    .withColumn("log_tpm", F.log2(F.col("tpm") + 1))
    .withColumn("expressed", F.when(F.col("tpm") > 1, 1).otherwise(0))
    .withColumnRenamed("count", "raw_count")
    .na.fill({"raw_count": 0})                                  # 依欄位補值;na.drop() 丟掉含 null 的列
    .drop("tpm"))

# 字串與陣列
parts = df.withColumn("fields", F.split("info", ";"))
parts.select(F.size("fields").alias("n"), F.col("fields").getItem(0).alias("first"))

# 聚合與 join
per_gene = clean.groupBy("gene").agg(F.mean("log_tpm").alias("mean_log_tpm"),
                                     F.countDistinct("sample_id").alias("n_samples"))
annotated = clean.join(F.broadcast(meta), on="sample_id", how="left")   # 小表 broadcast,避免 shuffle
原則理由
能用 pyspark.sql.functions 就不要寫 Python UDFUDF 要把資料序列化到 Python,慢且無法最佳化
非寫 UDF 不可時用 pandas UDF(@F.pandas_udf)以 Arrow 批次傳輸,比逐列 UDF 快很多
dropDuplicates() 前先定義保留規則重複列品質不同時,用 ROW_NUMBER() 依規則保留
join 後檢查列數key 不唯一時列數膨脹,不會報錯
不要對大表 collect() / toPandas()把分散的資料全拉回 driver,常直接記憶體不足

快取 (Caching) ​

python
clean.cache()          # 標記要保留(lazy)
clean.count()          # 第一次 action 才 materialize
clean.is_cached        # True
clean.unpersist()      # 用完釋放

只有同一份中間結果會被多次 action 或多個分支重用、重算成本高時才值得快取。cache() 不是鎖定記憶體:記憶體壓力大時各 worker 會以類似 LRU 的方式逐出。資料太大或只能落到慢磁碟時,寫成 Parquet 再讀回通常更穩定。

特徵工程與 MLlib ​

步驟工具
確認環境、抽查欄位spark.version、select().show()
去重、移除常數 / 錯誤欄dropDuplicates()、drop()
缺值診斷F.sum(F.col(c).isNull().cast("int"));或 sample() 一小部分轉 pandas 畫 heatmap
衍生特徵withColumn() 算術、F.log() 處理偏態
二元化 / 分箱Binarizer、Bucketizer、QuantileDiscretizer
類別編碼StringIndexer → OneHotEncoder
組成特徵向量VectorAssembler(MLlib 模型需要單一 features 欄)
python
from pyspark.ml import Pipeline
from pyspark.ml.feature import StringIndexer, OneHotEncoder, VectorAssembler, StandardScaler
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.evaluation import BinaryClassificationEvaluator

pipe = Pipeline(stages=[
    StringIndexer(inputCol="tissue", outputCol="tissue_idx", handleInvalid="keep"),
    OneHotEncoder(inputCols=["tissue_idx"], outputCols=["tissue_ohe"]),
    VectorAssembler(inputCols=["age", "mean_log_tpm", "tissue_ohe"], outputCol="raw"),
    StandardScaler(inputCol="raw", outputCol="features"),
    LogisticRegression(labelCol="label", featuresCol="features"),
])

# 有時間軸時依時間切,而不是 randomSplit,避免時間洩漏
cutoff = "2025-01-01"
train, test = data.where(F.col("date") < cutoff), data.where(F.col("date") >= cutoff)

model = pipe.fit(train)                 # 編碼與標準化參數只從訓練集學
pred = model.transform(test)
BinaryClassificationEvaluator(labelCol="label").evaluate(pred)    # 預設 areaUnderROC

把轉換放進 Pipeline 的價值在於訓練與推論用同一套邏輯,而且參數只從訓練集學到,避免 資料洩漏。MLlib 不見得比 scikit-learn 好,它的優勢是在叢集上處理單機放不下的資料,並與 Spark 的資料處理接在一起;資料聚合到放得進記憶體後,轉 pandas 用 scikit-learn 通常更方便。

Spark SQL ​

Spark SQL 把 DataFrame 與 SQL 接起來:spark.sql() 與 DataFrame API 在同一個執行引擎上,經過同一個最佳化器,效能相同。用哪個看哪一段寫起來最清楚。

python
df.createOrReplaceTempView("schedule")          # temp view:session 內的 SQL 別名

spark.sql("SHOW COLUMNS FROM schedule").show()
spark.sql("DESCRIBE schedule").show()           # 欄名與型別,不必拉資料

result = spark.sql("""
    SELECT train_id, station, time,
           ROW_NUMBER() OVER (PARTITION BY train_id ORDER BY time)  AS stop_no,
           LEAD(time, 1) OVER (PARTITION BY train_id ORDER BY time) AS time_next
    FROM schedule
    WHERE station IS NOT NULL
""")

# SQL 與 DataFrame API 混用
result.where("stop_no <= 3").groupBy("train_id").count()

同樣的 window 用 DataFrame API:

python
from pyspark.sql import Window

w = Window.partitionBy("train_id").orderBy("time")
df = (df.withColumn("stop_no", F.row_number().over(w))
        .withColumn("time_next", F.lead("time", 1).over(w)))
SQLPySpark
OVER (PARTITION BY a ORDER BY b)Window.partitionBy("a").orderBy("b")
ROW_NUMBER()、LAG()、LEAD()F.row_number()、F.lag()、F.lead()
CASE WHEN ... THEN ... ELSE ... ENDF.when(...).otherwise(...)

window 的細節(frame、RANGE 陷阱、每組 top-N)見 Window Functions。

文字處理 ​

python
text = spark.read.text("sherlock.txt")          # 單欄 value,每列是原檔一行
words = (text
    .select(F.lower("value").alias("v"))
    .select(F.regexp_replace("v", r"[^a-z\s]", "").alias("v"))
    .select(F.explode(F.split("v", r"\s+")).alias("word"))
    .where(F.col("word") != ""))
words.groupBy("word").count().orderBy(F.desc("count")).show(10)

保持在 DataFrame 內用內建函式逐步轉換,最後才聚合。

Spark SQL vs Databricks SQL ​

Spark SQLDatabricks SQL
層次Spark 引擎內的查詢介面Databricks 平台上的 SQL-first 分析層
用法notebook / PySpark 中的 spark.sql()SQL warehouse、dashboard、BI 連線、表維護

見 Databricks。

效能檢查清單 ​

症狀可能原因做法
某幾個 task 特別久data skew:少數 key 資料特別多對熱門 key 加鹽 (salting)、開啟 AQE skew join
shuffle 量很大大表對大表 join、多次 groupBy小表 broadcast();先篩選再 join
大量小檔案每個 partition 寫一個檔寫出前 coalesce() / repartition()
同一段重算很多次多次 action、沒有快取cache() 或寫出中間 Parquet
driver 記憶體不足collect() / toPandas() 大表在 Spark 內聚合,只拉回小結果
Python UDF 很慢逐列序列化改用內建函式或 pandas UDF

用 df.explain() 看執行計畫,Spark UI(預設 localhost:4040)看各 stage 的時間與 shuffle 量。Spark 3 起預設開啟 Adaptive Query Execution (AQE),會在執行中自動合併小 partition、處理 skew join。