BigDL 2.x
BigDL release 2.5.0b1
Important
bigdl-llm est maintenant devenu ipex-llm , et notre développement futur passera au projet IPEX-LLM.
Bigdl évolue de manière transparente votre analyse de données et vos applications AI de l'ordinateur portable au cloud, avec les bibliothèques suivantes:
LLM (DÉMANDÉ - Veuillez utiliser IPEX-LLM à la place) : Bibliothèque de modèles de grande langue optimizaed pour Intel CPU et GPU
ORCA: Pipeline distribué Big Data et AI (TF & Pytorch) sur Spark et Ray
Nano: Accélération transparente des programmes TensorFlow et Pytorch sur Intel CPU / GPU
Dllib: «Équivalent de Spark Mllib» pour l'apprentissage en profondeur
Chronos: analyse des séries chronologiques évolutives en utilisant Automl
Friesian: Systèmes de recommandation de bout en bout
PPML: sécuriser les mégadonnées et l'IA (avec la sécurité matérielle SGX / TDX)
Pour plus d'informations, vous pouvez lire les documents.
Organigramme TD;
FEARTAGE1 {{HW Secured Big Data & Ai?}};
FEATURE1-- NO -> FEAUTH2 {{Python vs Scala / Java?}};
FEATURE1-- "OUI" -> REFORMPML ([<em> <strong> ppml </strong> </em>]);
FEATURE2-- Python -> fonctionnalité3 {{quel type d'application?}};
FEATURE2-- Scala / Java -> REFORDLLIB ([<em> <strong> dllib </strong> </em>]);
FEAUTÉ3-- "Modèle grand langage" -> REFORLLM ([<em> <strong> llm </strong> </em>]);
FEARTAGE3-- "Big Data + Ai (TF / Pytorch)" -> RefortCa ([<em> <strong> Orca </strong> </em>]);
FEATION3-- Accélérer TensorFlow / Pytorch -> Refornano ([<em> <strong> nano </strong> </em>]);
FEAUTÉ3-- DL pour Spark Mllib -> Refordllib2 ([<em> <strong> dllib </strong> </em>]);
FEAUTÉ3-- Framework de l'application de haut niveau -> FEAUTH4 {{domaine?}};
FEAUTH4-- Série chronologique -> Reforchronos ([<em> <strong> chronos </strong> </em>]);
FEAUTH4-- Recomderder System -> RefyFriesian ([<em> <strong> Friesian </strong> </em>]);
Cliquez sur Referllm "https://github.com/intel-analytics/ipex-llm"
Cliquez sur Refaire "https://github.com/intel-analytics/bigdl-2.x#nano"
Cliquez sur Reforta "https://github.com/intel-analytics/bigdl-2.x#orca"
Cliquez sur ReberDllib "https://github.com/intel-analytics/bigdl-2.x#dllib"
Cliquez sur RefortDllib2 "https://github.com/intel-analytics/bigdl-2.x#dllib"
Cliquez sur Refirschronos "https://github.com/intel-analytics/bigdl-2.x#chronos"
Cliquez sur ReFORFRIESIAN "https://github.com/intel-analytics/bigdl-2.x#friesian"
Cliquez sur RefraierPML "https://github.com/intel-analytics/bigdl-2.x#ppml"
CLASSDEF REFERSTYLE1 FILL: # 5099CE, AVC: # 5099CE;
ClassDef Fonction Fill: # FFF, trait: # 08409C, largeur de course: 1px;
Class Reforllm, Refornano, RefortorCa, ReFORDLLIB, REFORDLLIB2, REFORCHRONOS, REFORFRIESIAN, REFORADPML REFERSTYLE1;
Class Feature1, fonctionn2, fonctionnant3, fonctionnalité, fonctionnalité5, fonctionnalité6, fonctionnalité7 fonctionnalité;
Pour installer Bigdl, nous vous recommandons d'utiliser Conda Environment:
conda create -n my_env
conda activate my_env
pip install bigdl Pour installer la dernière version nocturne, utilisez pip install --pre --upgrade bigdl ; Voir Guide de l'utilisateur Python et Scala pour plus de détails.
Pour installer chaque bibliothèque individuelle, comme les chronos, utilisez pip install bigdl-chronos ; Voir le site Web du document pour plus de détails.
La bibliothèque ORCA évolue de manière transparente votre seul nœud TensorFlow , Pytorch ou OpenVino sur les grands clusters (afin de traiter les mégadonnées distribuées).
Vous pouvez créer des programmes de traitement de données de bout en bout et distribués en utilisant ORCA en 4 étapes simples:
# 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' ],
...)Voir Orca User Guide, ainsi que TensorFlow et Pytorch Quickstarts, pour plus de détails.
De plus, vous pouvez également exécuter des programmes de rayons standard sur Spark Cluster à l'aide de Rayonspark dans ORCA.
Vous pouvez non seulement exécuter le programme RAY sur Spark Cluster, mais également écrire du code Ray en ligne avec le code Spark (afin de traiter les RDD Spark en mémoire ou DataFrames) à l'aide de Rayonspark dans 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 )))Voir Guide de l'utilisateur Rayonspark et QuickStart pour plus de détails.
Vous pouvez accélérer de manière transparente vos programmes TensorFlow ou Pytorch sur votre ordinateur portable ou serveur à l'aide de Nano . Avec des modifications de code minimum, Nano applique automatiquement les optimisations modernes du processeur (par exemple, SIMD, multiprocessement, faible précision, etc.) au code TensorFlow et pytorch standard, avec une accélération à la hausse.
Vous pouvez optimiser automatiquement un modèle Pytorch formé pour l'inférence ou le déploiement à l'aide de 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 () La sortie d' optimizer.summary() sera quelque chose comme:
-------------------------------- ---------------------- -------------- ----------------------
| 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 ()Voir Nano User Guide et Tutotial pour plus de détails.
Avec DLIB , vous pouvez écrire des applications d'apprentissage en profondeur distribuées en tant que programmes Spark standard ( Scala ou Python ), en utilisant les mêmes API Spark DataFrames et ML Pipeline .
Vous pouvez créer des applications d'apprentissage en profondeur distribuées pour Spark à l'aide d'API Dllib Scala en 3 étapes simples:
// 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)Vous pouvez créer des applications d'apprentissage en profondeur distribuées pour Spark à l'aide d'API Dllib Python en 3 étapes simples:
# 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 )Voir Dllib NNFrames et Keras API Guides utilisateur pour plus de détails.
La bibliothèque Chronos facilite la création d'applications d'analyse de séries chronologiques rapides, précises et évolutives (avec Automl).
Vous pouvez former un prévisionniste des séries chronologiques en utilisant Chronos en 3 étapes simples:
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 ) Pour appliquer Automl, utilisez AutoTSEstimator au lieu des prévisionnistes normaux.
# 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 )Voir Guide de l'utilisateur Chronos et démarrage rapide pour plus de détails.
La bibliothèque Friesian facilite la création du système de recommandation à grande échelle de bout en bout (y compris la transformation et le transformation des fonctionnalités hors ligne , la fonctionnalité et la mise à jour du modèle en ligne , et le pipeline de service en ligne ).
Voir Freisian Readme pour plus de détails.
BIGDL PPML fournit un environnement de cluster de confiance matériel (Intel SGX) pour l'exécution des Big Data et des applications AI distribuées (de manière sécurisée sur le cloud privé ou public).
Voir Guide de l'utilisateur PPML et tutoriel pour plus de détails.
Si vous avez trouvé Bigdl utile pour votre projet, vous pouvez citer nos articles comme suit:
@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}
}
