[!IMPORTANT] bigdl-llm 现已更名为 ipex-llm，我们未来的开发将迁移至 IPEX-LLM 项目。

概述

BigDL 可以无缝地将您的数据分析和 AI 应用从笔记本电脑扩展到云端，提供以下库：

• LLM (已弃用 - 请改用 IPEX-LLM)：针对 Intel CPU 和 GPU 优化的大语言模型库

• Orca：基于 Spark 和 Ray 的分布式大数据与 AI（TF 和 PyTorch）流水线

• Nano：在 Intel CPU/GPU 上透明加速 TensorFlow 和 PyTorch 程序

• DLlib：深度学习领域的“Spark MLlib 对等工具”

• Chronos：使用 AutoML 进行可扩展的时间序列分析

• Friesian：端到端的推荐系统

• PPML：安全的大数据与 AI（采用 SGX/TDX 硬件安全技术）

如需更多信息，请访问 文档。

选择合适的 BigDL 库

flowchart TD;
    Feature1{{硬件安全的大数据与 AI？}};
    Feature1-- 否 -->Feature2{{Python 还是 Scala/Java？}};
    Feature1-- 是  -->ReferPPML([<em><strong>PPML</strong></em>]);
    Feature2-- Python -->Feature3{{应用类型是什么？}};
    Feature2-- Scala/Java -->ReferDLlib([<em><strong>DLlib</strong></em>]);
    Feature3-- “大语言模型” -->ReferLLM([<em><strong>LLM</strong></em>]);
    Feature3-- “大数据 + AI（TF/PyTorch）” -->ReferOrca([<em><strong>Orca</strong></em>]);
    Feature3-- 加速 TensorFlow / PyTorch -->ReferNano([<em><strong>Nano</strong></em>]);
    Feature3-- 针对 Spark MLlib 的 DL -->ReferDLlib2([<em><strong>DLlib</strong></em>]);
    Feature3-- 高层次应用框架 -->Feature4{{领域是什么？}};
    Feature4-- 时间序列 -->ReferChronos([<em><strong>Chronos</strong></em>]);
    Feature4-- 推荐系统 -->ReferFriesian([<em><strong>Friesian</strong></em>]);
    
    click ReferLLM "https://github.com/intel-analytics/ipex-llm"
    click ReferNano "https://github.com/intel-analytics/BigDL-2.x#nano"
    click ReferOrca "https://github.com/intel-analytics/BigDL-2.x#orca"
    click ReferDLlib "https://github.com/intel-analytics/BigDL-2.x#dllib"
    click ReferDLlib2 "https://github.com/intel-analytics/BigDL-2.x#dllib"
    click ReferChronos "https://github.com/intel-analytics/BigDL-2.x#chronos"
    click ReferFriesian "https://github.com/intel-analytics/BigDL-2.x#friesian"
    click ReferPPML "https://github.com/intel-analytics/BigDL-2.x#ppml"
    
    classDef ReferStyle1 fill:#5099ce,stroke:#5099ce;
    classDef Feature fill:#FFF,stroke:#08409c,stroke-width:1px;
    class ReferLLM,ReferNano,ReferOrca,ReferDLlib,ReferDLlib2,ReferChronos,ReferFriesian,ReferPPML ReferStyle1;
    class Feature1,Feature2,Feature3,Feature4,Feature5,Feature6,Feature7 Feature;
    

安装

• 建议使用 conda 环境来安装 BigDL：

  conda create -n my_env 
  conda activate my_env
  pip install bigdl
  

  如需安装最新的 nightly 版本，请使用 pip install --pre --upgrade bigdl；更多详细信息请参阅 Python 和 Scala 用户指南。

• 若要单独安装某个库，例如 Chronos，可以使用 pip install bigdl-chronos；更多详情请访问 文档网站。

入门

Orca

