Model Online / On-Site
Duration
Modules 5 modules

Course Objective & Scope

Every major AI engine—PyTorch, TensorFlow, ONNX Runtime, llama.cpp and TensorRT—is written in C++ under the hood, and edge devices, robotics, game engines and ultra-low-latency services frequently require running inference natively without a Python runtime. This intensive programme bridges foundational modern C++ (C++17/20) with high-performance AI engineering.

Participants master safe memory management through RAII, smart pointers and move semantics, write concurrent code with STL and multithreading primitives, accelerate Python bottlenecks using pybind11, and build standalone native inference binaries with the LibTorch and ONNX Runtime C++ APIs. Teams leave with a CMake-based C++ inference project template.

Who Should Attend?

  • AI and software engineers deploying models in Python-free environments (embedded, robotics, desktop or low-latency services)
  • ML engineers writing custom C++ extensions (pybind11 / nanobind) to eliminate Python bottlenecks
  • Developers updating legacy C/C++ skills to modern C++17/20 standards for AI workloads
  • Prerequisite: programming experience in at least one language (Python, C, Java or C#)

Key Takeaways

  • Manage stack/heap memory safely using references, RAII and smart pointers (std::unique_ptr, std::shared_ptr)
  • Write zero-copy code with move semantics, std::span, constexpr, templates and STL algorithms
  • Implement multi-core preprocessing and compute tasks using std::thread, std::async, mutexes and atomics
  • Compile C++ extensions for Python with pybind11 that operate directly on NumPy and PyTorch tensor buffers
  • Link LibTorch or ONNX Runtime C++ via CMake to build a standalone native inference executable

Curriculum

Modern C++ Foundations, Memory Model and RAII
  • Compilation pipeline, CMake project setup, value/reference semantics, const correctness and auto
  • Stack vs Heap, the RAII idiom and replacing raw pointers with std::unique_ptr and std::shared_ptr
STL, Move Semantics and Template Programming
  • std::vector memory layout, std::string_view, std::span (C++20) and STL algorithms
  • Lvalue/Rvalue references, zero-copy transfers with std::move, generic templates and lambdas
Multithreading and Performance-Oriented C++
  • std::thread, std::jthread, std::async, std::mutex, std::lock_guard and thread-pool patterns
  • Cache-friendly data layouts, compiler optimisation flags and SIMD vectorisation
Bridging Python and C++ with pybind11
  • Wrapping C++ functions and classes as installable Python modules using pybind11 / nanobind
  • Zero-copy manipulation of NumPy arrays via the buffer protocol and custom PyTorch C++ extensions (torch::Tensor)
Native C++ Model Inference with ONNX Runtime and LibTorch
  • Loading models, constructing input tensors and running inference with the ONNX Runtime C++ API and LibTorch
  • Memory checking with AddressSanitizer/Valgrind and packaging a standalone C++ inference binary

Other Courses in This Category

  • Python Programming Python Programming

    Master Python from scratch: data structures, control flow, functional programming, Object-Oriented Programming (OOP), error handling, file I/O, virtual environments, and Pandas.

    Programming for AI Corporate, Individual
    Live Course
    9 modules
    View
  • Advanced Python for AI and Data Engineering

    Advanced Python for AI and data engineering: type hinting, decorators, memory-efficient generators, asyncio, multiprocessing and the GIL, Cython/Numba acceleration, profiling and packaging. For developers and data scientists.

    Programming for AI Corporate
    Live Course
    5 modules
    View
  • API Integration and Development with Python for AI Projects

    Consuming and building APIs in Python for AI and data projects: HTTP/REST principles, requests and async httpx clients, authentication, retry/rate-limit handling, LLM APIs and foundational service design.

    Programming for AI Corporate
    Live Course
    5 modules
    View
  • Building Modern Backend and AI APIs with FastAPI

    End-to-end modern Python web service development with FastAPI: Pydantic v2, Dependency Injection, async SQLAlchemy database integration, OAuth2/JWT security, pytest and Docker. For backend and AI developers.

    Programming for AI Corporate
    Live Course
    5 modules
    View
  • PyTorch Fundamentals for Deep Learning

    Deep learning programming fundamentals with PyTorch: Tensor operations and GPU acceleration, autograd, Dataset/DataLoader pipelines, building neural networks with nn.Module, training loops and saving models. For data scientists and developers.

    Programming for AI Corporate
    Live Course
    5 modules
    View
  • TensorFlow and Keras Fundamentals for Deep Learning

    Deep learning fundamentals with TensorFlow 2 and Keras: tf.Tensor, GradientTape, tf.data pipelines, building models with Sequential/Functional/Subclassing APIs, callbacks, TensorBoard and SavedModel. For data scientists and engineers.

    Programming for AI Corporate
    Live Course
    5 modules
    View

Get in touch