AMD Schola v2 Tutorial: Training AI Agents in UE5 (AMD & Nvidia Compatible)

AMD Schola v2 represents a massive leap forward for AI development in Unreal Engine. This update focuses heavily on giving developers unprecedented control, flexibility, and realism when training machine learning models. Here is a deep dive into the standout features of this release:

Older machine learning setups often force you to hardcode your AI's decision-making directly into the character's behavior. AMD Schola v2 introduces a highly flexible architecture that completely decouples the "brain" of your AI from its "body." This modular design allows you to mix and match different components without ever having to rewrite your core agent logic.

The system is broken down into three key pillars:

• The Agent Interface (The Body): This defines how your AI interacts with the Unreal Engine world specifically, how it takes actions and gathers observations.
• UInferenceComponent: A flexible component you can drop onto any existing Unreal Actor to instantly give it AI capabilities.
• AInferencePawn: A ready-to-use, standalone pawn tailored specifically for AI agents.
• AInferenceController: Implements the classic AI controller pattern for managing complex, multi-layered behaviors.
• The Policy Interface (The Brain): This acts as the decision-making backend, turning the agent's observations into actionable commands. You can easily swap these out depending on your workflow:
• UNNEPolicy: Leverages Unreal Engine’s Native Neural Network Engine for high-performance ONNX model inference.
• UBlueprintPolicy: Perfect for prototyping, allowing you to build custom decision-making logic entirely using Unreal's visual Blueprints.
• Extensible Design: You can also easily plug in custom policy implementations or entirely new inference providers as needed.
• Stepper Objects (The Heartbeat): These control the timing and execution of your AI, coordinating how often agents "think" compared to the game's frame rate.
• SimpleStepper: A straightforward, synchronous approach where the game waits for the AI to make a decision.
• PipelinedStepper: A high-performance option that overlaps the AI's inference calculations with the game's physics simulation, resulting in massively improved throughput.
• Custom Steppers: You have the freedom to build bespoke execution patterns for highly specialized performance needs.

Sometimes the best way to train an AI isn't through random trial and error, but by showing it how a human does it. AMD Schola v2 introduces out-of-the-box support for the Minari dataset format, which has become the industry standard for offline reinforcement learning and imitation learning. Minari acts as a unified library for storing and loading trajectory data (like recorded human gameplay). This makes it incredibly easy to record human demonstrations in Unreal Engine, package them neatly, and share those datasets across different research communities or development teams to give your AI a massive head start.

One of the most requested and powerful improvements in v2 is the ability to handle dynamic populations of agents. In previous versions of Schola (and many other RL frameworks), you were locked into a static number of agents per training episode. If an agent was destroyed, the simulation would break. Now, Schola v2 seamlessly handles agents spawning and despawning on the fly.

This unlocks the ability to train AI in highly realistic, complex game scenarios:

• Battle Royale & Survival Games: Agents can be eliminated, destroyed, and removed from the active training pool without interrupting the rest of the episode.
• Population Simulations: You can naturally spawn new agents based on specific environmental triggers, economy systems, or game events (like an RTS unit producing a new squad).
• Dynamic Team Composition: Add or remove AI teammates on the fly based on the player's choices.
• Procedural Generation: As a player moves through a procedurally generated world, you can dynamically create and activate new AI agents just-in-time.

Managing this is incredibly simple: just mark an agent as "terminated" when its health reaches zero, or tell it to start reporting observations the moment it spawns into the world. It bridges the gap between rigid lab environments and actual, dynamic gameplay.

Command line training: now redesigned for effortless flow.

# Stable Baselines 3
schola sb3 train ppo ...

# Ray RLlib
schola rllib train ppo ...

# Utilities
schola compile-proto
schola build-docs

The new CLI, built with "cyclopts," delivers a significantly enhanced developer experience with clearer, more informative error messages, seamless auto-completion support, and a clean, consistent interface across multiple "RL" frameworks making workflows faster, smoother, and more intuitive.

If you prefer visual scripting over writing C++, AMD Schola v2 has made the Blueprint workflow significantly more powerful and user-friendly. In previous versions, defining complex AI parameters often required diving into code, but v2 brings the full power of reinforcement learning directly into the Blueprint editor.

Instanced Struct-Based Objects: This is a major under-the-hood optimization. Schola v2 now fully supports Instanced Structs for defining all "points" and "spaces" (which are how you define what your AI can see and do). This means you get much better performance and memory management without sacrificing the ease of visual scripting.

Full Blueprint Support for Spaces and Points: You no longer need to rely on C++ to define the boundaries of your AI's world. Whether you are setting up continuous observation spaces (like the exact distance to an enemy) or discrete action spaces (like pressing jump or crouch), you can handle it all purely within Blueprints.

Enhanced Blueprint Utilities: The toolkit now includes a broader suite of utility nodes designed specifically to help you manipulate, read, and write to these spaces seamlessly within your event graphs.

The world of machine learning moves incredibly fast, and older plugins often force you to use outdated, deprecated Python libraries. AMD Schola v2 has been completely updated to integrate seamlessly with the modern reinforcement learning ecosystem, ensuring your Unreal Engine project can talk to the absolute latest AI tools.

This update includes out-of-the-box compatibility with the heavy hitters of the RL world:

Gymnasium (1.1+): The modern standard API for reinforcement learning environments. Schola fully supports the newest Gymnasium API, ensuring your Unreal environments are perfectly formatted for standard Python training loops.

Ray RLlib (New API Stack): If you are building complex, multi-agent scenarios or need to scale your training across massive distributed clusters, Ray RLlib is the go-to tool. Schola v2 is fully compatible with RLlib's newest API stack, unlocking access to their most cutting-edge features and algorithms.

Stable-Baselines3 (2.x): Known for its reliable and easy-to-use implementations of popular algorithms (like PPO and SAC), Schola v2 has been updated to work flawlessly with the newest release of SB3.

By supporting these latest versions, Schola v2 ensures you aren't just getting bug fixes; you are getting the fastest training speeds, the most advanced algorithms, and the highest security standards available in the current machine learning landscape.

Installation

1. Clone or download AMD Schola v2 from the official repository.
2. Copy the plugin into your project’s /Plugins folder.
3. Install the required Python package to enable full functionality and integration.

pip install -e <path to Schola>/Resources/python[all]

4. Enable the plugin within your Unreal Engine project to activate its features and seamlessly integrate it into your development workflow.