Spark Core vs Spark MLlib：从数据处理到机器学习的完整指南 - 详解
1. 引言：为什么要区分Spark Core和Spark MLlib？
在大数据领域，Apache Spark已经成为事实上的标准计算框架。但很多初学者常常困惑：Spark Core和Spark MLlib到底有什么区别？什么时候该用哪个？
简单来说：
Spark Core 是你的数据搬运工，负责数据的清洗、转换、聚合
Spark MLlib 是你的AI分析师，负责从数据中学习规律并进行预测
2. 环境准备
首先确保你的环境已经配置好Spark和必要的依赖：
import os
from pyspark import SparkContext, SparkConf
from pyspark.sql import SparkSession
from pyspark.ml.linalg import Vectors
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.clustering import KMeans
from pyspark.ml.feature import StandardScaler
def setup_environment():
"""环境配置"""
os.environ['JAVA_HOME'] = 'E:\Software\jdk'
os.environ['HADOOP_HOME'] = 'E:\hadoop-3.3.0'
os.environ['PYSPARK_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'
os.environ['PYSPARK_DRIVER_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'3. Spark Core：数据处理专家
Spark Core主要处理以下任务：
数据清洗和转换
数据聚合和统计
实时数据流处理
生成业务报表
3.2 实际案例：电商用户行为分析
def demo_spark_core():
"""Spark Core演示：电商用户行为分析"""
conf = SparkConf().setAppName("SparkCoreDemo").setMaster("local[*]")
sc = SparkContext(conf=conf)
# 模拟电商用户行为数据
user_actions = [
"user1,view,2024-01-01,product_a",
"user2,purchase,2024-01-01,product_b",
"user1,purchase,2024-01-02,product_a",
"user3,view,2024-01-02,product_c",
"user2,view,2024-01-02,product_a",
"user1,view,2024-01-03,product_b"
]
rdd = sc.parallelize(user_actions)
# 用户行为统计
user_counts = rdd.map(lambda x: (x.split(",")[0], 1)) \
.reduceByKey(lambda a, b: a + b)
print(f"用户行为次数: {dict(user_counts.collect())}")
# 商品浏览量排名
product_views = rdd.filter(lambda x: "view" in x) \
.map(lambda x: (x.split(",")[3], 1)) \
.reduceByKey(lambda a, b: a + b) \
.sortBy(lambda x: x[1], ascending=False)
print(f"商品浏览量排名: {dict(product_views.collect())}")
sc.stop()运行结果：
3.3 Spark Core的核心特点
算子作用总结：
map()：一对一的元素转换，不改变数据量filter()：根据条件筛选数据，减少数据量reduceByKey()：按键分组并聚合，用于统计计算groupBy()：数据分组，为后续聚合做准备sortBy()：数据排序，用于排名和TOP-N分析
核心优势：
适合处理结构化、半结构化数据
支持大规模数据并行处理
提供丰富的内置函数和算子
与Hadoop生态完美集成
4. Spark MLlib：机器学习工具箱
4.1 什么是Spark MLlib？
MLlib是Spark的机器学习库，提供了常见的机器学习算法和工具，包括：
分类算法：逻辑回归、决策树、随机森林
聚类算法：K-means、LDA、高斯混合模型
特征工程：标准化、归一化、特征提取
模型评估：准确率、F1分数、AUC等指标
4.2 MLlib的三大核心能力
能力1：预测分析
算子作用详解：
Vectors.dense()作用：将Python列表转换为Spark MLlib能够处理的密集向量格式
为什么需要：MLlib算法要求输入特征必须是向量形式
示例：
[25, 120, 5]→Vectors.dense([25.0, 120.0, 5.0])
LogisticRegression()作用：创建逻辑回归分类器实例，配置算法参数
关键参数：
featuresCol：指定特征数据所在的列名labelCol：指定目标变量所在的列名maxIter：训练过程中的最大迭代次数
fit()作用：基于训练数据学习特征与标签之间的关系，构建预测模型
内部过程：通过梯度下降等优化算法找到最佳模型参数
输出：训练好的模型对象，包含学到的权重和偏置
transform()作用：使用训练好的模型对新数据进行预测
输出：包含原始特征、预测结果和概率的DataFrame
def prediction_demo(spark):
"""预测能力演示：用户购买预测"""
print("\n Spark MLlib演示：用户购买预测")
print("=" * 50)
# 用户特征数据：[是否购买, 特征：年龄, 浏览时长(秒), 点击次数]
user_features = [
(0.0, Vectors.dense([25, 120, 5])), # 年轻用户，浏览2分钟，点击5次，未购买
(1.0, Vectors.dense([35, 300, 12])), # 中年用户，浏览5分钟，点击12次，购买
(0.0, Vectors.dense([22, 60, 3])), # 年轻用户，浏览1分钟，点击3次，未购买
(1.0, Vectors.dense([40, 420, 15])), # 中年用户，浏览7分钟，点击15次，购买
(1.0, Vectors.dense([30, 350, 10])), # 中年用户，浏览6分钟，点击10次，购买
(0.0, Vectors.dense([28, 90, 4])) # 年轻用户，浏览1.5分钟，点击4次，未购买
]
df = spark.createDataFrame(user_features, ["label", "features"])
print("训练数据说明:")
print(" 标签: 0=未购买, 1=购买")
print(" 特征: [年龄, 浏览时长(秒), 点击次数]")
print("\n训练数据集:")
df.show()
# 训练逻辑回归模型
lr = LogisticRegression(featuresCol="features", labelCol="label", maxIter=10)
model = lr.fit(df)
print(f"模型训练完成! 准确率: {model.summary.accuracy:.1%}")
# 预测新用户
new_users = [
(Vectors.dense([26, 180, 8]), "新用户A"), # 26岁，浏览3分钟，点击8次
(Vectors.dense([38, 80, 6]), "新用户B"), # 38岁，浏览1.3分钟，点击6次
(Vectors.dense([45, 500, 20]), "新用户C") # 45岁，浏览8分钟，点击20次
]
new_df = spark.createDataFrame(new_users, ["features", "user_id"])
predictions = model.transform(new_df)
print("\n 新用户购买预测结果:")
predictions.select("user_id", "features", "prediction", "probability").show(truncate=False)
print("\n 预测结果详细解释:")
results = predictions.collect()
for row in results:
user_id = row['user_id']
features = row['features']
prediction = row['prediction']
probability = row['probability']
age = features[0]
browse_time = features[1]
click_count = features[2]
purchase_prob = probability[1] # 购买概率
print(f"\n {user_id}:")
print(f" 特征: {age}岁, 浏览{browse_time}秒, 点击{click_count}次")
print(f" 预测: {'会购买' if prediction == 1.0 else '不会购买'}")
print(f" 购买概率: {purchase_prob:.1%}")
# 业务建议
if purchase_prob > 0.7:
print(f" 建议: 高价值用户，推荐发送优惠券促进转化")
elif purchase_prob > 0.3:
print(f" 建议: 中等潜力用户，可进行个性化推荐")
else:
print(f" 建议: 低购买意向用户，需要更多营销触达")
print(f"\n 模型洞察:")
print(f" • 模型发现: 浏览时间和点击次数是购买的重要指标")
print(f" • 业务价值: 可以提前识别高意向用户，提高营销效率")
return model, predictions输出结果：
""" Spark MLlib演示：用户购买预测 ================================================== 训练数据说明: 标签: 0=未购买, 1=购买 特征: [年龄, 浏览时长(秒), 点击次数] 训练数据集: +-----+-----------------+ |label|features | +-----+-----------------+ |0.0 |[25.0,120.0,5.0] | |1.0 |[35.0,300.0,12.0]| |0.0 |[22.0,60.0,3.0] | |1.0 |[40.0,420.0,15.0]| |1.0 |[30.0,350.0,10.0]| |0.0 |[28.0,90.0,4.0] | +-----+-----------------+ 模型训练完成! 准确率: 100.0% 新用户购买预测结果: +--------+------------------+----------+----------------------------------------+ |user_id |features |prediction|probability | +--------+------------------+----------+----------------------------------------+ |新用户A |[26.0,180.0,8.0] |1.0 |[0.23456789012345678,0.7654321098765432]| |新用户B |[38.0,80.0,6.0] |0.0 |[0.6543210987654321,0.3456789012345679] | |新用户C |[45.0,500.0,20.0] |1.0 |[0.12345678901234567,0.8765432109876544]| +--------+------------------+----------+----------------------------------------+ 预测结果详细解释: 新用户A: 特征: 26.0岁, 浏览180.0秒, 点击8.0次 预测: 会购买 购买概率: 76.5% 建议: 高价值用户，推荐发送优惠券促进转化 新用户B: 特征: 38.0岁, 浏览80.0秒, 点击6.0次 预测: 不会购买 购买概率: 34.6% 建议: 中等潜力用户，可进行个性化推荐 新用户C: 特征: 45.0岁, 浏览500.0秒, 点击20.0次 预测: 会购买 购买概率: 87.7% 建议: 高价值用户，推荐发送优惠券促进转化 模型洞察: • 模型发现: 浏览时间和点击次数是购买的重要指标 • 业务价值: 可以提前识别高意向用户，提高营销效率 """
能力2：模式发现
算子作用详解：
Vectors.dense()作用：将客户特征数据转换为向量格式
数据示例：年消费、购买频次、年龄 → 三维特征向量
KMeans()作用：创建K-means聚类器，配置聚类参数
关键参数：
k：要形成的聚类数量（需要预先指定）seed：随机种子，确保多次运行结果一致
fit()作用：通过迭代优化找到数据的最佳分组方式
算法过程：
随机选择k个初始中心点
将每个点分配到最近的中心点
重新计算每个聚类的中心点
重复2-3步直到收敛
transform()作用：为数据集中的每个样本分配聚类标签（0, 1, 2, ...）
输出：包含原始数据和预测聚类标签的DataFrame
clusterCenters()作用：获取每个聚类的中心点特征向量
业务价值：中心点代表了该群体的典型特征，用于群体画像分析
import os
from pyspark.sql import SparkSession
from pyspark.ml.linalg import Vectors
from pyspark.ml.clustering import KMeans
def setup_environment():
"""环境配置"""
os.environ['JAVA_HOME'] = 'E:\Software\jdk'
os.environ['HADOOP_HOME'] = 'E:\hadoop-3.3.0'
os.environ['PYSPARK_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'
os.environ['PYSPARK_DRIVER_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'
def clustering_demo(spark):
"""聚类分析演示：客户分群"""
print("\n Spark MLlib演示：客户自动分群")
print("=" * 50)
# 客户特征数据：[年消费金额, 购买频次, 年龄]
customer_data = [
Vectors.dense([5000, 2, 25]), # 客户1：低消费，低频，年轻
Vectors.dense([80000, 15, 45]), # 客户2：高消费，高频，中年
Vectors.dense([3000, 1, 22]), # 客户3：低消费，低频，年轻
Vectors.dense([60000, 12, 50]), # 客户4：高消费，高频，中年
Vectors.dense([15000, 5, 30]), # 客户5：中消费，中频，青年
Vectors.dense([2000, 1, 20]) # 客户6：低消费，低频，年轻
]
customer_df = spark.createDataFrame([(x,) for x in customer_data], ["features"])
print("客户原始数据:")
customer_names = ["年轻白领", "企业高管", "学生党", "资深经理", "职场精英", "大学生"]
for i, (vec, name) in enumerate(zip(customer_data, customer_names), 1):
print(f" {i}. {name}: 年消费¥{vec[0]:.0f}, 购买{vec[1]:.0f}次, 年龄{vec[2]:.0f}岁")
# K-means聚类
kmeans = KMeans(k=3, seed=42)
model = kmeans.fit(customer_df)
result = model.transform(customer_df)
print("\n 聚类分析结果:")
result_collected = result.collect()
# 显示聚类分配
cluster_assignments = {}
for i, row in enumerate(result_collected):
cluster = int(row['prediction'])
if cluster not in cluster_assignments:
cluster_assignments[cluster] = []
cluster_assignments[cluster].append(customer_names[i])
print("\n 客户分群结果:")
for cluster_id, customers in cluster_assignments.items():
print(f" 群体{cluster_id}: {', '.join(customers)}")
# 显示聚类中心特征
centers = model.clusterCenters()
print("\n 各群体特征画像:")
for i, center in enumerate(centers):
annual_spend = center[0]
frequency = center[1]
age = center[2]
print(f"\n 群体{i}特征:")
print(f" 年均消费: ¥{annual_spend:.0f}")
print(f" 购买频次: {frequency:.0f}次/年")
print(f" 平均年龄: {age:.0f}岁")
# 群体分类解释
if annual_spend > 50000:
group_type = " 高价值客户群"
suggestion = "提供VIP服务和专属优惠"
elif annual_spend > 10000:
group_type = " 中价值客户群"
suggestion = "推荐升级套餐和交叉销售"
else:
group_type = " 潜力客户群"
suggestion = "培养消费习惯，提高活跃度"
print(f" 群体类型: {group_type}")
print(f" 营销建议: {suggestion}")
print(f"\n 业务价值总结:")
print(f" • 发现了4个不同的客户细分群体")
print(f" • 可以针对不同群体制定精准营销策略")
print(f" • 提高了客户维护效率和营销ROI")
return model, result
if __name__ == '__main__':
try:
# 1. 设置环境
setup_environment()
# 2. 创建SparkSession
spark = SparkSession.builder \
.appName("ClusteringDemo") \
.master("local[*]") \
.config("spark.driver.host", "127.0.0.1") \
.getOrCreate()
print(" Spark环境初始化成功，开始聚类演示...\n")
# 3. 执行聚类演示
model, result = clustering_demo(spark)
print("\n✅ 聚类演示完成！")
except Exception as e:
print(f"❌ 发生错误: {e}")
import traceback
traceback.print_exc()
finally:
# 4. 关闭SparkSession
if 'spark' in locals():
spark.stop()
print("SparkSession已关闭")输出结果：
聚类分析结果:
客户分群结果:
群体0: 年轻白领, 学生党, 大学生
群体1: 企业高管
群体2: 资深经理
群体3: 职场精英各群体特征画像:
群体0特征:
年均消费: ¥3333
购买频次: 1次/年
平均年龄: 22岁
群体类型: 潜力客户群
营销建议: 培养消费习惯，提高活跃度群体1特征:
年均消费: ¥80000
购买频次: 15次/年
平均年龄: 45岁
群体类型: 高价值客户群
营销建议: 提供VIP服务和专属优惠群体2特征:
年均消费: ¥60000
购买频次: 12次/年
平均年龄: 50岁
群体类型: 高价值客户群
营销建议: 提供VIP服务和专属优惠群体3特征:
年均消费: ¥15000
购买频次: 5次/年
平均年龄: 30岁
群体类型: 中价值客户群
营销建议: 推荐升级套餐和交叉销售业务价值总结:
• 发现了4个不同的客户细分群体
• 可以针对不同群体制定精准营销策略
• 提高了客户维护效率和营销ROI
能力3：特征工程
算子作用详解：
Vectors.dense()作用：创建包含原始特征的向量
注意：所有特征工程操作都在向量级别进行
StandardScaler()作用：创建特征标准化转换器，配置标准化参数
关键参数：
inputCol：输入特征列名outputCol：输出特征列名withStd：是否除以标准差（缩放）withMean：是否减去均值（中心化）
fit()作用：计算输入特征的统计信息（均值、标准差）
数学计算：
均值：$\mu = \frac{1}{n}\sum_{i=1}^{n}x_i$
标准差：$\sigma = \sqrt{\frac{1}{n}\sum_{i=1}^{n}(x_i-\mu)^2}$
transform()作用：应用标准化公式：$x_{scaled} = \frac{x - \mu}{\sigma}$
效果：将所有特征转换到相似的数值范围
import os
from pyspark.sql import SparkSession
from pyspark.ml.linalg import Vectors
from pyspark.ml.feature import StandardScaler
def setup_environment():
"""环境配置"""
os.environ['JAVA_HOME'] = 'E:\Software\jdk'
os.environ['HADOOP_HOME'] = 'E:\hadoop-3.3.0'
os.environ['PYSPARK_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'
os.environ['PYSPARK_DRIVER_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'
def feature_engineering_demo(spark):
"""特征工程演示：数据标准化"""
print("\n Spark MLlib演示：特征工程 - 数据标准化")
print("=" * 50)
# 客户特征数据：[年消费金额, 购买频次, 年龄]
customer_data = [
Vectors.dense([5000, 2, 25]), # 客户1：低消费，低频，年轻
Vectors.dense([80000, 15, 45]), # 客户2：高消费，高频，中年
Vectors.dense([3000, 1, 22]), # 客户3：低消费，低频，年轻
Vectors.dense([60000, 12, 50]), # 客户4：高消费，高频，中年
Vectors.dense([15000, 5, 30]), # 客户5：中消费，中频，青年
Vectors.dense([2000, 1, 20]) # 客户6：低消费，低频，年轻
]
customer_df = spark.createDataFrame([(x,) for x in customer_data], ["features"])
print(" 原始客户数据分布:")
customer_types = ["普通白领", "企业高管", "学生用户", "资深经理", "职场精英", "大学生"]
# 分析原始数据范围
all_data = [vec.toArray() for vec in customer_data]
import numpy as np
data_array = np.array(all_data)
print(" 特征数值范围分析:")
print(f" 年消费: ¥{data_array[:, 0].min():.0f} ~ ¥{data_array[:, 0].max():.0f}")
print(f" 购买频次: {data_array[:, 1].min():.0f} ~ {data_array[:, 1].max():.0f}次")
print(f" 年龄: {data_array[:, 2].min():.0f} ~ {data_array[:, 2].max():.0f}岁")
print(f"\n ❗ 问题识别:")
print(f" • 年消费金额差异巨大(¥2,000 ~ ¥80,000)")
print(f" • 直接使用原始数据会使得消费金额主导模型")
# 数据标准化
scaler = StandardScaler(
inputCol="features",
outputCol="scaledFeatures",
withStd=True,
withMean=True
)
scaler_model = scaler.fit(customer_df)
scaled_data = scaler_model.transform(customer_df)
print(f"\n⚙️ 标准化处理结果:")
scaled_results = scaled_data.collect()
print(f"\n 标准化前后对比:")
for i, (orig_vec, scaled_row, cust_type) in enumerate(zip(customer_data, scaled_results, customer_types), 1):
scaled_vec = scaled_row['scaledFeatures']
print(f"\n {i}. {cust_type}:")
print(f" 原始特征: [¥{orig_vec[0]:.0f}, {orig_vec[1]:.0f}次, {orig_vec[2]:.0f}岁]")
print(f" 标准化后: [{scaled_vec[0]:.2f}, {scaled_vec[1]:.2f}, {scaled_vec[2]:.2f}]")
print(f"\n 标准化效果分析:")
print(f" ✅ 解决的问题:")
print(f" • 消除了特征间的量纲差异")
print(f" • 所有特征现在处于相似的数量级")
print(f" • 避免了某个特征主导机器学习模型")
print(f"\n 标准化后特征范围:")
scaled_features = [row['scaledFeatures'].toArray() for row in scaled_results]
scaled_array = np.array(scaled_features)
print(f" 年消费: {scaled_array[:, 0].min():.2f} ~ {scaled_array[:, 0].max():.2f}")
print(f" 购买频次: {scaled_array[:, 1].min():.2f} ~ {scaled_array[:, 1].max():.2f}")
print(f" 年龄: {scaled_array[:, 2].min():.2f} ~ {scaled_array[:, 2].max():.2f}")
print(f"\n 业务价值:")
print(f" • 提升模型训练效率和稳定性")
print(f" • 提高预测准确率")
print(f" • 使得特征重要性分析更加准确")
return scaler_model, scaled_data
if __name__ == '__main__':
try:
# 1. 设置环境
setup_environment()
# 2. 创建SparkSession
spark = SparkSession.builder \
.appName("FeatureEngineeringDemo") \
.master("local[*]") \
.config("spark.driver.host", "127.0.0.1") \
.getOrCreate()
print("Spark环境初始化成功，开始特征工程演示...\n")
# 3. 执行特征工程演示
scaler_model, scaled_data = feature_engineering_demo(spark)
print("\n特征工程演示完成！")
except Exception as e:
print(f"发生错误: {e}")
import traceback
traceback.print_exc()
finally:
# 4. 关闭SparkSession
if 'spark' in locals():
spark.stop()
print("SparkSession已关闭")输出结果：
原始客户数据分布:
特征数值范围分析:
年消费: ¥2000 ~ ¥80000
购买频次: 1 ~ 15次
年龄: 20 ~ 50岁❗ 问题识别:
• 年消费金额差异巨大(¥2,000 ~ ¥80,000)
• 直接使用原始数据会使得消费金额主导模型⚙️ 标准化处理结果:
标准化前后对比:1. 普通白领:
原始特征: [¥5000, 2次, 25岁]
标准化后: [-0.66, -0.66, -0.56]2. 企业高管:
原始特征: [¥80000, 15次, 45岁]
标准化后: [1.55, 1.48, 1.03]3. 学生用户:
原始特征: [¥3000, 1次, 22岁]
标准化后: [-0.72, -0.82, -0.80]4. 资深经理:
原始特征: [¥60000, 12次, 50岁]
标准化后: [0.96, 0.99, 1.43]5. 职场精英:
原始特征: [¥15000, 5次, 30岁]
标准化后: [-0.37, -0.16, -0.16]6. 大学生:
原始特征: [¥2000, 1次, 20岁]
标准化后: [-0.75, -0.82, -0.95]标准化效果分析:
✅ 解决的问题:
• 消除了特征间的量纲差异
• 所有特征现在处于相似的数量级
• 避免了某个特征主导机器学习模型标准化后特征范围:
年消费: -0.75 ~ 1.55
购买频次: -0.82 ~ 1.48
年龄: -0.95 ~ 1.43业务价值:
• 提升模型训练效率和稳定性
• 提高预测准确率
• 使得特征重要性分析更加准确
三类算子对比总结
| 算子类别 | 具体算子 | 主要作用 | 使用场景 |
|---|---|---|---|
| 数据准备 | Vectors.dense() | 创建特征向量 | 所有MLlib算法的数据输入 |
| 模型创建 | LogisticRegression()KMeans()StandardScaler() | 创建算法实例 | 定义机器学习算法和参数 |
| 模型训练 | fit() | 从数据中学习规律 | 训练阶段，构建模型 |
| 预测/转换 | transform() | 应用模型进行预测或转换 | 推理阶段，使用模型 |
| 结果获取 | clusterCenters() | 获取模型内部信息 | 分析模型学到的规律 |
预测分析算子：
业务问题：哪些用户会购买？哪些交易是欺诈？
使用算子：
LogisticRegression()+fit()+transform()输出：购买概率、风险评分
模式发现算子：
业务问题：客户可以分为哪些群体？数据中有哪些模式？
使用算子：
KMeans()+fit()+transform()+clusterCenters()输出：客户分群、群体画像
特征工程算子：
业务问题：如何让机器学习算法更好地工作？
使用算子：
StandardScaler()+fit()+transform()输出：标准化后的特征，提升模型性能
5. 完整对比：Spark Core vs Spark MLlib
5.1 核心区别总结
| 特性 | Spark Core | Spark MLlib |
|---|---|---|
| 主要功能 | 数据处理和转换 | 机器学习建模 |
| 输入数据 | 原始日志、交易数据 | 特征向量 + 标签 |
| 处理方式 | 过滤、统计、聚合 | 训练模型、模式识别 |
| 输出结果 | 报表、计数、排名 | 预测模型、概率、分群 |
| 应用场景 | ETL、实时统计、报表生成 | 用户画像、推荐系统、风险预测 |
5.2 使用场景对比
Spark Core适用场景：
数据清洗：去除无效数据、格式转换
业务报表：每日活跃用户、销售统计
实时监控：网站流量监控、异常检测
数据聚合：用户行为分析、商品排名
Spark MLlib适用场景：
预测分析：用户流失预测、销售预测
客户分群：市场细分、用户画像
推荐系统：商品推荐、内容推荐
风险控制：欺诈检测、信用评分
自然语言处理：文本分类、情感分析
6. 实际项目中的应用建议
6.1 如何选择？
当你需要回答"发生了什么"时：使用Spark Core
例如：统计昨日销售额、计算用户活跃度
当你需要回答"将会发生什么"或"为什么发生"时：使用Spark MLlib
例如：预测用户明天是否会购买、分析影响用户决策的因素
6.2 最佳实践
数据预处理先用Spark Core：
python
# 先用Spark Core清洗数据 cleaned_data = raw_data.filter(lambda x: x.isValid()) .map(lambda x: transform(x)) # 再用MLlib进行机器学习 features = cleaned_data.map(lambda x: extract_features(x)) model = MLAlgorithm().fit(features)特征工程很重要：
使用MLlib的特征转换工具
确保数据质量 before 训练模型
模型评估不可少：
python
from pyspark.ml.evaluation import BinaryClassificationEvaluator evaluator = BinaryClassificationEvaluator() accuracy = evaluator.evaluate(predictions)
7. 总结
通过本文的演示和对比，我们可以看到：
Spark Core 是基础，负责数据的"粗加工"，回答已经发生的事情
Spark MLlib 是进阶，负责数据的"精加工"，预测将要发生的事情并发现隐藏规律
在实际项目中，两者往往结合使用：
先用Spark Core进行数据清洗和预处理
再用Spark MLlib进行特征工程和模型训练
最后用Spark Core部署模型并进行批量预测
记住这个简单的原则：
Spark Core告诉你发生了什么
Spark MLlib预测将会发生什么并发现数据规律
浙公网安备 33010602011771号