BigDL 2.x
BigDL release 2.5.0b1
重要
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を使用したスケーラブルな時系列分析
フリージアン：エンドツーエンドの推奨システム
PPML：セキュアビッグデータとAI（SGX/TDXハードウェアセキュリティ付き）
詳細については、ドキュメントを読むことができます。
フローチャートTD;
feature1 {{hw secured big data＆ai？}};
feature1- no-> feature2 {{python vs. scala/java？}};
feature1-- "yes" - > referppml（[<em> <strong> ppml </strong> </em>]）;
feature2-Python-> feature3 {{quity of application？}};
feature2-- scala/java-> referdllib（[<em> <strong> dllib </strong> </em>]）;
feature3--「大手言語モデル」 - > referllm（[<em> <strong> llm </strong> </em>]）;
feature3-「ビッグデータ + ai（tf/pytorch） " - > requerorca（[<em> <strong> orca </strong> </em>]）;
feature3-- Tensorflow/pytorchを加速 - > refernano（[<em> <strong> nano </strong> </em>]）;
feature3-- dl for spark mllib-> referdllib2（[<em> <strong> dllib </strong> </em>]）;
feature3--高レベルのアプリフレームワーク - > feature4 {{domain？}};
feature4--時系列 - > referchronos（[<em> <strong> chronos </strong> </em>]）;
feature4--推奨システム - > referfriesian（[<em> <strong> friesian </strong> </em>]）;
[https://github.com/intel-analytics/ipex-llm]をクリックします
参照 "https://github.com/intel-analytics/bigdl-2.x#nano"をクリックします。
requerorca "https://github.com/intel-analytics/bigdl-2.x#orca"をクリックします。
referdllib "https://github.com/intel-analytics/bigdl-2.x#dllib"をクリックします "
referdllib2 "https://github.com/intel-analytics/bigdl-2.x#dllib"をクリックします "
referchronos "https://github.com/intel-analytics/bigdl-2.x#chronosをクリックします"
参照者をクリックします "https://github.com/intel-analytics/bigdl-2.x#friesian"
REFREPPML "https://github.com/intel-analytics/bigdl-2.x#ppml"をクリックします。
classdef redertyle1 fill：＃5099ce、stroke：＃5099ce;
classdef機能の塗りつぶし：＃fff、ストローク：＃08409c、ストローク幅：1px;
Class Referllm、Refernano、Referorca、Referdllib、Referdllib2、Referchronos、Referfriesian、ReferppML RefertyLe1;
class feature1、feature2、feature3、feature4、feature5、feature6、feature7 feature;
BIGDLをインストールするには、Conda環境を使用することをお勧めします。
conda create -n my_env
conda activate my_env
pip install bigdl最新の夜間ビルドをインストールするには、 pip install --pre --upgrade bigdl 。詳細については、Python and Scalaユーザーガイドを参照してください。
Chronosなどの個々のライブラリをインストールするには、 pip install bigdl-chronosを使用します。詳細については、Document Webサイトを参照してください。
ORCAライブラリは、大きなクラスター全体で単一のノードTensorflow 、 Pytorch 、またはOpenVinoプログラムをシームレスにスケーリングします（分散ビッグデータを処理するため）。
4つの簡単な手順でORCAを使用して、エンドツーエンドの分散データ処理およびAIプログラムを構築できます。
# 1. Initilize Orca Context (to run your program on K8s, YARN or local laptop)
from bigdl . orca import init_orca_context , OrcaContext
sc = init_orca_context ( cluster_mode = "k8s" , cores = 4 , memory = "10g" , num_nodes = 2 )
# 2. Perform distribtued data processing (supporting Spark DataFrames,
# TensorFlow Dataset, PyTorch DataLoader, Ray Dataset, Pandas, Pillow, etc.)
spark = OrcaContext . get_spark_session ()
df = spark . read . parquet ( file_path )
df = df . withColumn ( 'label' , df . label - 1 )
...
# 3. Build deep learning models using standard framework APIs
# (supporting TensorFlow, PyTorch, Keras, OpenVino, etc.)
from tensorflow import keras
...
model = keras . models . Model ( inputs = [ user , item ], outputs = predictions )
model . compile (...)
# 4. Use Orca Estimator for distributed training/inference
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 Quickstartsを参照してください。
さらに、ORCAのRayonsparkを使用してSpark Clusterで標準レイプログラムを実行することもできます。
Spark ClusterでRayプログラムを実行するだけでなく、 RayonsparkをORCAを使用して、Spark Code（インメモリSpark RDDまたはデータフレームを処理するために）を使用してRay Codeをインラインで書き込むこともできます。
# 1. Initilize Orca Context (to run your program on K8s, YARN or local laptop)
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. Distribtued data processing using Spark
spark = OrcaContext . get_spark_session ()
df = spark . read . parquet ( file_path ). withColumn (...)
# 3. Convert Spark DataFrame to Ray Dataset
from bigdl . orca . data import spark_df_to_ray_dataset
dataset = spark_df_to_ray_dataset ( df )
# 4. Use Ray to operate on Ray Datasets
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ユーザーガイドとQuickStartを参照してください。
Nanoを使用して、ラップトップまたはサーバーでTensorflowまたはPytorchプログラムを透過的に加速できます。最小コードの変更により、 NANOは最新のCPU最適化（SIMD、マルチプロセス、低精度など）を標準のTensorflowおよびPytorchコードに自動的に適用し、最大10倍の高速化を行います。
NANOを使用して、推論または展開のためにトレーニングされたPytorchモデルを自動的に最適化できます。
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 () 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 |
-------------------------------- ---------------------- -------------- ----------------------
* means we assume the metric value of the traced model does not change, so we don't recompute metric value to save time.
Optimization cost 60.8s in total.
model = ResNet18 ()
optimizer = torch . optim . SGD (...)
train_loader = ...
val_loader = ...
from bigdl . nano . pytorch import TorchNano
# Define your training loop inside `TorchNano.train`
class Trainer ( TorchNano ):
def train ( self ):
# call `setup` to prepare for model, optimizer(s) and dataloader(s) for accelerated training
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 )
# replace the loss.backward() with self.backward(loss)
loss = loss_fuc ( output , target )
self . backward ( loss )
optimizer . step ()
# Accelerated training (IPEX, BF16 and Multi-Instance Training)
Trainer ( use_ipex = True , precision = 'bf16' , num_processes = 2 ). train ()詳細については、NanoユーザーガイドとTutotialを参照してください。
DLLIBを使用すると、同じSpark DataFramesとML Pipeline APIを使用して、標準（ SCALAまたはPython ）Sparkプログラムとして分散したディープラーニングアプリケーションを記述できます。
DLLIB SCALA APIを3つの簡単な手順で使用して、Sparkの分散ディープラーニングアプリケーションを構築できます。
// 1. Call `initNNContext` at the beginning of the code:
import com . intel . analytics . bigdl . dllib . NNContext
val sc = NNContext .initNNContext()
// 2. Define the deep learning model using Keras-style API in DLlib:
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. Use `NNEstimator` to train/predict/evaluate the model using Spark DataFrame and ML pipeline APIs
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)Dllib Python APIを3つの簡単な手順で使用して、Sparkの分散ディープラーニングアプリケーションを構築できます。
# 1. Call `init_nncontext` at the beginning of the code:
from bigdl . dllib . nncontext import init_nncontext
sc = init_nncontext ()
# 2. Define the deep learning model using Keras-style API in DLlib:
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. Use `NNEstimator` to train/predict/evaluate the model using Spark DataFrame and ML pipeline APIs
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ライブラリにより、高速で正確でスケーラブルな時系列分析アプリケーション（Automlを使用）を簡単に構築できます。
3つの簡単な手順でChronosを使用して、時系列の予測をトレーニングできます。
from bigdl . chronos . forecaster import TCNForecaster
from bigdl . chronos . data . repo_dataset import get_public_dataset
# 1. Process time series data using `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. Create a `TCNForecaster` (automatically configured based on train_data)
forecaster = TCNForecaster . from_tsdataset ( train_data )
# 3. Train the forecaster for prediction
forecaster . fit ( train_data )
pred = forecaster . predict ( test_data ) Automlを適用するには、通常の予測者の代わりにAutoTSEstimator使用します。
# Create and fit an `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 Libraryは、エンドツーエンドの大規模な推奨システム（オフライン機能変換とトラニング、ニアライン機能とモデルの更新、オンラインサービングパイプラインなど）を簡単に構築できます。
詳細については、Freisian Readmeを参照してください。
BIGDL PPMLは、分散ビッグデータとAIアプリケーションを実行するためのハードウェア（Intel SGX）保護された信頼できるクラスター環境を提供します（プライベートまたはパブリッククラウドで安全な方法で）。
詳細については、PPMLユーザーガイドとチュートリアルを参照してください。
BigDLがプロジェクトに役立つとわかった場合は、次のように論文を引用できます。
@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}
}
@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}
}
