### cuSPARSELt Getting Started

Source: https://docs.nvidia.com/cuda/cusparselt/index

Guides and resources to help users begin with the cuSPARSELt library, including installation, prerequisites, and code examples.

```APIDOC
## cuSPARSELt Getting Started Guide

### Description
This section provides essential information for users new to cuSPARSELt, covering the workflow, setup, and basic usage.

### Key Topics:

*   **cuSPARSELt Workflow**: An overview of how to integrate cuSPARSELt into your projects.
*   **Installation and Compilation**: Instructions on how to install and build the cuSPARSELt library.
*   **Prerequisites**: Details on the system requirements and dependencies needed for cuSPARSELt.
*   **Code Example**: A practical code snippet to demonstrate the basic usage of cuSPARSELt functions.

### Resources:

*   [Getting Started](https://docs.nvidia.com/cuda/cusparselt/getting_started.html)
*   [cuSPARSELt Workflow](https://docs.nvidia.com/cuda/cusparselt/getting_started.html#cusparselt-workflow)
*   [Installation and Compilation](https://docs.nvidia.com/cuda/cusparselt/getting_started.html#installation-and-compilation)
*   [Prerequisites](https://docs.nvidia.com/cuda/cusparselt/getting_started.html#prerequisites)
*   [Code Example](https://docs.nvidia.com/cuda/cusparselt/getting_started.html#code-example)
```

--------------------------------

### VST Quickstart Guide

Source: https://docs.nvidia.com/jetson/jps/index

Quickstart guide for getting started with the Video Storage Toolkit (VST) on NVIDIA Jetson.

```APIDOC
## VST Usage & Configuration

### Description
This guide provides instructions on the usage and configuration of the Video Storage Toolkit (VST) on NVIDIA Jetson devices.

### Method
GET

### Endpoint
/websites/nvidia/jetson/jps/vst/VST_Quickstart_guide.html.md

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **Documentation Link** (string) - URL to the VST Usage & Configuration guide.

#### Response Example
{
  "Documentation Link": "https://docs.nvidia.com/jetson/jps/vst/VST_Quickstart_guide.html.md"
}
```

--------------------------------

### cuSOLVERMP Installation and Getting Started

Source: https://docs.nvidia.com/cuda/cusolvermp/index

Information on how to install cuSOLVERMP and get started with its usage, including hardware and software requirements, and an overview of the typical workflow.

```APIDOC
## cuSOLVERMP Installation and Getting Started

### Description
This section covers the installation process for cuSOLVERMP, detailing the necessary hardware and software prerequisites. It also provides a guide to the typical workflow for using the library, helping users to quickly begin with their linear algebra computations on CUDA-enabled devices.

### Method
N/A (Documentation Overview)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A
```

--------------------------------

### pyAerial Overview and Getting Started

Source: https://docs.nvidia.com/aerial/cuda-accelerated-ran/latest/pyaerial/index

Provides an overview of pyAerial's value proposition, release notes, and a step-by-step guide to getting started, including prerequisites, installation, and testing the installation.

```APIDOC
## pyAerial Overview and Getting Started

### Description
This section covers the core aspects of the pyAerial library, including its benefits, recent updates, and a detailed guide for new users.

### Topics Covered
*   **Value Proposition**: Understand the benefits and use cases of pyAerial.
*   **Release Notes**: Review the latest updates and changes in pyAerial.
*   **Getting Started**: A comprehensive guide for new users.
    *   **Pre-requisites**: Software and hardware requirements.
    *   **Installing pyAerial**: Step-by-step installation instructions.
    *   **Testing the installation**: Verifying a successful installation.
    *   **Running the example Jupyter notebooks**: Demonstrations of pyAerial's capabilities.
```

--------------------------------

### Install pyAerial Development Package

Source: https://docs.nvidia.com/aerial/cuda-accelerated-ran/25-1/pyaerial/getting_started

Installs the pyAerial development package after the build process is complete. This command should be executed within the pyAerial container.

