Inicio>Relacionado con la programación>C/C++
Descargar

Enorme CTR

HugeCTR es un marco de recomendación acelerado por GPU diseñado para el entrenamiento y la inferencia de grandes modelos de aprendizaje profundo.

Objetivos de diseño:

  • Rápido : HugeCTR se desempeña de manera sobresaliente en los puntos de referencia de recomendación, incluido MLPerf.
  • Fácil : independientemente de si es un científico de datos o un profesional del aprendizaje automático, hemos facilitado que cualquiera pueda usar HugeCTR con una gran cantidad de documentos, cuadernos y muestras.
  • Específico del dominio : HugeCTR proporciona lo esencial para que pueda implementar de manera eficiente sus modelos de recomendación con una incrustación muy grande.

NOTA : Si tiene alguna pregunta sobre el uso de HugeCTR, presente un problema o únase a nuestro canal de Slack para tener debates más interactivos.

Tabla de contenido

  • Características principales
  • Empezando
  • SDK enorme de CTR
  • Soporte y comentarios
  • Contribuyendo a HugeCTR
  • Recursos adicionales

Características principales

HugeCTR admite una variedad de funciones, incluidas las siguientes:

  • Interfaz Python abstracta de alto nivel
  • Modelo de entrenamiento paralelo
  • Flujo de trabajo de GPU optimizado
  • Entrenamiento multinodo
  • Entrenamiento de precisión mixto
  • Incrustar caché de entrenamiento
  • Caché de incorporación de GPU
  • Mecanismo de intercambio de memoria GPU/CPU entre varias instancias de inferencia
  • Convertidor HugeCTR a ONNX
  • Servidor de parámetros jerárquicos
  • Kit de operación escaso

Para conocer nuestras últimas mejoras, consulte nuestras notas de la versión.

Empezando

Si desea entrenar rápidamente un modelo utilizando la interfaz de Python, haga lo siguiente:

  1. Inicie un contenedor NGC con su directorio de host local (/your/host/dir montado) ejecutando el siguiente comando: 

     docker run --gpus=all --rm -it --cap-add SYS_NICE -v /your/host/dir:/your/container/dir -w /your/container/dir -it -u $(id -u):$(id -g) nvcr.io/nvidia/merlin/merlin-hugectr:24.06

    NOTA : El directorio /your/host/dir es tan visible como el directorio /your/container/dir . El directorio /your/host/dir también es su directorio de inicio.

    NOTA : HugeCTR usa NCCL para compartir datos entre rangos, y NCCL puede requerir memoria compartida para IPC y recursos de memoria del sistema anclados (bloqueados por página). Se recomienda aumentar estos recursos emitiendo las siguientes opciones en el comando docker run . 

     -shm-size=1g -ulimit memlock=-1

  2. Escriba un script Python simple para generar un conjunto de datos sintéticos: 

     # dcn_parquet_generate.py
import hugectr
from hugectr.tools import DataGeneratorParams, DataGenerator
data_generator_params = DataGeneratorParams(
  format = hugectr.DataReaderType_t.Parquet,
  label_dim = 1,
  dense_dim = 13,
  num_slot = 26,
  i64_input_key = False,
  source = "./dcn_parquet/file_list.txt",
  eval_source = "./dcn_parquet/file_list_test.txt",
  slot_size_array = [39884, 39043, 17289, 7420, 20263, 3, 7120, 1543, 39884, 39043, 17289, 7420, 
                     20263, 3, 7120, 1543, 63, 63, 39884, 39043, 17289, 7420, 20263, 3, 7120,
                     1543 ],
  dist_type = hugectr.Distribution_t.PowerLaw,
  power_law_type = hugectr.PowerLaw_t.Short)
data_generator = DataGenerator(data_generator_params)
data_generator.generate()

  3. Genere el conjunto de datos de Parquet para su modelo DCN ejecutando el siguiente comando: 

     python dcn_parquet_generate.py

    NOTA : El conjunto de datos generado residirá en la carpeta ./dcn_parquet , que contiene datos de capacitación y evaluación.

  4. Escriba un script Python simple para entrenamiento: 

     # dcn_parquet_train.py
import hugectr
from mpi4py import MPI
solver = hugectr.CreateSolver(max_eval_batches = 1280,
                              batchsize_eval = 1024,
                              batchsize = 1024,
                              lr = 0.001,
                              vvgpu = [[0]],
                              repeat_dataset = True)
reader = hugectr.DataReaderParams(data_reader_type = hugectr.DataReaderType_t.Parquet,
                                 source = ["./dcn_parquet/file_list.txt"],
                                 eval_source = "./dcn_parquet/file_list_test.txt",
                                 slot_size_array = [39884, 39043, 17289, 7420, 20263, 3, 7120, 1543, 39884, 39043, 17289, 7420, 
                                                   20263, 3, 7120, 1543, 63, 63, 39884, 39043, 17289, 7420, 20263, 3, 7120, 1543 ])
optimizer = hugectr.CreateOptimizer(optimizer_type = hugectr.Optimizer_t.Adam,
                                    update_type = hugectr.Update_t.Global)