• Orca 库能够无缝地将您单节点的 TensorFlow、PyTorch 或 OpenVINO 程序扩展到大型集群中运行（以便处理分布式大数据）。

  显示 Orca 示例

  
  

  您可以使用 Orca 通过 4 个简单步骤构建端到端的分布式数据处理与 AI 程序：

  # 1. 初始化 Orca 上下文（以便在 K8s、YARN 或本地笔记本上运行程序）
  from bigdl.orca import init_orca_context, OrcaContext
  sc = init_orca_context(cluster_mode="k8s", cores=4，memory="10g"，num_nodes=2)
  
  # 2. 执行分布式数据处理（支持 Spark DataFrames、TensorFlow Dataset、PyTorch DataLoader、Ray Dataset、Pandas、Pillow 等）
  spark = OrcaContext.get_spark_session()
  df = spark.read.parquet(file_path)
  df = df.withColumn('label', df.label-1)
  ...
  
  # 3. 使用标准框架 API 构建深度学习模型
  # （支持 TensorFlow、PyTorch、Keras、OpenVino 等）
  from tensorflow import keras
  ...
  model = keras.models.Model(inputs=[user, item], outputs=predictions)  
  model.compile(...)
  
  # 4. 使用 Orca Estimator 进行分布式训练/推理
  from bigdl.orca.learn.tf.estimator import Estimator
  est = Estimator.from_keras(keras_model=model)  
  est.fit(data=df，
          feature_cols=['user', 'item'],
          label_cols=['label'],
          ...)
  

  有关更多详细信息，请参阅 Orca 用户指南，以及 TensorFlow 和 PyTorch 快速入门。

• 此外，您还可以使用 Orca 中的 RayOnSpark 在 Spark 集群上运行标准 Ray 程序。

  显示 RayOnSpark 示例

  
  

  您不仅可以在 Spark 集群上运行 Ray 程序，还可以使用 Orca 中的 RayOnSpark 将 Ray 代码内嵌到 Spark 代码中（以便处理内存中的 Spark RDD 或 DataFrame）。

  # 1. 初始化 Orca 上下文（以便在 K8s、YARN 或本地笔记本上运行程序）
  from bigdl.orca import init_orca_context，OrcaContext
  sc = init_orca_context(cluster_mode="yarn"，cores=4，memory="10g"，num_nodes=2，init_ray_on_spark=True)
  
  # 2. 使用 Spark 进行分布式数据处理
  spark = OrcaContext.get_spark_session()
  df = spark.read.parquet(file_path).withColumn(...)
  
  # 3. 将 Spark DataFrame 转换为 Ray 数据集
  from bigdl.orca.data import spark_df_to_ray_dataset
  dataset = spark_df_to_ray_dataset(df)
  
  # 4. 使用 Ray 操作 Ray 数据集
  import ray
  
  @ray.remote
  def consume(data) -> int:
     num_batches = 0
     for batch in data.iter_batches(batch_size=10):
         num_batches += 1
     return num_batches
  
  print(ray.get(consume.remote(dataset)))
  

  有关更多详细信息，请参阅 RayOnSpark 用户指南 和 快速入门。

Nano

您可以在笔记本电脑或服务器上使用 Nano 透明地加速您的 TensorFlow 或 PyTorch 程序。只需进行最少的代码修改，Nano 就能自动将现代 CPU 优化（例如 SIMD、多进程、低精度等）应用于标准的 TensorFlow 和 PyTorch 代码，从而实现高达 10 倍的加速。

model = ResNet18().load_state_dict(...)
train_dataloader = ...
val_dataloader = ...
def accuracy (pred, target):
  ... 

from bigdl.nano.pytorch import InferenceOptimizer
optimizer = InferenceOptimizer()
optimizer.optimize(model,
                   training_data=train_dataloader,
                   validation_data=val_dataloader,
                   metric=accuracy)
new_model, config = optimizer.get_best_model()

optimizer.summary()

 -------------------------------- ---------------------- -------------- ----------------------
|             method             |        status        | latency(ms)  |     metric value     |
 -------------------------------- ---------------------- -------------- ----------------------
|            original            |      successful      |    45.145    |        0.975         |
|              bf16              |      successful      |    27.549    |        0.975         |
|          static_int8           |      successful      |    11.339    |        0.975         |
|         jit_fp32_ipex          |      successful      |    40.618    |        0.975*        |
|  jit_fp32_ipex_channels_last   |      successful      |    19.247    |        0.975*        |
|         jit_bf16_ipex          |      successful      |    10.149    |        0.975         |
|  jit_bf16_ipex_channels_last   |      successful      |    9.782     |        0.975         |
|         openvino_fp32          |      successful      |    22.721    |        0.975*        |
|         openvino_int8          |      successful      |    5.846     |        0.962         |
|        onnxruntime_fp32        |      successful      |    20.838    |        0.975*        |
|    onnxruntime_int8_qlinear    |      successful      |    7.123     |        0.981         |
 -------------------------------- ---------------------- -------------- ----------------------