```shell
./pyaerial/scripts/install_dev_pkg.sh
```

--------------------------------

### Building and Installing pyAerial within Container

Source: https://docs.nvidia.com/aerial/cuda-accelerated-ran/latest/pyaerial/getting_started

These commands are executed inside the pyAerial container to build and install the pyAerial library. It uses CMake and Ninja for the build process.

```bash
cd $cuBB_SDK
cmake -Bbuild -GNinja -DCMAKE_TOOLCHAIN_FILE=cuPHY/cmake/toolchains/devkit -DNVIPC_FMTLOG_ENABLE=OFF -DASIM_CUPHY_SRS_OUTPUT_FP32=ON
cmake --build build -t _pycuphy pycuphycpp
./pyaerial/scripts/install_dev_pkg.sh
```

--------------------------------

### Start JupyterLab Server in pyAerial Container

Source: https://docs.nvidia.com/aerial/archive/cuda-accelerated-ran/24-1/pyaerial/quick_setup

This command starts a JupyterLab server within the pyAerial container, making the example notebooks accessible via a web browser. Ensure you are in the correct directory before execution. No external dependencies are required beyond the pyAerial installation.

```shell
cd $cuBB_SDK/pyaerial/notebooks
jupyter lab --ip=0.0.0.0
```

--------------------------------

### Install AIQ Toolkit Examples with uv

Source: https://docs.nvidia.com/aiqtoolkit/latest/resources/contributing

Installs all AIQ toolkit examples by syncing the 'examples' extra. It also shows how to install a specific example, like the 'Simple Calculator', in editable mode.

```shell
uv sync --extra examples
uv pip install -e ./examples/simple_calculator
```

--------------------------------

### Install Docker using Convenience Script on Ubuntu

Source: https://docs.nvidia.com/ace/audio2face-3d-microservice/latest/text/getting-started/getting-started

This script downloads and executes the Docker installation convenience script from get.docker.com. It's a quick way to install Docker on Ubuntu systems. Ensure you have internet connectivity and necessary permissions.

```bash
$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh ./get-docker.sh
```

--------------------------------

### Setup Plugin Installation - Python (setup.py)

Source: https://docs.nvidia.com/deeplearning/digits/digits-container-user-guide/index

Configures the installation of a DIGITS plugin using setuptools. Specifies package metadata, entry points for DIGITS to discover the plugin, and external Python dependencies like 'pydicom'.

```python
setup(
    name="digits_sunnybrook_data_plugin",
    version="0.0.1",
    author="Greg Heinrich",
    description=("A data ingestion plugin for the Sunnybrook cardiac dataset"),
    long_description=read('README'),
    license="Apache",
    packages=find_packages(),
    entry_points={
        DIGITS_PLUGIN_GROUP: [
        'class=digitsDataPluginSunnybrook:DataIngestion',
        ]},
    include_package_data=True,
    install_requires=['pydicom'],
)
```

--------------------------------

### Install HPC Container Maker (HPCCM)

Source: https://docs.nvidia.com/aerial/archive/cuda-accelerated-ran/24-2.1/pyaerial/getting_started

Installs the HPC Container Maker (HPCCM) Python package using pip. This tool is a prerequisite for building the pyAerial container.

```bash
pip install hpccm
```

--------------------------------

### Install nv_peer_memory Modules (Bash)

Source: https://docs.nvidia.com/ai-enterprise/deployment/multi-node/latest/getting-started

Installs the nv_peer_memory modules on each node to enable peer-to-peer memory access between GPUs. This involves cloning the repository, building the module, and installing the resulting deb package.

```bash
git clone https://github.com/Mellanox/nv_peer_memory.git
cd nv_peer_memory
./build_module.sh
cd /tmp
tar xzf /tmp/nvidia-peer-memory_1.0.orig.tar.gz
cd nvidia-peer-memory-1.0
dpkg-buildpackage -us -uc
dpkg -i <path to generated deb files>

```

--------------------------------

### Install cuOpt Python Thin Client

