Train and Get Certified at GTC Paris at VivaTech 2025

Just like how humans have multiple senses to perceive the world around them, more and more computer sensors are being developed to capture a wide variety of data. In the health industry, computed tomography (CT) scans provide a 3D representation to detect potentially dangerous abnormalities. In the robotics industry, lidars help robots see depth and navigate their complex environments. In this course, learners will develop neural network agents that can reason using many different data types by exploring multiple fusion techniques. 

You’ll learn about:

• Different data types and how to make them ready for neural networks.
• Model fusion, and the differences between early, late, and intermediate fusion.
• Structure loss and how to avoid it.
• The difference between modality and agent orchestration.

Upon completion, you'll be able to orchestrate several multimodal agents into an application.

Prerequisite(s)

• Basic understanding of Python, including classes, objects, and decorators.
• Basic understanding of neural networks, such as image convolution and sequential models

Retrieval-Augmented Generation (RAG) pipelines are revolutionizing enterprise operations. However, most existing tutorials stop at proof-of-concept implementations that falter when scaling. This workshop aims to bridge that gap, focusing on building scalable, production-ready RAG pipelines powered by NVIDIA NIM microservices and Kubernetes. Participants will gain hands-on experience deploying, monitoring, and scaling RAG pipelines with the NIM Operator and learn best practices for infrastructure optimization, performance monitoring, and handling high traffic volumes.

The workshop begins by building a simple RAG pipeline using the NVIDIA API catalog. Participants will deploy and test individual components in a local environment using Docker Compose. Once familiar with the basics, the focus will shift to deploying NIMs, such as LLM, NeMo Retriever Text Embedding, and NeMo Retriever Text Reranking, in a Kubernetes cluster using the NIM Operator. This'll include managing the deployment, monitoring, and scalability of NVIDIA NIM microservices. The workshop will focus on building a RAG pipeline that can be used in production. It'll also look at the NVIDIA AI Blueprint for PDF ingestion, and how to use it in the RAG pipeline.

To ensure operational efficiency, the workshop will introduce Prometheus and Grafana for monitoring pipeline performance, cluster health, and resource utilization. Scalability will be addressed through the use of the Kubernetes Horizontal Pod Autoscaler (HPA) for dynamically scaling NIMs based on custom metrics in conjunction with the NIM Operator. Custom dashboards will be created to visualize key metrics and interpret performance insights.

You'll be able to:

• Build a simple RAG pipeline using API endpoints, deployed locally with Docker Compose.
• Deploy a variety of NVIDIA NIM microservices in a Kubernetes cluster using the NIM Operator.
• Combine NIMs into a cohesive, production-grade RAG pipeline and integrate advanced data ingestion workflows.
• Monitor RAG pipelines and Kubernetes clusters with Prometheus and Grafana.
• Scale NIMs to handle high traffic using the NIM Operator.
• Create, deploy, and scale RAG pipelines for a variety of agentic workflows, including PDF ingestion.

Prerequisite(s)

• Familiarity working with LLM-based applications
• Familiarity with RAG pipelines
• Familiarity working with Kubernetes
• Familiarity working with Helm

This workshop provides a comprehensive introduction to general-purpose GPU programming with NVIDIA® CUDA®. You'll learn how to write, compile, and run GPU-accelerated code, use CUDA core libraries to tap into the power of massive parallelism provided by modern GPU accelerators, optimize memory migration between CPU and GPU, and implement your own algorithms.

At the conclusion of the workshop, you'll have an understanding of the fundamental concepts and techniques for accelerating C++ code with CUDA and be able to:

• Write and compile code that runs on the GPU
• Optimize memory migration between CPU and GPU
• Use powerful parallel algorithms that simplify adding GPU acceleration to your code
• Implement your own parallel algorithms by directly programming GPUs with CUDA kernels
• Use concurrent CUDA streams to overlap memory traffic with compute
• Know where, when, and how best to add CUDA acceleration to existing CPU-only applications

Prerequisite(s)

• Basic C++ competency, including familiarity with lambda expressions, loops, conditional statements, functions, standard algorithms, and containers.
• No previous knowledge of CUDA programming is assumed.

