# MemryX Support ## Summary | AI Accelerator | Support Level | CPU Architecture | Operating System | API/driver version | | -------------- | ------------- | ---------------- | -------------------------- | ------------------ | | MX3 | Experimental | x86\_64 | Ubuntu 22.04, Ubuntu 24.04 | 2.2.0 | ## Introduction ### About MemryX MemryX, Inc. was established with the mission of accelerating Edge AI workloads by providing a highly efficient and scalable solution that is simple to deploy and support. MemryX’s AI accelerator chips, known as MXAs, offer server-like performance and accuracy at low power and low cost and are well-positioned for Edge AI applications, including autonomous driving, robotics, machine vision, and more. The MemryX MX3 M.2 AI Accelerator module has an M-key 2280 form factor and includes 4 MXA chips. This production module is now supported by the Nx AI Manager. ## ![](/files/7bc0eaaac043d2b6f08b08a8f384db25e1aff19b) ## Workflow The Nx AI Manager simplifies the process of securely deploying your AI models on MemryX MX3 devices with the following steps: 1. Install all necessary software dependencies. 2. Install the Nx Meta Server on your machine and choose the MemryX runtime option. 3. Upload your model to the Nx AI Cloud for compilation. 4. Compile and install the required post-processor. 5. Set up your inference pipeline. ## Hardware and Software Requirements **Hardware Requirements:** * Hardware requirements can be accessed in detail on the MemryX Developer Hub. Please see the following [resource](https://developer.memryx.com/get_started/install_hardware.html) for hardware installation, requirements and recommendations. * In general, any modern x86\_64 system with AVX2 and a suitable M.2 slot should work well with the MX3. The MemryX driver and runtime libraries support multiple CPU and distribution combinations, provided via: apt package repository **Software Requirements:** * Ubuntu 22.04 LTS * Ubuntu 24.04 LTS ## Installation steps Follow the runtime installation steps from the MemryX Developer Hub: [Installation Instructions](https://developer.memryx.com/get_started/install_runtime.html) The instructions will guide you through the installation of both the MemryX runtime and drivers, which are required to use the device with the Nx AI Manager. After installing the drivers and runtime, you will be prompted to reboot your system. After rebooting, please return to the installation steps on the Developer Hub and complete Step 7, which instructs you to install the MemryX utilities and plugins. These are strictly required for compatible use with Nx AI. ### Verify installation To verify your MemryX installation, power on your system and run the following command: ``` ls /dev/memx* ``` The command should return the following to indicate that a single MemryX module is properly installed and ready to use: ``` /dev/memx0 ``` If you wish to further verify the installation by running a simple workload on the accelerator module, please refer to the [Hello, MXA!](https://developer.memryx.com/get_started/hello_mxa.html) tutorial on the MemryX Developer Hub. ## Getting Started This guide walks you through deploying the **Yolov8n** model on an MemryX MX3 M.2 module using the Nx AI Manager. Before you begin, ensure you are familiar with the Nx AI Manager and the process of running models on a CPU. If you need a refresher, please see the [configuration section](https://nx.docs.scailable.net/nx-ai-manager/configure-the-plugin). For this guide, we will use the following resources: * **Nx Meta:** Use the Nx Meta 6.1.2 version or later, which you can download from [here](https://beta.networkoptix.com/beta-builds/metavms/6.1.2.42601/index.html), and install and configure as outlined [here](https://nx.docs.scailable.net/nx-ai-manager/install-network-optix). * **ONNX Model:** The model is available at [model.zip](https://drive.google.com/file/d/1Fc-AvmEpvBxmj7Vz1BHJHcC5tKkyfZWk/view?usp=sharing) * **Post-processor**: The post-processor source is available at [post\_processor.zip](https://drive.google.com/file/d/1J3Iyt3x8usG5oN6P_W7OHbFfLiLsUhoR/view?usp=drive_link) ### Upload model to Nx AI Cloud Upload your ONNX model to the [Nx AI Cloud](https://admin.sclbl.nxvms.com/) following the steps outlined in [the upload section](https://nx.docs.scailable.net/nx-ai-cloud/upload-your-model). **Crucially,** enable the **MemryX** conversion option within the model upload form and set the correct normalization values (as demonstrated in the image below). ![](/files/a1a95eec8cf2dd6344359614cbb5c38ab1be2b43) The cloud platform will automatically convert the standard ONNX model into an MX3-compatible binary in the background. The model is ready for deployment once its status updates to **ok**, as shown below: ![](/files/92c0e4d3bc2325e3f137059ffbcbe2d24780fc31) ### Select the MemryX runtime The Nx AI Manager provides native support for multiple AI accelerators. To route inference to the chip, select the **MemryX** runtime in the Nx AI Manager settings page: ![](/files/8bc3c64bbeeab44a9197ad466323e7e53b220b5a) ### Install post-processor Models running on the MX3 require an **external post-processor** to translate raw network output tensors (e.g., probability matrices) back into meaningful Nx metadata, such as object bounding boxes and classifications. To deploy the provided YOLOv8m example, complete the following steps to compile and install the external C/C++ post-processor directly on the Nx Meta Server machine: 1. Extract the post-processor source code archive. 2. Execute the provided compilation script compile\_install.sh. This builds the post-processor and automatically copies its config.json definition into the Nx AI Manager's post-processors directory: ``` bash ./compile_install.sh ``` To apply the change, restart the Nx VMS server. Instructions are available in [this section](https://www.google.com/search?q=https://nx.docs.scailable.net/support-and-troubleshooting/troubleshooting/controlling-the-server-and-the-plugin%23restarting-the-server). ### Configure pipeline Within the Nx Meta Client, [configure the pipeline](https://nx.docs.scailable.net/nx-ai-cloud/use-your-model) as shown in the image below: ### ![](/files/c073be9f19089f04d40b7e845d61b0c7c337fa20) ### Enable inference on camera The final step is to activate inference for your camera by toggling the **Device Active** switch on the Nx AI Manager settings page (as shown below). ![](/files/3a36743bd6926d4986e3d8b230cccf7b9d9b1364) You should immediately begin seeing inference results in the Nx Meta Client after enabling the "Objects" tab. ![](/files/63eec9197385999850b227aef792c03d0384bb6f) To enable model inference on multiple cameras, simply repeat steps 4 and 5 for each camera. ## Supported Models An extensive list of supported models can be found in the [MemryX Model Explorer](https://developer.memryx.com/model_explorer/models.html). Rather than providing a curated ‘model zoo’, the MemryX team emphasizes their solution’s ability to support a wide variety of models out-of-the-box by using BF16 activations, enabling users to run their own models without manual quantization or modifications. The MemryX Model Explorer is a great resource to characterize the types of supported model architectures, but users are certainly not limited to this selection of models. ## Monitoring ### Monitor pipeline throughput To see the number of frames the Nx AI Manager is processing for a camera, enable the model FPS event. You can find detailed instructions on this page: [Show AI inference framerate on video](https://nx.docs.scailable.net/nx-ai-manager/howtos/show-ai-inference-framerate-on-video). ### Monitor chip metrics **Chip Temperatures** There are two methods to view the chip temperatures. The first method is to use the C++ MxAccl API, which has two functions for temperature monitoring. Use the following function to monitor the temperature of each chip on the specified device ([docs](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase21get_chip_temperaturesEi)): ``` std::vector get_chip_temperatures(int device_id = 0) ``` To see the maximum chip temperature across all chips on the device, use ([docs](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase19get_max_temperatureEi)): ``` float get_max_temperature(int device_id = 0) ``` If you prefer to use the terminal for monitoring, you can run the following command to check the temperatures of all chips on your device: ``` cat /sys/memx0/temperature ``` For continuous monitoring from the terminal, try the following command to view updated temperatures in 1-second intervals: ``` watch -n 1 cat /sys/memx0/temperature ``` Note that all temperature measurements are provided in degrees Celsius. **Chip Utilization** The C++ MxAccl API uses a metric referred to as ‘pressure’, which serves to approximate the throughput utilization of a given model on the device. You can read more about the pressure metric [here](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase19get_max_temperatureEi). You can use the following C++ function to retrieve the MXA’s current pressure status ([docs](https://developer.memryx.com/api/accelerator/cpp.html#_CPPv4N2MX7Runtime10MxAcclBase12get_pressureEi)): ``` MX::Types::Pressure get_pressure(int device_id = 0) ``` Again, if you prefer to monitor utilization from the terminal, you can do so continuously in 1-second intervals using the following command: ``` watch -n 1 cat /sys/memx0/utilization ``` Note that the percentage provided in this file is not measured in the same way as the pressure metric described above. It is more so an approximation of the current core utilization. ## Troubleshooting ### Missing bounding-boxes If you are not seeing bounding boxes visualized in the Nx Client, check the following potential factors: * **Model Accuracy:** The model might not be accurate enough for the specific environment where it is deployed. * **Corrupted Configuration:** If the pipeline configuration has become corrupted, try re-installing the post-processor and reconfiguring the pipeline. * **Throughput Saturation:** If you assign the pipeline to too many high-framerate streams, the pipeline throughput may become significantly lower than the stream framerate, causing the Nx AI Manager to drop most frames. To troubleshoot this, disable the AI Manager integration on all but one camera and gradually increase the number of cameras until you identify the machine's saturation limit. * **Pipeline Incompatibility:** If a camera on the server is assigned a model that is not compatible with the MemryX chip, the AI Manager integration will stop working for *all* cameras across the server. Verify that all cameras have the correct pipeline assigned. If any camera has an incompatible model, disable the AI Manager integration for that camera. ## Technical Support For technical questions or assistance, please reach out to us through the following channels: * MemryX Developer Support: [MemryX Developer Community Forum](https://community.memryx.com/t/welcome-to-memryx-developer-community/5) * Nx Customer Support Portal: [Network Optix](https://support.networkoptix.com/) --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://nx.docs.scailable.net/nx-ai-manager-v6.1.2/ai-accelerators-support/advanced/memryx-support.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.