* 表示我们假设追踪模型的指标值不会改变，因此为了节省时间，不再重新计算指标值。
优化总耗时 60.8 秒。

model = ResNet18()
optimizer = torch.optim.SGD(...)
train_loader = ...
val_loader = ...

from bigdl.nano.pytorch import TorchNano

# 在 `TorchNano.train` 中定义您的训练循环
class Trainer(TorchNano):
	def train(self):
	# 调用 `setup` 准备模型、优化器和数据加载器，以便进行加速训练
	model, optimizer, (train_loader, val_loader) = self.setup(model, optimizer,
  train_loader, val_loader)
  
    for epoch in range(num_epochs):  
      model.train()  
      for data, target in train_loader:  
        optimizer.zero_grad()  
        output = model(data)  
        # 将 loss.backward() 替换为 self.backward(loss)  
        loss = loss_fuc(output, target)  
        self.backward(loss)  
        optimizer.step()   

# 加速训练（IPEX、BF16 和多实例训练）
Trainer(use_ipex=True, precision='bf16', num_processes=2).train()

请参阅 Nano 用户指南 和 教程 以获取更多详细信息。

DLlib

借助 DLlib，您可以使用标准的 (Scala 或 Python) Spark 程序，通过相同的 Spark DataFrames 和 ML Pipeline API 来编写分布式深度学习应用程序。

// 1. 在代码开头调用 `initNNContext`： 
import com.intel.analytics.bigdl.dllib.NNContext
val sc = NNContext.initNNContext()

// 2. 使用 DLlib 中的 Keras 风格 API 定义深度学习模型：
import com.intel.analytics.bigdl.dllib.keras.layers._
import com.intel.analytics.bigdl.dllib.keras.Model
val input = Input[Float](inputShape = Shape(10))  
val dense = Dense[Float](12).inputs(input)  
val output = Activation[Float]("softmax").inputs(dense)  
val model = Model(input, output)

// 3. 使用 `NNEstimator` 通过 Spark DataFrame 和 ML Pipeline API 来训练/预测/评估模型
import org.apache.spark.sql.SparkSession
import org.apache.spark.ml.feature.MinMaxScaler
import org.apache.spark.ml.Pipeline
import com.intel.analytics.bigdl.dllib.nnframes.NNEstimator
import com.intel.analytics.bigdl.dllib.nn.CrossEntropyCriterion
import com.intel.analytics.bigdl.dllib.optim.Adam
val spark = SparkSession.builder().getOrCreate()
val trainDF = spark.read.parquet("train_data")
val validationDF = spark.read.parquet("val_data")
val scaler = new MinMaxScaler().setInputCol("in").setOutputCol("value")
val estimator = NNEstimator(model, CrossEntropyCriterion())  
        .setBatchSize(128).setOptimMethod(new Adam()).setMaxEpoch(5)
val pipeline = new Pipeline().setStages(Array(scaler, estimator))

val pipelineModel = pipeline.fit(trainDF)  
val predictions = pipelineModel.transform(validationDF)

# 1. 在代码开头调用 `init_nncontext`：
from bigdl.dllib.nncontext import init_nncontext
sc = init_nncontext()

# 2. 使用 DLlib 中的 Keras 风格 API 定义深度学习模型：
from bigdl.dllib.keras.layers import Input, Dense, Activation
from bigdl.dllib.keras.models import Model
input = Input(shape=(10,))
dense = Dense(12)(input)
output = Activation("softmax")(dense)
model = Model(input, output)

# 3. 使用 `NNEstimator` 通过 Spark DataFrame 和 ML pipeline API 训练/预测/评估模型
from pyspark.sql import SparkSession
from pyspark.ml.feature import MinMaxScaler
from pyspark.ml import Pipeline
from bigdl.dllib.nnframes import NNEstimator
from bigdl.dllib.nn.criterion import CrossEntropyCriterion
from bigdl.dllib.optim.optimizer import Adam
spark = SparkSession.builder.getOrCreate()
train_df = spark.read.parquet("train_data")
validation_df = spark.read.parquet("val_data")
scaler = MinMaxScaler().setInputCol("in").setOutputCol("value")
estimator = NNEstimator(model, CrossEntropyCriterion())\
    .setBatchSize(128)\
    .setOptimMethod(Adam())\
    .setMaxEpoch(5)