model = hugectr.Model(solver, reader, optimizer)
model.add(hugectr.Input(label_dim = 1, label_name = "label",
                        dense_dim = 13, dense_name = "dense",
                        data_reader_sparse_param_array =
                        [hugectr.DataReaderSparseParam("data1", 1, True, 26)]))
model.add(hugectr.SparseEmbedding(embedding_type = hugectr.Embedding_t.DistributedSlotSparseEmbeddingHash,
                           workspace_size_per_gpu_in_mb = 75,
                           embedding_vec_size = 16,
                           combiner = "sum",
                           sparse_embedding_name = "sparse_embedding1",
                           bottom_name = "data1",
                           optimizer = optimizer))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.Reshape,
                           bottom_names = ["sparse_embedding1"],
                           top_names = ["reshape1"],
                           leading_dim=416))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.Concat,
                           bottom_names = ["reshape1", "dense"], top_names = ["concat1"]))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.MultiCross,
                           bottom_names = ["concat1"],
                           top_names = ["multicross1"],
                           num_layers=6))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.InnerProduct,
                           bottom_names = ["concat1"],
                           top_names = ["fc1"],
                           num_output=1024))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.ReLU,
                           bottom_names = ["fc1"],
                           top_names = ["relu1"]))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.Dropout,
                           bottom_names = ["relu1"],
                           top_names = ["dropout1"],
                           dropout_rate=0.5))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.Concat,
                           bottom_names = ["dropout1", "multicross1"],
                           top_names = ["concat2"]))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.InnerProduct,
                           bottom_names = ["concat2"],
                           top_names = ["fc2"],
                           num_output=1))
model.add(hugectr.DenseLayer(layer_type = hugectr.Layer_t.BinaryCrossEntropyLoss,
                           bottom_names = ["fc2", "label"],
                           top_names = ["loss"]))
model.compile()
model.summary()
model.graph_to_json(graph_config_file = "dcn.json")
model.fit(max_iter = 5120, display = 200, eval_interval = 1000, snapshot = 5000, snapshot_prefix = "dcn")

    NOTA : Asegúrese de que las rutas a los conjuntos de datos sintéticos sean correctas con respecto a este script de Python. data_reader_type , check_type , label_dim , dense_dim y data_reader_sparse_param_array deben ser coherentes con el conjunto de datos generado.

  5. Entrene el modelo ejecutando el siguiente comando: 

     python dcn_parquet_train.py

    NOTA : Se supone que el valor AUC de evaluación es incorrecto ya que se utilizan conjuntos de datos generados aleatoriamente. Cuando finalice el entrenamiento, se generarán archivos que contienen el JSON del gráfico volcado, los pesos del modelo guardados y los estados del optimizador.

Para obtener más información, consulte la Guía del usuario de HugeCTR.

SDK enorme de CTR

Podemos ayudar a los desarrolladores externos que no pueden usar HugeCTR directamente exportando componentes importantes de HugeCTR usando:

  • Directorio del kit de operación dispersa | documentación: un paquete de Python empaquetado con operaciones aceleradas por GPU dedicadas a casos dispersos de entrenamiento/inferencia.
  • Caché de incrustación de GPU: caché de incrustación disponible en la memoria de la GPU diseñada para la carga de trabajo de inferencia CTR.

Soporte y comentarios

Si tiene algún problema o tiene preguntas, vaya a https://github.com/NVIDIA/HugeCTR/issues y envíe un problema para que podamos brindarle las resoluciones y respuestas necesarias. Para avanzar aún más en la hoja de ruta de HugeCTR, le recomendamos que comparta todos los detalles relacionados con el proceso de su sistema de recomendación mediante esta encuesta.

Contribuyendo a HugeCTR

Dado que HugeCTR es un proyecto de código abierto, agradecemos las contribuciones del público en general. Con sus contribuciones, podemos continuar mejorando la calidad y el rendimiento de HugeCTR. Para saber cómo contribuir, consulte nuestra Guía para contribuyentes de HugeCTR.

Recursos adicionales

Paginas web
NVIDIA Merlín
NVIDIA enorme CTR

Publicaciones

Yingcan Wei, Matthias Langer, Fan Yu, Minseok Lee, Jie Liu, Ji Shi y Zehuan Wang , "Un servidor de parámetros de inferencia especializado en GPU para modelos de recomendación profunda a gran escala", Actas de la 16ª Conferencia ACM sobre sistemas de recomendación, págs. 408-419, 2022.

Zehuan Wang, Yingcan Wei, Minseok Lee, Matthias Langer, Fan Yu, Jie Liu, Shijie Liu, Daniel G. Abel, Xu Guo, Jianbing Dong, Ji Shi y Kunlun Li , "Merlin HugeCTR: entrenamiento e inferencia del sistema de recomendación acelerado por GPU , "Actas de la 16ª Conferencia ACM sobre sistemas de recomendación, págs. 534-537, 2022.

Negociaciones

