Layer-Based Neural Network

Layer-Based Neural Network is a Blueprint plugin for assembling a neural network from individual layer classes. Its central class, NglSimpleLayerStackNN, is not a fixed model; it is a container that becomes a network as layers are added.

That structure puts the emphasis on composition. A developer chooses layer classes, adds them to the stack, and then uses the same class for construction, training, inference, and JSON-based save and load. The stack is processed from the input side to the output side.

NglSimpleLayerStackNN and the AddLayer method

NglSimpleLayerStackNN is the main class of the plugin, and the layer class is part of it. Construct Network creates a layer class and adds it to the network by the AddLayer method. That makes AddLayer the assembly point. Each call adds another layer class. Because the stack is processed in order from the input side to the output side, the sequence in which layers are added defines the path data travels through the network.

This is a layer-stack model instead of one monolithic network object. The central class holds the layers; the individual layer class supplies the pieces. Using the plugin means working with both levels: the stack that coordinates the flow and the layers that occupy positions in that flow.

Eight layer classes in the stack

The plugin contains eight different layer classes: Affine, Convolutional, GRU (Gated Recurrent Unit), Softmax, Sigmoid, ReLU, Softplus, and Tanh. These are the available building blocks for a network. No other layer types are listed. Each belongs to the layer class structure used by NglSimpleLayerStackNN.

For a developer, the layer list is the vocabulary of the network. A stack can combine these classes, and the order matters because processing proceeds from input to output. The stack does not treat layers as an unordered collection; it processes them sequentially.

Construct Network, Train, and Forward

The plugin exposes separate methods for the three main stages. Construct Network creates a layer class and adds it to the network using AddLayer. Train is called with Input-Data and Teach-Data. Inference is handled by calling Forward with Input-Data to calculate output.

The three calls map to distinct moments in a game AI workflow. Construction defines the network's shape. Training supplies both the input and the teaching data. Inference supplies only the input and returns the calculated output. Keeping these as separate methods means a network can be assembled, trained, and then used for inference through the same NglSimpleLayerStackNN class.

Game AI is the stated training target: the plugin allows a game AI to be trained through this process. The teaching data is passed into Train alongside the input data. The Forward method then calculates output from input data during inference.

No GPU acceleration

GPU acceleration is not supported. The plugin's training and inference methods operate without GPU acceleration. That is a plain constraint to account for when deciding how the network will be used. The layer classes and the NglSimpleLayerStackNN methods remain the same; the note simply rules out GPU acceleration as part of the plugin's capabilities.

SaveJson and LoadJson preserve structure and parameters

SaveJson writes two things to JSON: the network parameters and the network structure. LoadJson goes the other way. It constructs the network structure and reads the parameters from JSON. This is more than a weight dump; the structure is part of what is saved. A saved network is therefore represented by both its layer arrangement and its parameters.

For project work, that pairing matters because NglSimpleLayerStackNN is assembled from layers. The saved JSON carries the structure needed to reconstruct the stack, and LoadJson uses it to construct that structure again before reading the parameters. The methods are named SaveJson and LoadJson and belong to the central class's save/load path.

What the layer stack is set up to handle

Layer-Based Neural Network provides a Blueprint-accessible way to build a neural network out of eight layer classes, train it with input and teach data, run inference with the Forward method, and preserve both structure and parameters in JSON. The central NglSimpleLayerStackNN class is the place where construction, training, inference, saving, and loading meet.

Its scope is specific. Layers are added through AddLayer, processed from input to output, and selected from Affine, Convolutional, GRU, Softmax, Sigmoid, ReLU, Softplus, and Tanh. Training uses Input-Data and Teach-Data; inference uses Input-Data and calculates output. SaveJson and LoadJson handle the JSON side. GPU acceleration is not part of the package. Those are the boundaries within which the plugin works.

Explore Similar Assets

• Multiplayer FPS Procedural Animation Toolkit
• Simple Capture The Flag
• FPS First Person Shooter Framework (SKG Shooter Framework V2)
• Kronos Matchmaking
• Skills Indicators (Customizable)