BigDL 2.x
BigDL release 2.5.0b1
Wichtig
bigdl-llm ist jetzt zu ipex-llm geworden, und unsere zukünftige Entwicklung wird zum IPEX-Llm-Projekt übergehen.
Bigdl skaliert nahtlos Ihre Datenanalyse- und AI -Anwendungen vom Laptop nach Cloud mit den folgenden Bibliotheken:
LLM (veraltet - bitte verwenden
Orca: Verteilte Big Data & AI (TF & Pytorch) -Pipeline auf Spark und Ray
Nano: Transparente Beschleunigung von TensorFlow & Pytorch -Programmen zu Intel CPU/GPU
DLLIB: „Äquivalent von Spark Mllib“ für tiefes Lernen
Chronos: Skalierbare Zeitreihenanalyse mit Automl
Friesisch: End-to-End-Empfehlungssysteme
PPML: sichere Big Data und KI (mit SGX/TDX -Hardware -Sicherheit)
Für weitere Informationen können Sie die Dokumente lesen.
Flussdiagramm TD;
Feature1 {{hw gesicherte Big Data & ai?}};
Feature1-- no-> feature2 {{python vs. scala/java?}};
Feature1-- "yes"-> referppml ([<em> <strong> ppml </strong> </em>]);
Feature2-- python-> feature3 {{welche Art von Anwendung?}};
Feature2-- scala/java-> referDllib ([<em> <strong> dllib </strong> </em>]);
Feature3-- "großsprachiges Modell"-> Referllm ([<em> <strong> llm </strong> </em>]);
Feature3-- "Big Data + AI (TF/Pytorch)"-> Referorca ([<em> <strong> orca </strong> </em>]);
Feature3-- Tensorflow/Pytorch-> Refernano ([<em> <strong> nano </strong> </em>]);
Feature3-- DL für Spark Mllib-> referDllib2 ([<em> <strong> dllib </strong> </em>]);
Feature3-- High-Level-App-Framework-> Feature4 {{Domain?}};
Feature4-- Time Series-> Referchronos ([<em> <strong> Chronos </strong> </em>]);
Feature4-- Empfehlungssystem-> referfriesian ([<em> <strong> Friesian </strong> </em>]);
Klicken Sie auf Referllm "https://github.com/intel-analytics/ipex-llm"
Klicken Sie auf "https://github.com/intel-analytics/bigdl-2.x#nano" auf "https://github.com/intel-analytics".
Klicken Sie auf Referorca "https://github.com/intel-analytics/bigdl-2.x#orca"
Klicken Sie auf "https://github.com/intel-analytics/bigdl-2.x#dllib" siehe.
Klicken Sie auf Über 1: "https://github.com/intel-analytics/bigdl-2.x#dllib" siehe.
Klicken Sie auf ReferessCronos "https://github.com/intel-analytics/bigdl-2.x#chronos"
Klicken Sie auf Referenzen "https://github.com/intel-analytics/bigdl-2.x#friesian"
Klicken Sie auf "https://github.com/intel-analytics/bigdl-2.x#ppml".
classDef RefertSyle1 FILL:#5099ce, Schlaganfall:#5099ce;
ClassDEF-Funktion FILL:#fff, stroke:#08409c, stroke-width: 1px;
Klasse Referllm, Refernano, Referorca, ReferDllib, ReferDllib2, Referchronos, Referenfriesian, ReferpPML RefERSyle1;
Klasse Feature1, Feature2, Feature3, Feature4, Feature5, Feature6, Feature7 -Funktion;
Um BigDL zu installieren, empfehlen wir die Verwendung der Conda -Umgebung:
conda create -n my_env
conda activate my_env
pip install bigdl Verwenden Sie zur Installation der neuesten Nachtbauten pip install --pre --upgrade bigdl ; Weitere Informationen finden Sie unter Python- und Scala -Benutzerhandbuch.
Um jede einzelne Bibliothek, wie z. B. Chronos, zu installieren, verwenden Sie pip install bigdl-chronos . Weitere Informationen finden Sie auf der Dokumentwebsite.
Die Orca -Bibliothek skaliert nahtlos Ihren einzelnen Knotenzensorflow- , Pytorch- oder OpenVino -Programme in großen Clustern (um verteilte Big Data zu verarbeiten).
Sie können End-to-End-Datenverarbeitung und KI-Programme mit Orca in 4 einfachen Schritten erstellen:
# 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' ],
...)Weitere Informationen finden Sie im Orca -Benutzerhandbuch sowie TensorFlow und Pytorch QuickStarts.
Darüber hinaus können Sie auch Standard -Ray -Programme auf Spark Cluster mit Rayonspark in Orca ausführen.
Sie können nicht nur das Ray-Programm auf Spark Cluster ausführen, sondern auch Ray Code Inline mit Spark-Code (um die In-Memory-Spark-RDDs oder DataFrames) mit Rayonspark in Orca zu verarbeiten.
# 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 )))Weitere Informationen finden Sie unter Rayonspark -Benutzerhandbuch und QuickStart.
Mit Nano können Sie Ihre Tensorflow- oder Pytorch -Programme auf Ihrem Laptop oder Server transparent beschleunigen. Mit minimalen Codeänderungen wendet Nano automatisch moderne CPU-Optimierungen (z. B. SIMD, Multiprocessing, niedrige Präzision usw.) auf Standard-Tensorflow- und Pytorch-Code mit bis zu 10-facher Geschwindigkeit an.
Sie können ein geschulter Pytorch -Modell für Inferenz oder Bereitstellung mithilfe von Nano automatisch optimieren:
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 () Die Ausgabe von optimizer.summary() ist so etwas wie:
-------------------------------- ---------------------- -------------- ----------------------
| 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 ()Weitere Informationen finden Sie unter Nano -Benutzerhandbuch und Tutotial.
Mit DLLIB können Sie verteilte Deep -Learning -Anwendungen als Standard ( Scala oder Python ) Funkenprogramme mit denselben Funkendatenframes und ML -Pipeline -APIs schreiben.
Sie können verteilte Deep -Learning -Anwendungen für Spark unter Verwendung von DLLIB Scala -APIs in 3 einfachen Schritten erstellen:
// 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)Sie können verteilte Deep -Learning -Anwendungen für Spark unter Verwendung von DLLIB Python -APIs in 3 einfachen Schritten erstellen:
# 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 )Weitere Informationen finden Sie unter DLLIB NNFrames und Keras -API -Benutzerführer.
Die Chronos -Bibliothek erleichtert es einfach, schnelle, genaue und skalierbare Zeitreihenanalyse -Anwendungen (mit Automl) zu erstellen.
Sie können einen Zeitreihenprognostiker mit Chronos in 3 einfachen Schritten trainieren:
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 ) Verwenden Sie AutoTSEstimator anstelle von normalen Prognostern.
# 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 )Weitere Informationen finden Sie unter Chronos User Guide und Quick Start.
Die friesische Bibliothek erleichtert das Erstellen von End-to-End- Empfehlungssystemen (einschließlich Offline- Feature-Transformation und -Laning, Nahline- Funktionen und Model-Update sowie Online- Servierpipeline).
Weitere Informationen finden Sie unter Freisian Readme.
Bigdl PPML bietet eine Hardware (Intel SGX) geschützte vertrauenswürdige Cluster -Umgebung für die Ausführung von verteilten Big Data & AI -Anwendungen (auf sichere Weise auf privater oder öffentlicher Cloud).
Weitere Informationen finden Sie unter PPML -Benutzerhandbuch und Tutorial.
Wenn Sie BigDL für Ihr Projekt nützlich empfanden, können Sie unsere Papiere wie folgt zitieren:
@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}
}