pipeline = Pipeline(stages=[scaler, estimator])

pipelineModel = pipeline.fit(train_df)
predictions = pipelineModel.transform(validation_df)

更多详细信息，请参阅 DLlib 的 NNFrames 和 Keras API 用户指南。

Chronos

Chronos 库使构建快速、准确且可扩展的 时间序列分析 应用程序（支持 AutoML）变得简单易行。

from bigdl.chronos.forecaster import TCNForecaster 
from bigdl.chronos.data.repo_dataset import get_public_dataset

# 1. 使用 `TSDataset` 处理时间序列数据
tsdata_train, tsdata_val, tsdata_test = get_public_dataset(name='nyc_taxi')
for tsdata in [tsdata_train, tsdata_val, tsdata_test]:
    data.roll(lookback=100, horizon=1)

# 2. 创建一个 `TCNForecaster`（根据训练数据自动配置）
forecaster = TCNForecaster.from_tsdataset(train_data)

# 3. 训练预测器以进行预测
forecaster.fit(train_data)

pred = forecaster.predict(test_data)

# 创建并拟合一个 `AutoTSEstimator`
from bigdl.chronos.autots import AutoTSEstimator
autotsest = AutoTSEstimator(model="tcn", future_seq_len=10)

tsppl = autotsest.fit(data=tsdata_train, validation_data=tsdata_val)
pred = tsppl.predict(tsdata_test)

更多详细信息，请参阅 Chronos 的 用户指南 和 快速入门。

Friesian

Friesian 库使构建端到端的大规模 推荐系统 变得容易（包括 离线 特征转换与训练、近线 特征和模型更新，以及 在线 服务管道）。

更多详细信息，请参阅 Friesian 的 README。

PPML

BigDL PPML 提供一种 基于硬件（Intel SGX）保护的可信集群环境，用于在私有云或公有云上以安全的方式运行分布式大数据和 AI 应用程序。

更多详细信息，请参阅 PPML 的 用户指南 和 教程。

获取支持

• 邮件列表：mail list
• 用户组：user group
• GitHub 问题：GitHub issues

引用

如果您发现 BigDL 对您的项目有所帮助，您可以按照以下方式引用我们的论文：