Source: https://docs.nvidia.com/cuopt/service/latest/quickstart

Installs the cuOpt Python thin client package into the active Python virtual environment. This command makes the 'cuopt_cli' available and allows importing the 'cuopt_thin_client' package.

```bash
pip install .
```

--------------------------------

### Getting Started with TensorRT C++ Samples

Source: https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/sample-support-guide

This guide provides instructions and code examples for getting started with TensorRT samples written in C++. It covers the necessary setup, compilation, and execution of TensorRT applications using the C++ API. Requires a C++ compiler, CMake, and TensorRT installation.

```cpp
// Example main function structure for a TensorRT C++ application
#include "NvInfer.h"
#include "NvInferRuntime.h"
#include <iostream>
#include <vector>
#include <memory>

// Logger class implementation
class Logger : public nvinfer1::ILogger
{
    void log(Severity severity, const char* msg) noexcept override
    {
        // Print log messages to stdout or stderr
        if (severity <= Severity::kWARNING)
        {
            std::cout << "[ " << severity << " ] " << msg << std::endl;
        }
    }
} logger;

int main()
{
    // Create a TensorRT runtime
    nvinfer1::IRuntime* runtime = nvinfer1::createInferRuntime(logger);
    if (!runtime) { return 1; }

    // Deserialize engine from file
    // std::ifstream engineFile("engine.trt", std::ios::binary);
    // if (!engineFile) { std::cerr << "Error opening engine file" << std::endl; return 1; }
    // std::string engineStr((std::istreambuf_iterator<char>(engineFile)), std::istreambuf_iterator<char>());
    // nvinfer1::ICudaEngine* engine = runtime->deserializeCudaEngine(engineStr.data(), engineStr.size());
    // if (!engine) { std::cerr << "Error deserializing engine" << std::endl; return 1; }

    // Create execution context
    // nvinfer1::IExecutionContext* context = engine->createExecutionContext();
    // if (!context) { std::cerr << "Error creating execution context" << std::endl; return 1; }

    // ... Prepare input/output buffers and run inference ...

    // Clean up
    // context->destroy();
    // engine->destroy();
    runtime->destroy();

    return 0;
}
```

--------------------------------

### Download TensorBoard Tutorial Notebook

Source: https://docs.nvidia.com/base-command-platform/user-guide/index

This command downloads the official TensorBoard 'get started' tutorial notebook from Google Cloud Storage. It is used after launching a TensorFlow container with JupyterLab, allowing users to follow along with the TensorBoard documentation.

```bash
wget https://storage.googleapis.com/tensorflow_docs/tensorboard/docs/get_started.ipynb

```

--------------------------------

### View NGC Quick Start Project Command Help

Source: https://docs.nvidia.com/base-command-platform/user-guide/index

Command to display detailed help and available options for the NGC Quick Start project command. This is useful for understanding all configurable parameters.

```bash
$ ngc base-command quickstart project -h
```

--------------------------------

### Start SGLang Worker with Dynamo

Source: https://docs.nvidia.com/dynamo/latest/index

This command starts an SGLang worker using NVIDIA Dynamo. It requires Python and the dynamo package to be installed. The command specifies the model path to be used by the worker.

```python
python -m dynamo.sglang --model-path Qwen/Qwen3-0.6B
```

--------------------------------

### Start etcd and NATS with Docker Compose

Source: https://docs.nvidia.com/dynamo/latest/index

Fetches the Docker Compose configuration for etcd and NATS from a GitHub URL and starts these services in detached mode. Requires Docker and Docker Compose to be installed.

```bash
# Fetch and start etcd and NATS using Docker Compose
curl -fsSL -o docker-compose.yml https://raw.githubusercontent.com/ai-dynamo/dynamo/release/0.4.1/deploy/docker-compose.yml
docker compose -f docker-compose.yml up -d
```

--------------------------------

### cuOpt CLI Sample Run and Arguments

Source: https://docs.nvidia.com/cuopt/service/latest/quickstart

This snippet demonstrates a sample command to run the cuOpt CLI with specified input and credential files, and details the available command-line arguments. It highlights the purpose of each argument, such as specifying input data, credentials, cloud functions, and temporary directories.

```bash
cuopt_cli cuopt_problem_data.json -c credentials.json -f optimized_routes_sync_elite -t my_temp_dir

file: cuOpt problem data file, required if -g is not specified

-c: credentials file containing client_id and secret values in JSON. If
this file is not supplied,
the environment variables CUOPT_CLIENT_ID and CUOPT_CLIENT_SECRET will
be used

-f: cuOpt cloud function to call (defaults to
"optimized_routes_sync_elite")

-g: get available functions. Prints list of available cuOpt functions
and exits

-t: directory to write temporary files for handling large results
(defaults to "./")

-a: relevant only for internal NVIDIA developers to switch between
staging and production
```

--------------------------------

### Clone TensorRT Repository and Navigate to Quickstart Directory

Source: https://docs.nvidia.com/deeplearning/tensorrt/latest/getting-started/quick-start-guide

This command clones the TensorRT GitHub repository and then changes the current directory to the quickstart folder. This is the initial step to access the tutorial's source code and scripts.

```bash
git clone https://github.com/NVIDIA/TensorRT.git
cd TensorRT/quickstart
```

--------------------------------

### Example Error Message for Containerd Start Error

Source: https://docs.nvidia.com/aerial/cuda-accelerated-ran/25-1/aerial_cubb/cubb_install/cloud_native_stack

Illustrates a typical error message encountered when the containerd runtime fails to start a container, often due to issues with the NVIDIA driver or OCI runtime. This can occur if certain configurations are not met.

```text
State:      Terminated
      Reason:   StartError
      Message:  failed to create containerd task: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: error during container init: error running hook #0: error running hook: exit status 1, stdout: , stderr: Auto-detected mode as 'legacy'
nvidia-container-cli: initialization error: nvml error: driver not loaded: unknown
      Exit Code:    128
      Started:      Thu, 01 Jan 1970 00:00:00 +0000
      Finished:     Wed, 17 Jan 2024 05:25:27 +0000
```

--------------------------------

### Run NVIDIA Dynamo Frontend

Source: https://docs.nvidia.com/dynamo/latest/index

Starts the OpenAI compatible frontend for NVIDIA Dynamo using Python. The frontend typically runs on port 8000 by default. This assumes Dynamo is installed in the active environment.

```python
# Start the OpenAI compatible frontend (default port is 8000)
python -m dynamo.frontend
```

--------------------------------

### cuBLASMp Getting Started

Source: https://docs.nvidia.com/cuda/cublasmp/index

Information on hardware and software requirements, data layout, workflow, and code samples for getting started with cuBLASMp.

```APIDOC
## cuBLASMp Getting Started

This section covers the initial setup and basic usage of the cuBLASMp library.

### Topics

- **Hardware and Software Requirements**: Details the necessary system configurations.
- **Data Layout of Local Matrices**: Explains how matrices are stored in memory.
- **Workflow**: Outlines the typical steps for using cuBLASMp in an application.
- **Code Samples**: Provides example code to demonstrate cuBLASMp functionality.
```

--------------------------------

### Install Dynamo with uv

Source: https://docs.nvidia.com/dynamo/latest/index

Installs the uv package manager and then creates a virtual environment to install the NVIDIA Dynamo library with the 'sglang' extra. Ensure you have curl installed.

```bash
# Install uv (recommended Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create virtual environment and install Dynamo
uv venv venv
source venv/bin/activate
uv pip install "ai-dynamo[sglang]==0.4.1" # or [vllm], [trtllm]
```

--------------------------------

### Blackwell Block-Scaled GEMM Quickstart (C++)

Source: https://docs.nvidia.com/cutlass/CHANGELOG

This is a quickstart example for instantiating a Blackwell block-scaled GEMM kernel. It provides a basic setup for using this functionality.

```cpp
// Example code snippet from the quickstart documentation
// Instantiating a Blackwell SM100 GEMM kernel...
```

--------------------------------

### Example: Create PyTorch Jupyter Template with NGC CLI

Source: https://docs.nvidia.com/base-command-platform/user-guide/index

An example illustrating the creation of a PyTorch Jupyter Quick Start Template using the NGC CLI. This command shows the specific parameters required for setting up a PyTorch environment.

```bash
$ ngc base-command quickstart project create-template \
            --name "demo pytorch template" \
            --description "demo" \
            --display-image-url "https://demo/demo-image.png" \
            --ace ceph-sjc-4-ngc-wfs0 \
            --cluster-lifetime 3600s \
            --cluster-type jupyterlab \
            --container-image "nvidia/pytorch:23.08-py3" \
            --data-output-mount-point /results \
            --scheduler-instance-typedgx1v.32g.4.norm \
            --job-order 50 \
            --job-priority NORMAL \
            --min-time-slice 1s \
            --nworkers 2 \
            --org nvidia \
            --label "tf template" \
            --workspace-mount ZNqskFA0SC2uMGUa4q-5Vg:/bcp/workspaces/49529_quick-start-jupyterlab-workspace_ceph-sjc-4-ngc-wfs0:RW
```

--------------------------------

### Getting Started with TensorRT Python Samples

Source: https://docs.nvidia.com/deeplearning/tensorrt/latest/inference-library/sample-support-guide

This section provides an overview and links to TensorRT samples implemented in Python. It guides users on setting up their environment and running basic TensorRT applications using the Python API. Requires Python, pip, and TensorRT installation.

```python
# Example structure for a TensorRT Python script
import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

# Define logger
TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

# Load the TensorRT engine from file
engine_path = "your_engine.trt"
with open(engine_path, "rb") as f:
    serialized_engine = f.read()

runtime = trt.Runtime(TRT_LOGGER)
engine = runtime.deserialize_cuda_engine(serialized_engine)

# Create execution context
context = engine.create_execution_context()

# Allocate GPU buffers for input and output
input_shape = context.get_binding_shape(0) # Assuming first binding is input
output_shape = context.get_binding_shape(1) # Assuming second binding is output

dtype = trt.nptype(engine.get_binding_dtype(0))

input_size = trt.volume(input_shape) * input_shape.each()
data_type = trt.nptype(engine.get_binding_dtype(0))

# Allocate device memory
data_in = cuda.mem_alloc(input_size * data_type.itemsize)
data_out = cuda.mem_alloc(output_size * data_type.itemsize)

# Create a stream for asynchronous operations
stream = cuda.Stream()

# Prepare input data (numpy array)
# host_in = np.random.rand(*input_shape).astype(data_type)

# Transfer input data to the GPU
# cuda.memcpy_htod_async(data_in, host_in, stream)

# Run inference
# context.execute_async_v2(bindings=[int(data_in), int(data_out)], stream_handle=stream.handle)

# Transfer output data from the GPU
# host_out = np.empty(output_shape, dtype=data_type)
# cuda.memcpy_dtoh_async(host_out, data_out, stream)

# Synchronize the stream
# stream.synchronize()

# Process host_out...

print("TensorRT Python sample execution complete.")
```

--------------------------------

### Verify pyAerial Installation with Python

Source: https://docs.nvidia.com/aerial/archive/cuda-accelerated-ran/24-1/pyaerial/quick_setup

This command verifies the pyAerial installation by attempting to import the 'aerial' module in Python. A successful import without errors indicates the installation is working correctly.

```python
python3 -c "import aerial"
```

--------------------------------

### Start NVIDIA AIQ Toolkit Server

Source: https://docs.nvidia.com/aiqtoolkit/latest/quick-start/launching-ui

This command starts the NVIDIA Agent Intelligence (AIQ) toolkit server using a specified configuration file. Ensure the AIQ toolkit and its dependencies are installed. The command takes a path to a YAML configuration file as input and outputs server logs upon successful startup.

```shell
aiq serve --config_file=examples/simple_calculator/configs/config.yml
```

--------------------------------

### Setup Audio2Face-3D Python Interaction App on WSL2

Source: https://docs.nvidia.com/ace/audio2face-3d-microservice/latest/text/getting-started/getting-started

These commands set up the Audio2Face-3D Python interaction application within a WSL2 environment. It involves cloning the sample repository, checking out a specific tag, navigating to the application directory, creating a virtual environment, activating it, and installing dependencies.

```bash
$ wsl -d Ubuntu-22.04
$ git clone https://github.com/NVIDIA/Audio2Face-3D-Samples.git
$ git checkout tags/v1.3
$ cd Audio2Face-3D-Samples/scripts/audio2face_3d_microservices_interaction_app
$ python3 -m venv .venv
$ source .venv/bin/activate
$ pip3 install ../../proto/sample_wheel/nvidia_ace-1.2.0-py3-none-any.whl
$ pip3 install -r requirements.txt
```

--------------------------------

### Check CMake Version

Source: https://docs.nvidia.com/aerial/archive/cuda-accelerated-ran/24-1/aerial_cubb/aerial_cumac/getting_started

Command to check the installed version of CMake. Requires CMake to be installed and accessible in the system's PATH.

```bash
cmake --version
```

--------------------------------

### Install NVIDIA Driver with Verbose Versions using APT

Source: https://docs.nvidia.com/datacenter/tesla/driver-installation-guide/index

Installs the NVIDIA driver with the `--verbose-versions` flag enabled, which provides more detailed information during the installation process. This is useful for troubleshooting or understanding driver installation steps. It requires APT and an internet connection.

```bash
apt install --verbose-versions nvidia-open
```

--------------------------------

### Set CUDA Installation Path

Source: https://docs.nvidia.com/aerial/cuda-accelerated-ran/24-3/aerial_cumac/getting_started

This command sets the PATH environment variable to include a specific CUDA installation directory. This is useful when CUDA is installed in a non-standard location or when needing to use a particular version.

```bash
export PATH=/usr/local/cuda-12.0/bin:$PATH

```

--------------------------------

### Launch pyAerial Container Script

Source: https://docs.nvidia.com/aerial/archive/cuda-accelerated-ran/24-1/pyaerial/quick_setup

This script launches the pre-built pyAerial container. It assumes the container has been successfully built and is accessible via the run.sh script in the cuBB_SDK directory.

```shell
$cuBB_SDK/pyaerial/container/run.sh
```

--------------------------------

### Download cuMAC using Git

Source: https://docs.nvidia.com/aerial/cuda-accelerated-ran/24-3/aerial_cumac/getting_started

Clones the cuMAC repository and its submodules. This is the initial step to obtain the source code.

```bash
git clone --recurse-submodules https://gitlab-master.nvidia.com/gputelecom/cumac
```

--------------------------------

### Setup Python Script for DIGITS Data Plugin

Source: https://docs.nvidia.com/deeplearning/digits/digits-tutorial/index

Python script using setuptools to define and install a DIGITS data plugin. It specifies package metadata, entry points for DIGITS discovery, and Python dependencies like 'pydicom'.

```python
from setuptools import setup, find_packages

def read(fname):
    return open(os.path.join(os.path.dirname(__file__), fname)).read()

setup(
    name="digits_sunnybrook_data_plugin",
    version="0.0.1",
    author="Greg Heinrich",
    description=("A data ingestion plugin for the Sunnybrook cardiac dataset"),
    long_description=read('README'),
    license="Apache",
    packages=find_packages(),
    entry_points={
        DIGITS_PLUGIN_GROUP: [
        'class=digitsDataPluginSunnybrook:DataIngestion',
        ]},
    include_package_data=True,
    install_requires=['pydicom'],
)
```

--------------------------------

### GStreamer Audio Encode Examples with gst-launch-1.0

Source: https://docs.nvidia.com/jetson/archives/l4t-archived/l4t-3276/index

Shows examples of audio encoding using GStreamer's gst-launch-1.0 command. Requires GStreamer installation.

```bash
# Example for MP3 encoding
gst-launch-1.0 audiotestsrc ! audioconvert ! lamemp3enc ! filesink location=output.mp3

# Example for AAC encoding
gst-launch-1.0 audiotestsrc ! audioconvert ! faac ! filesink location=output.aac
```

--------------------------------

### Setup Audio2Face-3D Interaction App and Run Inference (Python)

Source: https://docs.nvidia.com/ace/audio2face-3d-microservice/latest/text/getting-started/getting-started

Clones the Audio2Face-3D-Samples repository, checks out a specific version, sets up a Python virtual environment, installs dependencies including the nvidia_ace gRPC module, and performs health checks and inference using the provided scripts. Requires Python 3 and pip.

```bash
git clone https://github.com/NVIDIA/Audio2Face-3D-Samples.git
git checkout tags/v1.3
cd Audio2Face-3D-Samples/scripts/audio2face_3d_microservices_interaction_app
python3 -m venv .venv
source .venv/bin/activate
pip3 install ../../proto/sample_wheel/nvidia_ace-1.2.0-py3-none-any.whl
pip3 install -r requirements.txt

python3 a2f_3d.py health_check --url 0.0.0.0:52000

python3 a2f_3d.py run_inference ../../example_audio/Mark_neutral.wav config/config_james.yml -u 0.0.0.0:52000
```

--------------------------------

### Install nvidia-docker2 on DGX Systems

Source: https://docs.nvidia.com/datacenter/cloud-native/edge/latest/anthos-guide

This snippet shows how to install the nvidia-docker2 package on DGX systems using apt-get. This is a prerequisite for GPU node setup in Anthos.

```bash
apt-get install -y nvidia-docker2
```

--------------------------------

### Build and Push Docker Image

Source: https://docs.nvidia.com/ai-enterprise/deployment/multi-node/latest/getting-started

Commands to build the Docker image from the Dockerfile and then tag and push it to a private registry. This process creates a container suitable for multi-node training.

```bash
sudo docker build -t multinode:latest .

```

```bash
sudo docker tag multinode <NVIDIA_AI_Enterprise_private_registry_username>/multinode

```

```bash
sudo docker push

```

--------------------------------

### Install Python Virtual Environment Package

Source: https://docs.nvidia.com/cuopt/service/latest/quickstart

Installs the 'virtualenv' package for creating isolated Python environments. This is necessary for managing project-specific dependencies.

```bash
pip3 install virtualenv
```

--------------------------------

### GStreamer Video Decode Examples with gst-launch-1.0

Source: https://docs.nvidia.com/jetson/archives/l4t-archived/l4t-3276/index

Provides examples for decoding various video formats using GStreamer and the gst-launch-1.0 utility. Ensure GStreamer is properly installed.

```bash
# Example for H.264 decoding
gst-launch-1.0 filesrc location=video.h264 ! h264parse ! nvv4l2decoder ! nvoverlaysink

# Example for VP9 decoding
gst-launch-1.0 filesrc location=video.vp9 ! vp9parse ! nvv4l2decoder ! nvoverlaysink
```

--------------------------------

### Install NVIDIA Driver using Local Repository

Source: https://docs.nvidia.com/datacenter/tesla/driver-installation-guide/index

Instructions for setting up and installing NVIDIA drivers from a local repository, often used in cloud environments like Azure. This involves downloading the driver package and configuring the local repository for the package manager.

```bash
# Example commands for local repository installation (actual commands may vary)
sudo rpm -ivh NVIDIA-Linux-x86_64-*.run
sudo yum localinstall <path_to_local_repo_package>
```

--------------------------------

### Install MLNX OFED for Ubuntu

Source: https://docs.nvidia.com/ai-enterprise/deployment/multi-node/latest/getting-started

Installs the Mellanox OFED driver for Ubuntu 20.04. This process includes extracting the tarball, running the installation script, and restarting the OpenIB daemon.

