Graiphic has developed and trained a complete Mixture-of-Experts reinforcement learning architecture, then executed it in SOTA and LabVIEW through DeepMX.
Advanced deep learning creates industrial value only when it can leave research notebooks and become a practical engineering component. That is the purpose of DeepMX.
DeepMX is designed as the reference model driver for deep learning in LabVIEW. It provides the integration layer required to configure, execute, accelerate, and connect supported models to a complete LabVIEW application without rebuilding the runtime interface for every project.
To demonstrate this capability, Graiphic trained a Mixture-of-Experts reinforcement learning system for Street Fighter II. Ryu is controlled in real time by a composite AI model made of several specialist policies. Each expert learned a different matchup, while a trainable dense routing network learned which specialist should drive the next action according to the current opponent.
The game is the visible demonstration. The engineering subject is much larger: complex deep learning architectures can now become executable and reusable components inside a graphical LabVIEW workflow.
Watch the DeepMX Mixture-of-Experts demonstration on YouTube.
DeepMX, the Deep Learning Driver for LabVIEW
DeepMX is designed to become the model driver par excellence for deep learning in LabVIEW.
A capable driver does more than launch a runtime call. It creates a stable boundary between complex technology and the application that must use it. It reads the model interface, exposes the correct inputs and outputs, configures the execution target, manages the runtime session, and presents the result as a clean engineering component.
DeepMX applies this principle to neural networks. Through a guided Express VI, engineers can select a model, inspect its interface, map its tensors, choose an execution provider, expose the required runtime parameters, and generate a ready-to-wire VI for the LabVIEW block diagram.
This reduces repetitive integration work around model loading, tensor mapping, session management, execution-provider selection, provider-specific configuration, and clean session shutdown.
DeepMX currently builds on ONNX and ONNX Runtime. Depending on the model and deployment target, execution can use CPU or supported optimized providers such as CUDA, TensorRT, DirectML, and OpenVINO.
If DAQmx made acquisition a first-class LabVIEW workflow, DeepMX aims to make deep learning a first-class LabVIEW workflow.
The analogy is about workflow philosophy, not identical scope. DAQmx gave LabVIEW engineers a coherent layer for acquisition. DeepMX brings the same type of clarity to model execution.
A trained neural network should not remain an isolated Python artifact that is difficult to deploy and maintain. Through DeepMX, it can become a versioned, testable, accelerated, and reusable LabVIEW component.
Why a Mixture of Experts?
A single general model can learn many behaviors, but generalization can introduce compromises.
In a fighting environment, each opponent creates a different decision problem. Timing, distance, attack patterns, defensive behavior, and effective actions change from one matchup to another.
A Mixture-of-Experts architecture divides the problem between several specialist models. Each expert becomes highly competent in a narrower context, while a routing mechanism determines which specialist should be activated for the current situation.
For this Graiphic demonstration, dedicated reinforcement learning experts were trained for Ryu against Guile, Ken, Chun-Li, and Ryu. Each policy learned its own matchup independently before the complete architecture was assembled.
How Graiphic Trained the Architecture
The architecture was developed in several stages.
First, each reinforcement learning policy was trained against one opponent. This gave every expert a focused objective and allowed it to specialize in the observations, distances, timings, and action patterns associated with that matchup.
Once the expert policies had completed training, their weights were frozen. This preserved the knowledge acquired by each specialist and prevented the final routing phase from damaging the behaviors they had learned.
The frozen expert branches were then assembled in parallel and connected to a trainable dense routing network.
The router was trained to interpret the current observation and opponent context, then select the expert whose behavior was most appropriate for the matchup.
The experts contain specialized skills. The router contains the contextual decision about which skill should be activated.
The final result is one composite model that preserves specialized behaviors while exposing a unified execution interface.
Deterministic and Stochastic Execution Modes
Graiphic added two execution modes for running the reinforcement learning policies: deterministic mode and stochastic mode.
In deterministic mode, the action with the highest model score is selected at each inference step.
This produces more repeatable behavior and makes it easier to compare model versions, reproduce a sequence, inspect decisions, validate integration, and debug the complete application.
For industrial workflows, deterministic execution is particularly useful when engineers need controlled tests, repeatable acceptance criteria, or consistent behavior under the same input conditions.
In stochastic mode, the action is sampled from the probability distribution produced by the policy.
This introduces controlled variability into the behavior. The agent can explore alternative actions instead of always selecting the highest-scoring one, which makes the resulting matches less rigid and helps reveal how robust the policy is across different trajectories.
The stochastic mode is useful for exploration, behavioral diversity, robustness evaluation, and scenarios where the policy must preserve a degree of adaptability.
LabVIEW as the Orchestrator
LabVIEW fulfills its role as the system orchestrator throughout the demonstration.
At every step, LabVIEW collects the current environment observation, provides the model inputs to DeepMX, triggers inference, applies deterministic selection or stochastic sampling, sends the selected controller action to the environment, controls execution timing, updates the visual indicators, and manages episode, stop, and restart logic.
This creates a clear division of responsibilities. DeepMX acts as the optimized model driver. LabVIEW orchestrates the complete application around the model.
The model is therefore not isolated from the rest of the system. It becomes one component inside a visible dataflow that also includes environment state, action selection, timing, monitoring, and control.
This orchestration capability is one of the strongest reasons to bring advanced deep learning into LabVIEW. The model can be integrated directly into a larger system instead of remaining separated behind a script or external application.
What the Demonstration Shows
The video exposes the complete inference loop through a visual interface.
The environment produces the current game observation. The composite model evaluates the situation. The routing layer identifies the opponent context and selects the relevant expert. The selected policy generates the next controller action, and the environment advances.
The interface displays the generated action and the selected opponent context while the match runs in real time.
Reinforcement learning is particularly effective for this demonstration because the behavior of the model is visible continuously. The result is not a static label. It is a sequence of decisions inside a dynamic system.
One Complex Model, One Clean LabVIEW Component
Internally, a Mixture-of-Experts model may contain multiple branches, routing logic, expert outputs, contextual inputs, and decision layers.
The application should not need to rebuild that internal complexity.
DeepMX presents the complete architecture as a clear LabVIEW model component with defined inputs, outputs, runtime parameters, and session behavior.
This allows the model architecture, the experts, the routing strategy, and the execution provider to evolve while the surrounding LabVIEW application keeps a stable integration boundary.
For industrial development, that separation supports testing, versioning, deployment, maintenance, and long-term evolution.
Why This Matters Beyond the Game
Street Fighter II provides an engaging visual environment, but the architecture demonstrated here is directly relevant to industrial AI.
In product-specific inspection, different experts can specialize in product families, materials, camera conditions, or defect classes, while a router selects the relevant inspection model.
For machine operating regimes, separate models can specialize in startup, nominal production, cleaning, maintenance, or degraded operation.
In robotics, different policies can specialize in grasping, positioning, navigation, recovery, or tool-specific actions.
For predictive maintenance, dedicated experts can model different machines or failure mechanisms, while a router interprets the current operating context.
In multimodal systems, specialists can focus on images, signals, text, or process data before a routing layer selects or combines their contributions.
The essential industrial concept is specialization without losing system-level integration.
A Mixture-of-Experts architecture allows teams to preserve focused models while exposing one unified model interface to the application.
Giving Industry Access to Modern Deep Learning
The latest AI techniques often remain difficult to adopt outside research environments.
Training a model is only one stage. Industrial teams also need runtime configuration, acceleration, application integration, monitoring, deployment, testability, and maintenance.
Graiphic is developing SOTA to close that gap.
DeepMX provides the model execution layer. GraphMX extends graph-based computation. VisionMX simplifies practical vision workflows. Together, these components connect modern AI architectures to LabVIEW, ONNX Runtime, execution providers, deployment tools, and reproducible examples.
Graiphic develops the toolkits, the models, the training workflows, the demonstrations, and the integration layers required to validate the complete system.
The objective is not simply to reproduce AI terminology inside LabVIEW. The objective is to make advanced methods usable by engineers who build machines, test benches, inspection systems, robots, scientific instruments, and industrial applications.
A Graiphic Technology Demonstration
This Mixture-of-Experts demonstration combines reinforcement learning model development, specialist policy training, expert-weight freezing, contextual routing, composite model construction, DeepMX execution, SOTA and LabVIEW integration, deterministic and stochastic policy execution, real-time environment control, and visual monitoring of actions and context.
One Ryu is controlled by four specialists and one learned router.
The video makes the concept visible. The strategic message is industrial: modern neural architectures can be specialized, assembled, routed, accelerated, and executed inside the same graphical engineering environment.
DeepMX is the driver that makes this transition practical.
Conclusion
The latest DeepMX integration demonstrates more than a model running in LabVIEW. It demonstrates a complete architecture.
Graiphic trained several reinforcement learning experts, preserved their specialized knowledge, and added a learned routing layer that selects the appropriate policy for the current opponent.
DeepMX then turns the complete Mixture-of-Experts model into an executable component inside SOTA and LabVIEW.
The deterministic and stochastic modes show that model execution is not limited to a single rigid inference path. Engineers can choose repeatability or controlled variability according to the objective of the test or application.
LabVIEW completes the architecture by orchestrating the environment, the DeepMX inference call, the action-selection mode, timing, monitoring, and the application lifecycle.
This is how advanced deep learning becomes useful to industry: not as an isolated experiment, but as a visible, optimized, maintainable, and integrated engineering workflow.
Explore SOTA, discover DeepMX, and follow Graiphic as we bring modern AI architectures into LabVIEW.