In today's AI landscape, even powerful Large Language Models (LLMs) face limitations when confronted with specialized business knowledge, technical domains, or cultural contexts absent from their training data. While retrieval-augmented generation can mitigate some gaps, true domain mastery requires a deeper level of model adaptation.

This comprehensive workshop equips developers with hands-on skills to transform open-source LLMs into domain-specialized AI assets. Through five interconnected modules, you'll master the complete lifecycle of model customization:

• Systematic Evaluation and Dataset Creation: Build custom evaluation benchmarks using NeMo Evaluator to identify model limitations and track engineering progress. Learn metrics that matter for your specific use case.
• Advanced Data Curation: Implement state-of-the-art data cleaning pipelines with NeMo Curator to assemble high-quality domain-specific datasets that address your business or cultural requirements.
• Targeted Knowledge Injection: Master multiple adaptation techniques, including in-context learning, Parameter-Efficient Fine-Tuning (PEFT), Continued Pre-Training (CPT), Supervised Fine-Tuning (SFT), and Reinforcement Learning from Human Feedback (RLHF).
• Model Optimization: Apply distillation, quantization, and pruning techniques with NeMo Model Optimizer and TensorRT-LLM to dramatically reduce inference costs without sacrificing performance.
• Production Deployment: Learn to deploy, monitor, and scale your custom models within Kubernetes environments using NVIDIA Inference Microservices (NIMs).

By workshop completion, you'll possess the complete technical skill set to develop, deploy, and operate sovereign AI systems tailored to your specific requirements—from data preparation to production scaling.

Prerequisite(s)

• Intermediate Python programming skills
• Previous work with LLM-based applications and understanding of prompt engineering principles
• Experience with data processing pipelines and text preprocessing techniques
• Understanding of fine-tuning, training/validation splits, and basic ML metrics
• Basic knowledge of GPU acceleration for ML workloads (CUDA experience helpful but not required)
• Familiarity with containerization and basic Kubernetes concepts (Optional but helpful)

As manufacturing accelerates toward automation and AI-driven processes, digital twins are becoming essential for simulating, testing, and deploying intelligent systems in real-world factory environments.

In this workshop, you'll learn about:

• Creating digital twins from manufacturing data using OpenUSD and Omniverse.
• Simulating accurate sensor data with NVIDIA Cosmos and Sensor RTX ‌to power AI perception, localization, and decision-making.
• Applying Metropolis VSS for semantic labeling, tracking, and classification.
• Generating large-scale, labeled datasets from digital twins to train AI models and create closed-loop robot learning workflows.

By the end of this workshop, attendees will have hands-on experience building simulation-ready digital twins and learn how these twins support the development of physical AI systems in the manufacturing domain.

Topics Covered:

• Create a digital twin from existing 3D data.
• Generate synthetic sensor data to power AI perception, localization, and decision-making
• Integrate Metropolis VSS for search and semantic labeling.
• Generate large-scale datasets to train AI models.

Prerequisite(s)

• Familiarity with 3D workflows or CAD tools commonly used in manufacturing
• Basic understanding of AI concepts, such as perception, localization, and planning
• Exposure to simulation, robotics, or automation workflow

Unlock the power of simulation-driven robotics with NVIDIA Isaac Sim and Isaac Lab. This hands-on, full-day workshop is designed for robotics engineers, applied researchers, and R&D teams focused on building, training, and simulating robots in software.

In this workshop, you'll learn about:

• Structuring modular robot assets using OpenUSD and importing CAD/URDF models
• Integrating robots into virtual environments in Isaac Sim
• Connecting ROS 2 for real-time robot control and software-in-the-loop testing
• Accelerating perception and AI workloads using NVIDIA GPU-powered libraries
• Generating physically accurate synthetic data for robust robot training

By the end of this workshop, attendees will have hands-on experience building robot simulations and integrating synthetic data pipelines to build scalable, simulation-first workflows.

Prerequisite(s)

• Proficiency in Python programming
• Familiarity with ROS 2 (Robot Operating System)
• Familiarity with 3D workflows or CAD tools commonly used in robotics
• Exposure to simulation and robotics workflows