Conferencia / Sitio web Título Fecha Vocero Idioma
ACM RecSys 2022 Un servidor de parámetros de inferencia especializado en GPU para modelos de recomendación profunda a gran escala Septiembre 2022 Matías Langer Inglés
Vídeos cortos episodio 1 Merlin HugeCTR: GPU 加速的推荐系统框架mayo 2022 Joey Wang中文
Vídeos cortos episodio 2 HugeCTR 分级参数服务器如何加速推理mayo 2022 Joey Wang中文
Vídeos Cortos Episodio 3 Incluye HugeCTR SOK y TensorFlow. mayo 2022 Gemas Guo中文
GTC Primavera 2022 Merlin HugeCTR: servidor de parámetros de inferencia jerárquica distribuida que utiliza caché de incrustación de GPU marzo 2022 Matthias Langer, Yingcan Wei, Yu Fan Inglés
APSARA 2021 GPU 推荐系统 Merlin octubre de 2021 Joey Wang中文
GTC Primavera 2021 Descubra cómo Tencent implementó un sistema de publicidad en el marco de recomendación de GPU Merlin abril 2021 Xiangting Kong, Joey Wang Inglés
GTC Primavera 2021 Merlin HugeCTR: profundización en la optimización del rendimiento abril 2021 Minseok Lee Inglés
GTC Primavera 2021 Integre la incrustación de HugeCTR con TensorFlow abril 2021 Jianbing Dong Inglés
GTC China 2020 MERLIN HUGECTR: 深入研究性能优化octubre de 2020 Minseok Lee Inglés
GTC China 2020性能提升 7 倍 + 的高性能 GPU 广告推荐加速系统的落地实现octubre de 2020 Xiangting Kong中文
GTC China 2020使用 CACHE DE INTEGRACIÓN DE GPU 加速 CTR 推理过程octubre de 2020 fan yu中文
GTC China 2020将 HUGECTR EMBEDDING 集成于 TENSORFLOW octubre de 2020 Jianbing Dong中文
GTC Primavera 2020 HugeCTR: capacitación en estimación de la tasa de clics de alto rendimiento marzo 2020 Minseok Lee, Joey Wang Inglés
GTC China 2019 HUGECTR: GPU 加速的推荐系统训练octubre de 2019 Joey Wang中文

Blogs

Conferencia / Sitio web Título Fecha Autores Idioma
Blog de Wechat Merlin HugeCTR 分级参数服务器系列之三：集成到TensorFlow noviembre de 2022 Kingsley Liu中文
Blog de desarrollo de NVIDIA Escalar la inferencia del sistema de recomendación con el servidor de parámetros jerárquicos de Merlin/使用 Merlin 分层参数服务器扩展推荐系统推理agosto 2022 Shashank Verma, Wenwen Gao, Yingcan Wei, Matthias Langer, Jerry Shi, Fan Yu, Kingsley Liu, Minseok Lee Inglés/中文
Blog de desarrollo de NVIDIA Kit de operación dispersa Merlin HugeCTR junio 2022 Kunlun Li中文
Blog de desarrollo de NVIDIA Kit de operación dispersa Merlin HugeCTR marzo 2022 Gemas Guo, Jianbing Dong中文
Blog de Wechat Merlin HugeCTR 分级参数服务器系列之二marzo 2022 Yingcan Wei, Matthias Langer, Jerry Shi中文
Blog de Wechat Merlin HugeCTR 分级参数服务器系列之一enero de 2022 Yingcan Wei, Jerry Shi中文
Blog de desarrollo de NVIDIA Acelerando la incrustación con el complemento de incrustación HugeCTR TensorFlow septiembre de 2021 Vinh Nguyen, Ann Spencer, Joey Wang y Jianbing Dong Inglés
medio.com Optimización de la plataforma de aprendizaje automático de Meituan: una entrevista con Jun Huang septiembre de 2021 Sheng Luo y Benedikt Schifferer Inglés
medio.com Diseño y desarrollo líderes del sistema de recomendación de publicidad en Tencent: una entrevista con Xiangting Kong septiembre de 2021 Xiangting Kong, Ann Spencer Inglés
Blog de desarrollo de NVIDIA扩展和加速大型深度学习推荐系统 – HugeCTR 系列第 1 página junio 2021 Minseok Lee中文
Blog de desarrollo de NVIDIA使用 Merlin HugeCTR y Python API 训练大型深度学习推荐模型 – HugeCTR 系列第 2 páginas junio 2021 Vinh Nguyen中文
medio.com Entrenamiento de grandes modelos de recomendación de aprendizaje profundo con las API de Python de Merlin HugeCTR: serie HugeCTR, parte 2 mayo 2021 Minseok Lee, Joey Wang, Vinh Nguyen y Ashish Sardana Inglés
medio.com Ampliación y aceleración de grandes sistemas de recomendación de aprendizaje profundo: serie HugeCTR, parte 1 mayo 2021 Minseok Lee Inglés
Hacienda 2020 Merlin: un marco de recomendación acelerado por GPU agosto de 2020 Incluso Oldridge, etc. Inglés
Blog de desarrollo de NVIDIA Presentamos NVIDIA Merlin HugeCTR: un marco de capacitación dedicado a sistemas de recomendación julio 2020 Minseok Lee y Joey Wang Inglés
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo