BigDL 2.x
BigDL release 2.5.0b1
Importante
bigdl-llm se ha convertido en ipex-llm , y nuestro desarrollo futuro se trasladará al proyecto IPEX-LLM.
BigDL escala sin problemas sus aplicaciones de análisis de datos y AI de la computadora portátil a la nube, con las siguientes bibliotecas:
LLM (desaprobado: use IPEX -LLM en su lugar) : Optimizaed Language Model Library para CPU Intel y GPU
ORCA: tuberías distribuidas de Big Data & AI (TF y Pytorch) en Spark and Ray
Nano: Aceleración transparente de programas TensorFlow & Pytorch en CPU Intel/GPU
Dllib: "equivalente de chispa mllib" para el aprendizaje profundo
Chronos: análisis de series de tiempo escalables utilizando AUTOML
Friesiano: sistemas de recomendación de extremo a extremo
PPML: Secure Big Data y AI (con seguridad de hardware SGX/TDX)
Para obtener más información, puede leer los documentos.
diagrama de flujo TD;
Característica1 {{HW asegurado Big Data & ai?}};
Feature1-- No-> Feature2 {{Python vs. Scala/Java?}};
Feature1-- "Sí"-> referPpml ([<em> <strong> ppml </strong> </em>]);
Feature2-- Python-> Feature3 {{¿Qué tipo de aplicación?}};
Característica2-- scala/java-> referdllib ([<em> <strong> dllib </strong> </em>]);
Característica3-- "Modelo de lenguaje grande"-> referlm ([<em> <strong> llm </strong> </em>]);
Característica3-- "Big Data + Ai (TF/Pytorch)"-> referca ([<em> <strong> orca </strong> </em>]);
Feing3-- Acelerar TensorFlow/Pytorch-> refernano ([<em> <strong> nano </strong> </em>]);
Feature3-- DL para Spark Mllib-> referdllib2 ([<em> <strong> dllib </strong> </em>]);
Feature3-- Framework de aplicaciones de alto nivel-> características4 {{dominio?}};
Feing4-- Serie de tiempo-> referChronos ([<em> <strong> cronos </strong> </em>]);
Feature4-- Sistema de recomendación-> Referfriesian ([<em> <strong> friesian </strong> </em>]);
Haga clic en Referlm "https://github.com/intel-analytics/ipex-llm"
Haga clic en Refernano "https://github.com/intel-analytics/bigdl-2.x#nano"
Haga clic en Referca "https://github.com/intel-analytics/bigdl-2.x#orca"
Haga clic en referdllib "https://github.com/intel-analytics/bigdl-2.x#dllib"
Haga clic en referdllib2 "https://github.com/intel-analytics/bigdl-2.x#dllib"
Haga clic en Referchronos "https://github.com/intel-analytics/bigdl-2.x#chronos"
Haga clic en Referfriesian "https://github.com/intel-analytics/bigdl-2.x#friesian"
Haga clic en Referppml "https://github.com/intel-analytics/bigdl-2.x#ppml"
classdef referstyle1 relleno:#5099CE, accidente cerebrovascular:#5099CE;
ClassDef Function Fill:#FFF, Stroke:#08409c, accidente cerebrovascular: 1px;
Class Referllm, Refernano, ReferRAn, referdllib, referdllib2, referchronos, referfriesian, referppml referstyle1;
Class Feature1, Feature2, Feature3, Feature4, Feature5, Feature6, Feature7 característica;
Para instalar BIGDL, recomendamos usar CondA Entorno:
conda create -n my_env
conda activate my_env
pip install bigdl Para instalar la última compilación nocturna, use pip install --pre --upgrade bigdl ; Consulte la guía del usuario de Python y Scala para obtener más detalles.
Para instalar cada biblioteca individual, como Chronos, use pip install bigdl-chronos ; Consulte el sitio web del documento para obtener más detalles.
La biblioteca ORCA escala perfectamente los programas de su solo nodo TensorFlow , Pytorch o OpenVino en grupos grandes (para procesar big data distribuidos).
Puede crear programas de procesamiento de datos distribuidos y de extremo a extremo utilizando ORCA en 4 pasos 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' ],
...)Consulte la Guía del usuario de ORCA, así como TensorFlow y Pytorch QuickStarts, para obtener más detalles.
Además, también puede ejecutar programas de rayos estándar en Spark Cluster usando Rayonspark en Orca.
No solo puede ejecutar el programa Ray en Spark Cluster, sino también escribir el código de Ray en línea con el código Spark (para procesar el Spark RDDS o Dataframes en memoria) utilizando Rayonspark en 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 )))Consulte la Guía del usuario de Rayonspark y rápido para obtener más detalles.
Puede acelerar de manera transparente sus programas TensorFlow o Pytorch en su computadora portátil o servidor usando Nano . Con cambios mínimos en el código, Nano aplica automáticamente las optimizaciones modernas de la CPU (por ejemplo, SIMD, multiprocesamiento, baja precisión, etc.) al código estándar de TensorFlow y Pytorch, con una velocidad hasta 10x.
Puede optimizar automáticamente un modelo de Pytorch capacitado para inferencia o implementación utilizando 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 salida de optimizer.summary() será algo así como:
-------------------------------- ---------------------- -------------- ----------------------
| 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 ()Consulte la Guía del usuario de Nano y Tutotial para obtener más detalles.
Con Dllib , puede escribir aplicaciones de aprendizaje profundo distribuidos como programas estándar ( Scala o Python ) Spark, utilizando las mismas API de Spark Dataframes y ML Pipeline .
Puede construir aplicaciones de aprendizaje profundo distribuidos para Spark utilizando API de Dllib Scala en 3 pasos 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)Puede construir aplicaciones de aprendizaje profundo distribuidos para Spark utilizando API Dllib Python en 3 pasos 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 )Consulte las guías de usuario de Dllib Nnframes y Keras API para obtener más detalles.
La biblioteca Chronos facilita la construcción de aplicaciones de análisis de series de tiempo rápidas, precisas y escalables (con AUTOML).
Puede entrenar un pronosticador de series de tiempo usando cronos en 3 pasos 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 ) Para aplicar AUTOML, use AutoTSEstimator en lugar de pronosticadores normales.
# 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 )Consulte la Guía del usuario de Chronos y el inicio rápido para obtener más detalles.
La Biblioteca Friesia facilita la construcción del sistema de recomendación de extremo a extremo y a gran escala (incluida la transformación de características fuera de línea y la transmisión, la función de la línea cercana y la actualización del modelo, y la tubería de servicio en línea ).
Ver Readme freisiano para más detalles.
BigDL PPML proporciona un entorno de clúster de confianza protegido de hardware (Intel SGX) para ejecutar aplicaciones distribuidas de Big Data & AI (de manera segura en nubes privadas o públicas).
Consulte la Guía del usuario de PPML y el tutorial para obtener más detalles.
Si ha encontrado que BigDL es útil para su proyecto, puede citar nuestros documentos de la siguiente manera:
@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}
}
