BigDL 2.x
BigDL release 2.5.0b1
Penting
bigdl-llm sekarang telah menjadi ipex-llm , dan pengembangan masa depan kami akan pindah ke proyek IPEX-LLM.
BIGDL dengan mulus menskalakan aplikasi analitik data & AI Anda dari laptop ke cloud, dengan pustaka berikut:
LLM (Terpisah - Harap gunakan IPEX -LLM sebagai gantinya) : Pustaka Model Bahasa Besar Optimizaed untuk Intel CPU dan GPU
ORCA: Pipa Big Data & AI (TF & Pytorch) terdistribusi pada Spark and Ray
Nano: Percepatan transparan program TensorFlow & Pytorch di Intel CPU/GPU
Dllib: “Setara dengan Spark Mllib” untuk pembelajaran yang mendalam
Chronos: Analisis seri waktu yang dapat diskalakan menggunakan Automl
Friesian: Sistem Rekomendasi End-to-End
PPML: Amankan data besar dan AI (dengan keamanan perangkat keras SGX/TDX)
Untuk informasi lebih lanjut, Anda dapat membaca dokumen.
Flowchart TD;
Fitur1 {{hw Secured Big Data & ai?}};
Fitur1-- tidak-> fitur2 {{python vs scala/java?}};
Fitur1-- "ya"-> referppml ([<em> <strong> ppml </strong> </em>]);
Fitur2-- python-> fitur3 {{jenis aplikasi apa?}};
Fitur2-- scala/java-> referdllib ([<em> <strong> dllib </strong> </em>]);
Fitur3-- "model bahasa besar"-> referensi ([<em> <strong> llm </strong> </em>]);
Fitur3-- "Big Data + AI (TF/Pytorch)"-> Referorca ([<em> <strong> orca </strong> </em>]);
Fitur3-- percepatan tensorflow/pytorch-> refernano ([<em> <strong> nano </strong> </em>]);
Fitur3-- dl untuk spark mllib-> referdllib2 ([<em> <strong> dllib </strong> </em>]);
Fitur3-- kerangka kerja aplikasi tingkat tinggi-> fitur4 {{domain?}};
Fitur4-- waktu seri-> referchronos ([<em> <strong> chronos </strong> </em>]);
Fitur4-- Sistem Rekomendasi-> ReferFriesian ([<em> <strong> Friesian </strong> </em>]);
Klik Referensi "https://github.com/intel-analytics/ipex-llm"
Klik Refernano "https://github.com/intel-analytics/bigdl-2.x#nano"
Klik ReferorCA "https://github.com/intel-analytics/bigdl-2.x#orca"
Klik Referdllib "https://github.com/intel-analytics/bigdl-2.x#dllib"
Klik Referdllib2 "https://github.com/intel-analytics/bigdl-2.x#dllib"
Klik ReferchRonos "https://github.com/intel-analytics/bigdl-2.x#chronos"
Klik Referfriesian "https://github.com/intel-analytics/bigdl-2.x#friesian"
Klik Referppml "https://github.com/intel-analytics/bigdl-2.x#ppml"
ClassDef Referstyle1 Isi:#5099CE, Stroke:#5099CE;
Fitur ClassDef Isi:#FFF, Stroke:#08409c, Stroke-Width: 1px;
Referensi Kelas, Refernano, Referorca, Referdllib, Referdllib2, Referchronos, Referfriesian, Referppml Referstyle1;
Class Feature1, Feature2, Feature3, Feature4, Feature5, Feature6, Fitur7 Fitur;
Untuk menginstal BigDL, kami sarankan menggunakan lingkungan Conda:
conda create -n my_env
conda activate my_env
pip install bigdl Untuk menginstal Build Nightly Terbaru, gunakan pip install --pre --upgrade bigdl ; Lihat Panduan Pengguna Python dan Scala untuk detail lebih lanjut.
Untuk menginstal setiap perpustakaan individu, seperti chronos, gunakan pip install bigdl-chronos ; Lihat situs web dokumen untuk lebih jelasnya.
Perpustakaan ORCA dengan mulus mengeluarkan program TensorFlow , Pytorch, atau OpenVino tunggal Anda di seluruh kelompok besar (sehingga dapat memproses data besar yang didistribusikan).
Anda dapat membangun program pemrosesan data end-to-end yang didistribusikan & program AI menggunakan ORCA dalam 4 langkah sederhana:
# 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' ],
...)Lihat Panduan Pengguna ORCA, serta TensorFlow dan Pytorch QuickStarts, untuk lebih jelasnya.
Selain itu, Anda juga dapat menjalankan program sinar standar di Spark Cluster menggunakan Rayonspark di ORCA.
Anda tidak hanya dapat menjalankan program Ray di Spark Cluster, tetapi juga menulis kode Ray inline dengan Spark Code (untuk memproses RDD Spark atau DataFrames in-memory) menggunakan Rayonspark di ORCA.
# 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 )))Lihat Panduan Pengguna Rayonspark dan QuickStart untuk lebih jelasnya.
Anda dapat secara transparan mempercepat program TensorFlow atau Pytorch Anda di laptop atau server Anda menggunakan Nano . Dengan perubahan kode minimum, Nano secara otomatis menerapkan optimisasi CPU modern (misalnya, SIMD, multiprosesing, presisi rendah, dll.) Untuk kode TensorFlow dan Pytorch standar, dengan speedup hingga 10x.
Anda dapat secara otomatis mengoptimalkan model pytorch terlatih untuk inferensi atau penyebaran menggunakan nano :
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 () Output dari optimizer.summary() akan menjadi sesuatu seperti:
-------------------------------- ---------------------- -------------- ----------------------
| 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 ()Lihat Panduan Pengguna Nano dan Tutotial untuk lebih jelasnya.
Dengan Dllib , Anda dapat menulis aplikasi pembelajaran mendalam yang didistribusikan sebagai program Spark Standard ( Scala atau Python ), menggunakan Dataframes Spark yang sama dan API Pipeline ML .
Anda dapat membangun aplikasi pembelajaran mendalam terdistribusi untuk Spark menggunakan Dllib Scala API dalam 3 langkah sederhana:
// 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)Anda dapat membangun aplikasi pembelajaran mendalam terdistribusi untuk Spark menggunakan Dllib Python API dalam 3 langkah sederhana:
# 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 )Lihat DLLIB nnframes dan Panduan Pengguna API Keras untuk lebih jelasnya.
Perpustakaan Chronos memudahkan untuk membangun aplikasi analisis rangkaian waktu yang cepat, akurat, dan dapat diskalakan (dengan AutomL).
Anda dapat melatih peramal seri waktu menggunakan chronos dalam 3 langkah sederhana:
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 ) Untuk menerapkan Automl, gunakan AutoTSEstimator alih -alih peramal normal.
# 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 )Lihat Panduan Pengguna Chronos dan Mulai Cepat Untuk Detail Lebih Lanjut.
Perpustakaan Friesian memudahkan untuk membangun sistem rekomendasi berskala besar dari ujung ke ujung (termasuk transformasi dan transformasi fitur offline , fitur dekat dan pembaruan model, dan pipa sajian online ).
Lihat Readme Freisian untuk lebih jelasnya.
BIGDL PPML menyediakan lingkungan cluster tepercaya yang dilindungi perangkat keras (Intel SGX) untuk menjalankan aplikasi Big Data & AI terdistribusi (dengan cara yang aman di cloud pribadi atau publik).
Lihat Panduan dan Tutorial Pengguna PPML untuk detail lebih lanjut.
Jika Anda menemukan BigDL berguna untuk proyek Anda, Anda dapat mengutip makalah kami sebagai berikut:
@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}
}
