DOCSEARCHbyAlgolia
Submit Docs

Sionna Documentation

repository·main·Indexed 23 days ago

https://github.com/nvlabs/sionna

Sionna is a hardware-accelerated, differentiable open-source Python library for communication systems research. It consists of three primary modules: Sionna RT, a high-speed standalone ray tracer for radio propagation modeling built on Mitsuba 3 and Dr.Jit; Sionna PHY, a link-level simulator for wireless and optical communication systems written in PyTorch; and Sionna SYS, a system-level simulator using physical-layer abstractions. It supports automatic differentiation and GPU acceleration via NVIDIA GPUs.

Tokens
27.1K
Snippets
50
Records
104
Agent score
82%

What's inside Sionna

  1. Overview of Sionna modules and capabilities

    main

    Sionna is a hardware-accelerated, differentiable open-source library for communication systems research. It is designed with modularity and extensibility, allowing users to prototype complex architectures by connecting independent building blocks, similar to stacking layers in a deep neural network.

    Sionna is composed of three primary modules:

    • Sionna RT: A high-speed, stand-alone ray tracer for radio propagation modeling. It is built on top of Mitsuba 3 and Dr.Jit.
    • Sionna PHY: A link-level simulator for wireless and optical communication systems. It is written in PyTorch.
    • Sionna SYS: System-level simulation functionalities that utilize physical-layer abstractions. It is written in PyTorch.

    Key Features:

    • Differentiability: Built on PyTorch, Mitsuba 3, and Dr.Jit, Sionna supports automatic differentiation, enabling gradient-based optimization and the integration of neural networks throughout the entire system.
    • GPU Acceleration: Optimized for NVIDIA GPUs to provide high-speed simulation (ideal for Jupyter notebooks and Google Colab). If no GPU is detected, Sionna falls back to CPU execution.
    • Sionna Research Kit (SRK): An extension for deploying trained AI/ML components into a real software-defined 5G NR radio access network (RAN), based on the OpenAirInterface project.

  2. Overview of Forward Error Correction (FEC) in Sionna

    main

    The Sionna FEC package provides encoding and decoding algorithms for various coding schemes and auxiliary physical layer processing components. It is designed to integrate seamlessly into a larger physical layer processing chain.

    Supported Coding Schemes:

    • Low-Density Parity-Check (LDPC) codes (5G compliant)
    • Polar codes (5G compliant)
    • Turbo codes
    • Convolutional codes
    • Cyclic Redundancy Checks (CRC)

    Auxiliary Physical Layer Components:

    • Interleavers
    • Scramblers
    • Rate-matching

    When choosing a coding scheme, consider factors beyond error rate, such as decoding complexity, latency, scalability, parallelism, memory access patterns, error-floor behavior, and rate adaptivity.

  3. Overview of Sionna 2.0

    main

    Sionna is an open-source Python-based library designed for research on communication systems. It is organized into three primary packages:

    • Sionna RT: A high-speed, standalone ray tracer used for radio propagation modeling.
    • Sionna PHY: A link-level simulator for wireless and optical communication systems.
    • Sionna SYS: A system-level simulator built on physical-layer abstractions.

  4. Use the sionna.phy.mimo module for MIMO signal processing

    main

    The sionna.phy.mimo module provides a comprehensive suite of components for Multiple-Input Multiple-Output (MIMO) signal processing. It is organized into several functional areas:

    • Stream Management: For configuring multi-user MIMO setups and managing data streams.
    • Precoding: Functions for transmit beamforming to shape the signal before transmission.
    • Equalization: Linear receive processing techniques to mitigate channel effects.
    • Detection: Algorithms used for symbol recovery at the receiver.
    • Utility: Common MIMO-related operations and helper functions.

  5. Simulate OFDM-based systems with sionna.phy.ofdm

    main

    The sionna.phy.ofdm module provides the necessary layers and functions to simulate Orthogonal Frequency-Division Multiplexing (OFDM) systems. The workflow typically involves:

    1. Defining the Resource Grid: Use ResourceGrid to define how data and pilot symbols are mapped onto OFDM symbols (including FFT size, guard carriers, and DC carriers). In 4G/5G terminology, this represents a 'slot'.
    2. Mapping Symbols: Use ResourceGridMapper to map complex-valued data symbols onto the defined ResourceGrid.
    3. Modulation: Apply OFDMModulator to perform OFDM modulation on the mapped symbols.
    4. Pilot Configuration: Use PilotPattern or KroneckerPilotPattern to manage pilot transmissions across streams or antennas.
    5. Signal Processing: Utilize built-in blocks for channel estimation, precoding, equalization, and detection.

  6. Use signal processing components in sionna.phy.signal

    main

    The sionna.phy.signal module provides core signal processing components for communication systems. It is organized into three main functional areas:

    • Filters: Used for pulse shaping and matched filtering.
    • Window Functions: Used for spectral analysis and filter design.
    • Utility: Provides common signal operations.

    You can access these components via the sionna.phy.signal namespace to build up physical layer signal processing chains.

  7. What is Link Adaptation in Sionna

    main

    Link adaptation (LA) is a mechanism used to optimize the performance of a wireless link by dynamically adjusting transmission parameters (such as modulation and coding schemes) to match time-varying channel conditions.

    In Sionna, the goal is typically to maximize throughput while maintaining a target Transport Block Error Rate (TBLER). The core challenge addressed is estimating channel quality from noisy and sparse SINR feedback.

    Sionna provides two main classes for implementing link adaptation:

    • InnerLoopLinkAdaptation
    • OuterLoopLinkAdaptation

    For a practical implementation guide, refer to the Link Adaptation notebook.

  8. Configure OFDM resource grids using ResourceGrid

    main

    The ResourceGrid is the central component for defining the structure of an OFDM symbol sequence. It specifies:

    • The mapping of data and pilot symbols.
    • The FFT size.
    • The location of guard carriers and DC carriers (which are nulled).

    In 4G/5G systems, a ResourceGrid corresponds to a slot.

  10. Manage pilot transmissions with PilotPattern and KroneckerPilotPattern

    main

    To configure how transmitters send pilots for different streams or antennas, use the following classes:

    • PilotPattern: Provides fine-grained configuration for pilot placement.
    • KroneckerPilotPattern: Automatically generates orthogonal pilot transmissions for all transmitters and streams. This is particularly useful in multi-cell MIMO setups to manage the complexity of pilot coordination.

  11. System requirements for Sionna PHY and SYS

    main

    Sionna PHY and Sionna SYS have specific environment requirements:

    • Python: 3.11 or higher.
    • PyTorch: 2.9 or higher (earlier versions are not recommended).
    • OS: Ubuntu 24.04 is recommended.
    • GPU Support: For CUDA support, refer to the PyTorch get-started guide for driver setup.

    If you wish to run tutorial notebooks locally, you will also need JupyterLab.

  12. How interleaving and deinterleaving work in Sionna

    main

    The sionna.phy.fec.interleaving module provides tools to permute tensors using pseudo-random permutations or row/column swapping.

    To support distributed graph execution (e.g., running the interleaver and deinterleaver on different devices or sub-graphs), the interleaver layers are implemented as stateless operations. This means the internal seed is fixed at initialization and cannot be updated at runtime.

    To achieve different permutations for different calls, you must pass an explicit random seed as an additional input to both the interleaver and the deinterleaver during the call.

    # Simplified usage (fixed seed from initialization)
interleaver = RandomInterleaver(seed=1234, keep_batch_constant=False, axis=-1)
deinterleaver = Deinterleaver(interleaver=interleaver)

c_int = interleaver(c)
c_deint = deinterleaver(c_int)

# Advanced usage (providing a new seed per call)
s = tf.random.uniform((), minval=0, maxval=12345678, dtype=tf.int32)
c_int = interleaver([c, s])
c_deint = deinterleaver([c_int, s])