```bash
tar xvf MLNX_OFED_LINUX-5.2-2.2.4.0-ubuntu20.04-x86_64.tgz
cd MLNX_OFED_LINUX-5.2-2.2.4.0-ubuntu20.04-x86_64
sudo ./mlnxofedinstall
sudo /etc/init.d/openibd restart
```

--------------------------------

### Install Docker Compose Plugin on Ubuntu

Source: https://docs.nvidia.com/ace/audio2face-3d-microservice/latest/text/getting-started/getting-started

This command installs the Docker Compose plugin on Ubuntu systems using apt-get. It is required for managing multi-container Docker applications. Ensure your package list is updated before installation.

```bash
$ sudo apt-get update
$ sudo apt-get install docker-compose-plugin
```

--------------------------------

### Get Started with TensorBoard using NGC CLI and JupyterLab

Source: https://docs.nvidia.com/base-command-platform/user-guide/index

This example demonstrates how to start a TensorFlow job for TensorBoard visualization using the NGC CLI. It launches a JupyterLab instance with TensorBoard pre-installed. The command specifies the instance type, a TensorFlow container image, and maps ports for accessing JupyterLab and TensorBoard.

```bash
$ ngc base-command run \
--name "NVbc-tensorboard" \
--preempt RUNONCE \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.1.norm \
--commandline "set -x; jupyter lab --allow-root --NotebookApp.token='' --NotebookApp.allow_origin=* --notebook-dir=/ & date; tensorboard --logdir /workspace/logs/fit ; sleep 1d" \
--result /result \
--image "nvidia/tensorflow:21.08-tf1-py3" \
--org nv-eagledemo \
--team nvbc-tutorials \
--port 8888 \
--port 6006

```

--------------------------------

### cuSPARSELt Installation and Compilation Guide

Source: https://docs.nvidia.com/cuda/cusparselt/index

This section details the prerequisites and steps required to install and compile the cuSPARSELt library. It covers system requirements and build instructions.

```text
Prerequisites:
- CUDA Toolkit (version specified in release notes)
- C++ compiler supporting C++11 or later
- CMake (version specified in release notes)

Installation and Compilation:
1. Download the cuSPARSELt library source code.
2. Create a build directory: `mkdir build && cd build`
3. Configure the build using CMake: `cmake .. -DCUDA_TOOLKIT_ROOT_DIR=/path/to/cuda -DCMAKE_INSTALL_PREFIX=/path/to/install`
4. Build the library: `make`
5. Install the library: `make install`
```

--------------------------------

### Build and Install pyAerial Inside Container

Source: https://docs.nvidia.com/aerial/archive/cuda-accelerated-ran/24-2.1/pyaerial/getting_started

Builds and installs pyAerial within the pyAerial container. This involves configuring the build with CMake, specifying toolchains and disabling NVIDIA IPC fmtlog, then building the pycuphy and pycuphycpp targets, and finally installing the development package.

```bash
cd $cuBB_SDK
cmake -Bbuild -GNinja -DCMAKE_TOOLCHAIN_FILE=cuPHY/cmake/toolchains/native -DNVIPC_FMTLOG_ENABLE=OFF
cmake --build build -t _pycuphy pycuphycpp
./pyaerial/scripts/install_dev_pkg.sh
```

--------------------------------

### Run ResNet-50 with TensorFlow Container

Source: https://docs.nvidia.com/ai-enterprise/release-7/7.0/getting-started/quick-start-guide

Launches a TensorFlow 1 Docker container, navigates to the example directory, and runs the ResNet-50 training test with FP16 precision.

```bash
sudo docker run --gpus all -it --rm \
nvcr.io/nvidia/tensorflow-pb24h1:24.03.06-tf2-py3nvcr.io/nvidia/tensorflow:21.07-tf1-py3

```

```bash
# cd /workspace/nvidia-examples/cnn

```

```bash
# python resnet.py --layers 50 -b 64 -i 200 -u batch --precision fp16

```