BigDL 2.x
BigDL release 2.5.0b1
Важный
bigdl-llm теперь стал ipex-llm , и наша будущая разработка перейдет в проект IPEX-LLM.
BIGDL плавно масштабирует ваши приложения Analytics & AI от ноутбука в Cloud, со следующими библиотеками:
LLM (устарел - вместо этого используйте IPEX -LLM) : Оптимизированная библиотека моделей с большой языком для процессора Intel и графического процессора
ORCA: Распределенные большие данные и AI (TF & Pytorch) трубопровод на Spark and Ray
Nano: прозрачное ускорение программ Tensorflow & Pytorch на процессоре Intel/GPU
Dllib: «эквивалент Spark Mllib» для глубокого обучения
Chronos: анализ масштабируемых временных рядов с использованием Automl
Friesian: сквозные системы рекомендаций
PPML: Закрепите большие данные и AI (с SGX/TDX Adplave Security)
Для получения дополнительной информации вы можете прочитать документы.
Блок -схема TD;
Feature1 {{HW защищен большие данные и AI?}};
Feature1-- no-> fabric2 {{python vs. scala/java?}};
Feature1-- «Да»-> СПОРТИППМЛ ([<em> <strong> ppml </strong> </em>]);
Feature2-- Python-> feature3 {{какой тип приложения?}};
Feature2-- Scala/Java-> referdllib ([<em> <strong> dllib </strong> </em>]);
Feature3-- «Большая языковая модель»-> reformllm ([<em> <strong> llm </strong> </em>]);
Feature3-- «Большие данные + ai (tf/pytorch)»-> Referorca ([<em> <strong> orca </strong> </em>]));
Feature3-- Accelerate TensorFlow/Pytorch-> refernano ([<em> <strong> nano </strong> </em>]);
Feature3-- DL для Spark Mllib-> referdllib2 ([<em> <strong> dllib </strong> </em>]);
Feature3-- высокоуровневый приложение Framework-> feature4 {{Domain?}};
Feature4-- Временные ряды-> referchronos ([<em> <strong> chronos </strong> </em>]);
Feature4-- Рекомендационная система-> referfriesian ([<em> <strong> friesian </strong> </em>]);
Нажмите ссылку "https://github.com/intel-analytics/ipex-llm"
Щелкните SERMANANO "https://github.com/intel-analytics/bigdl-2.x#nano"
Щелкните реферику "https://github.com/intel-analytics/bigdl-2.x#orca"
Нажмите SEREDLLIB "https://github.com/intel-analytics/bigdl-2.x#dllib"
Нажмите SEREDLLIB2 "https://github.com/intel-analytics/bigdl-2.x#dllib"
Щелкните Reformchronos "https://github.com/intel-analytics/bigdl-2.x#chronos"
Нажмите SERECTFIRESIAN "https://github.com/intel-analytics/bigdl-2.x#friesian"
Нажмите SEREPPPML "https://github.com/intel-analytics/bigdl-2.x#ppml"
ClassDef RefersTyle1 Fill:#5099ce, ход:#5099ce;
ClassDef функции заполнения:#fff, ход:#08409c, ширина хода: 1px;
Класс Reformllm, Refermano, Referorca, Refermllib, Refermllib2, Referchronos, Refiesian, Referpmp RecersTyle1;
Class feature1, feature2, feature3, feature4, feature5, feature6, feature7 feature;
Чтобы установить BIGDL, мы рекомендуем использовать Conda Environment:
conda create -n my_env
conda activate my_env
pip install bigdl Чтобы установить последнюю ночную сборку, используйте pip install --pre --upgrade bigdl ; См. Руководство пользователя Python и Scala для получения более подробной информации.
Чтобы установить каждую отдельную библиотеку, такую как Chronos, используйте pip install bigdl-chronos ; Смотрите веб -сайт документа для более подробной информации.
Библиотека ORCA плавно расширяет программы для вашего отдельного узла Tensorflow , Pytorch или OpenVino в больших кластерах (чтобы обрабатывать распределенные большие данные).
Вы можете создать сквозные, распределенные программы обработки данных и ИИ с использованием ORCA в 4 простых шагах:
# 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, для более подробной информации.
Кроме того, вы также можете запустить стандартные программы Ray на Spark Cluster, используя RayonsPark в ORCA.
Вы можете не только запустить программу Ray на кластере Spark, но и написать код Ray в линии с помощью кода Spark (чтобы обработать RDD-RDD или DataFrames в памяти) с использованием RayonsPark в 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 )))См. Руководство пользователя RayonsPark и QuickStart для получения более подробной информации.
Вы можете прозрачно ускорить свои программы Tensorflow или Pytorch на вашем ноутбуке или сервере с помощью Nano . При минимальных изменениях кода Nano автоматически применяет современные оптимизации процессора (например, SIMD, многопроцессор, низкая точность и т. Д.) К стандартному коду TensorFlow и Pytorch с более 10-кратным ускорением.
Вы можете автоматически оптимизировать обученную модель Pytorch для вывода или развертывания с помощью 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 () Выход 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 для получения более подробной информации.
С помощью Dllib вы можете написать распределенные приложения глубокого обучения в качестве стандартных программ Spark ( Scala или Python ), используя те же самые искрутные данные и API -интерфейсы ML .
Вы можете создать распределенные приложения для глубокого обучения для Spark, используя API dllib scala в 3 простых шагах:
// 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)Вы можете создать распределенные приложения для глубокого обучения для Spark, используя API Dllib Python в 3 простых шагах:
# 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).
Вы можете обучить прогнозист временных рядов, используя Chronos в 3 простых шагах:
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 и быстрое начало для более подробной информации.
Фризеанская библиотека позволяет легко создавать сквозную, крупномасштабную систему рекомендации (включая трансформацию и трансляцию в автономном режиме , функцию и обновление моделей в ближней линии , а также онлайн- конвейер).
Смотрите Freisian Readme для более подробной информации.
BIGDL PPML предоставляет аппаратное обеспечение (Intel SGX), защищенную доверенной кластерной средой для запуска распределенных приложений Big Data & AI (безопасным образом на частном или общественном облаке).
См. Руководство пользователя 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}
}