• BigDL 2.0：从笔记本电脑到分布式集群的 AI 流程无缝扩展

  @INPROCEEDINGS{9880257,
      title={BigDL 2.0: Seamless Scaling of AI Pipelines from Laptops to Distributed Cluster}, 
      author={Dai, Jason Jinquan and Ding, Ding and Shi, Dongjie and Huang, Shengsheng and Wang, Jiao and Qiu, Xin and Huang, Kai and Song, Guoqiong and Wang, Yang and Gong, Qiyuan and Song, Jiaming and Yu, Shan and Zheng, Le and Chen, Yina and Deng, Junwei and Song, Ge},
      booktitle={2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, 
      year={2022},
      pages={21407-21414},
      doi={10.1109/CVPR52688.2022.02076}
  }
  

[^1]: 性能因使用场景、配置及其他因素而异。bigdl-llm 可能无法针对非 Intel 产品达到相同的优化效果。更多信息请访问 www.Intel.com/PerformanceIndex。

• BigDL：面向大数据的分布式深度学习框架

  @INPROCEEDINGS{10.1145/3357223.3362707,
      title = {BigDL: A Distributed Deep Learning Framework for Big Data},
      author = {Dai, Jason Jinquan and Wang, Yiheng and Qiu, Xin and Ding, Ding and Zhang, Yao and Wang, Yanzhang and Jia, Xianyan and Zhang, Cherry Li and Wan, Yan and Li, Zhichao and Wang, Jiao and Huang, Shengsheng and Wu, Zhongyuan and Wang, Yang and Yang, Yuhao and She, Bowen and Shi, Dongjie and Lu, Qi and Huang, Kai and Song, Guoqiong},
      booktitle = {Proceedings of the ACM Symposium on Cloud Computing (SoCC)},
      year = {2019},
      pages = {50–60},
      doi = {10.1145/3357223.3362707}
  }
  

BigDL 快速上手指南

重要提示：原 bigdl-llm 组件已更名为 ipex-llm。如果您主要关注大语言模型（LLM）在 Intel CPU/GPU 上的运行，请前往 IPEX-LLM 项目。本指南主要针对 BigDL 的其他核心组件（如 Orca, Nano, DLlib 等）。

BigDL 是一套用于在 Intel 架构（CPU/GPU）上无缝扩展数据分析和 AI 应用的库，支持从笔记本电脑到云集群的部署。

1. 环境准备

在开始之前，请确保您的系统满足以下要求：

• 操作系统：Linux (推荐 Ubuntu/CentOS), macOS, 或 Windows。
• Python 版本：建议 Python 3.8 - 3.10。
• 前置依赖：
  • 推荐安装 Conda 以管理虚拟环境。
  • 若使用分布式功能（Orca），需确保集群环境（如 K8s, YARN）或本地 Spark 环境可用。
• 硬件加速：BigDL 自动利用 Intel CPU 指令集（如 AVX-512, AMX）及 GPU，无需额外配置驱动即可享受性能提升。

2. 安装步骤

推荐使用 Conda 创建独立环境进行安装。

创建并激活环境

conda create -n bigdl_env python=3.9
conda activate bigdl_env

安装 BigDL 核心包

安装包含基础功能的完整包：

pip install bigdl

安装特定组件（可选）

如果您只需要特定功能模块，可以单独安装以减少依赖体积：

• 时序分析 (Chronos): pip install bigdl-chronos
• 推荐系统 (Friesian): pip install bigdl-friesian
• 隐私计算 (PPML): pip install bigdl-ppml

提示：如需体验最新夜间构建版本，可使用 pip install --pre --upgrade bigdl。国内用户若遇下载缓慢，可配置 pip 使用清华或阿里镜像源（例如：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple bigdl）。

3. 基本使用

BigDL 包含多个子库，以下是两个最常用场景的快速示例。

场景一：使用 Nano 加速 PyTorch 推理

Nano 可以在几乎不修改代码的情况下，自动应用 Intel CPU 优化技术（如多进程、低精度量化等），显著提升 TensorFlow 或 PyTorch 程序的运行速度。

from bigdl.nano.pytorch import InferenceOptimizer
import torch
from torchvision.models import resnet18

# 1. 加载预训练模型
model = resnet18(pretrained=True)
model.eval()

# 2. 准备数据 (此处仅为示例占位符)
train_dataloader = ... 
val_dataloader = ...

def accuracy(pred, target):
    # 定义准确率计算逻辑
    ...

# 3. 初始化优化器并执行优化
optimizer = InferenceOptimizer()
optimizer.optimize(model,
                   training_data=train_dataloader,
                   validation_data=val_dataloader,
                   metric=accuracy)

# 4. 获取最佳加速模型
new_model, config = optimizer.get_best_model()

# 查看不同优化策略的性能对比
optimizer.summary()

执行后，summary() 将输出原始模型与多种加速策略（如 BF16, INT8, OpenVINO 等）的延迟和精度对比。

场景二：使用 Orca 进行分布式训练

Orca 允许您将单机的 TensorFlow/PyTorch 程序轻松扩展到 Spark 或 Ray 集群上进行分布式大数据处理。

from bigdl.orca import init_orca_context, OrcaContext
from bigdl.orca.learn.tf.estimator import Estimator
from tensorflow import keras

# 1. 初始化 Orca 上下文 (支持本地、K8s、YARN)
sc = init_orca_context(cluster_mode="local", cores=4, memory="10g")

# 2. 获取 Spark Session 进行分布式数据处理
spark = OrcaContext.get_spark_session()
df = spark.read.parquet("hdfs:///path/to/data")
# 数据预处理...
df = df.withColumn('label', df.label-1)

# 3. 构建标准 Keras 模型
inputs = keras.Input(shape=(10,))
x = keras.layers.Dense(12, activation='relu')(inputs)
outputs = keras.layers.Dense(1, activation='softmax')(x)
keras_model = keras.Model(inputs, outputs)
keras_model.compile(optimizer='adam', loss='mse')

# 4. 使用 Orca Estimator 进行分布式训练
est = Estimator.from_keras(keras_model=keras_model)
est.fit(data=df,
        feature_cols=['feature1', 'feature2'],
        label_cols=['label'],
        batch_size=32,
        epochs=5)

更多详细文档、API 参考及高级教程，请访问 BigDL 官方文档。