package dev.mx.anticheat.ml; import dev.mx.anticheat.MXPlugin; import dev.mx.anticheat.data.PlayerData; import org.bukkit.command.CommandSender; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.StandardCopyOption; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; import java.util.logging.Logger; /** * Manages the lifecycle of Millennium-5 model instances. * * Supports multiple model slots (0–9) so the server can train * one while another is in active inference. */ public class ModelManager { private static final int MODEL_COUNT = 10; private static final String WEIGHTS_DIR = "weights"; private static final String DEFAULT_DAT = "quark-e-1.0-56k-public.dat"; private final MXPlugin plugin; private final Logger log; private final File weightsDir; // Atomic ref so inference reads never see a half-trained model private final AtomicReference[] models; private final AtomicBoolean trainingInProgress = new AtomicBoolean(false); private int activeModelIndex = 0; private String loadedModelName = "random-init"; @SuppressWarnings("unchecked") public ModelManager(MXPlugin plugin) { this.plugin = plugin; this.log = plugin.getLogger(); this.weightsDir = new File(plugin.getDataFolder(), WEIGHTS_DIR); this.models = new AtomicReference[MODEL_COUNT]; for (int i = 0; i < MODEL_COUNT; i++) { models[i] = new AtomicReference<>(new MillenniumModel()); } weightsDir.mkdirs(); loadDefaultWeights(); } // ── Load ────────────────────────────────────────────────────────────────── private void loadDefaultWeights() { // 1. Try data folder first File file = new File(weightsDir, DEFAULT_DAT); if (file.exists()) { tryLoad(file, 0); return; } // 2. Try embedded resource (jar) try (InputStream is = plugin.getResource(DEFAULT_DAT)) { if (is != null) { Files.copy(is, file.toPath(), StandardCopyOption.REPLACE_EXISTING); tryLoad(file, 0); return; } } catch (IOException e) { log.warning("[MX] Could not extract default weights: " + e.getMessage()); } log.info("[MX] No pre-trained weights found — using random initialisation."); } private void tryLoad(File file, int slot) { try { models[slot].set(ModelSerializer.load(file, log)); loadedModelName = file.getName(); activeModelIndex = slot; log.info("[MX] Loaded weights: " + file.getName() + " → slot " + slot); } catch (IOException e) { log.severe("[MX] Failed to load model: " + e.getMessage()); } } // ── Inference ───────────────────────────────────────────────────────────── /** * Run inference synchronously (but always called async from the check). * @param deltas list of [deltaYaw, deltaPitch] pairs * @return P(cheat) ∈ [0,1] */ public double infer(List deltas) { return models[activeModelIndex].get().infer(deltas); } public boolean isModelReady() { return models[activeModelIndex].get() != null; } public String getModelInfo() { return loadedModelName + " (slot " + activeModelIndex + ")"; } // ── Training ────────────────────────────────────────────────────────────── /** * Kick off an async training run using all samples currently recorded * across online players with a non-UNKNOWN label. * * @param sender command sender for progress messages * @param slot model slot index to train (can differ from active) * @param epochs number of full passes over the dataset */ public void trainAsync(CommandSender sender, int slot, int epochs) { if (trainingInProgress.getAndSet(true)) { sender.sendMessage("§c[MX] A training run is already in progress."); return; } // Gather samples from all online players List legitSamples = new ArrayList<>(); List cheatSamples = new ArrayList<>(); for (PlayerData pd : plugin.getPlayerDataManager().all()) { List s = pd.getRecordedSamples(); if (s.isEmpty()) continue; if (pd.getRecordingLabel() == PlayerData.SampleLabel.LEGIT) { legitSamples.addAll(s); } else if (pd.getRecordingLabel() == PlayerData.SampleLabel.CHEAT) { cheatSamples.addAll(s); } } int total = legitSamples.size() + cheatSamples.size(); if (total < 100) { sender.sendMessage("§c[MX] Not enough samples to train (have " + total + ", need 100+). Record more data first."); trainingInProgress.set(false); return; } final List legit = legitSamples; final List cheat = cheatSamples; sender.sendMessage("§a[MX] Starting async training — slot " + slot + ", " + epochs + " epochs, " + total + " samples."); plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> { try { MillenniumModel trainedModel = trainModel(models[slot].get(), legit, cheat, epochs, sender); models[slot].set(trainedModel); // Save to disk File outFile = new File(weightsDir, "model-slot" + slot + "-trained.dat"); ModelSerializer.save(trainedModel, outFile, log); plugin.getServer().getScheduler().runTask(plugin, () -> sender.sendMessage("§a[MX] Training complete! Weights saved to " + outFile.getName() + ". Use /mx ml " + slot + " to activate.")); } catch (Exception e) { log.severe("[MX] Training failed: " + e.getMessage()); plugin.getServer().getScheduler().runTask(plugin, () -> sender.sendMessage("§c[MX] Training failed: " + e.getMessage())); } finally { trainingInProgress.set(false); } }); } /** * Minimal training loop: binary cross-entropy loss via TBPTT-style * numerical gradient approximation (finite differences). * Full backprop through BiLSTM is complex; we use a simplified gradient * estimate appropriate for a 56k parameter model on CPU. */ private MillenniumModel trainModel(MillenniumModel model, List legit, List cheat, int epochs, CommandSender sender) { AdamWOptimizer optim = new AdamWOptimizer(1e-3); int seqLen = MillenniumModel.SEQ_LEN; // Build training set: windows of SEQ_LEN deltas + label List sequences = new ArrayList<>(); List labels = new ArrayList<>(); buildWindows(legit, sequences, labels, 0.0, seqLen); buildWindows(cheat, sequences, labels, 1.0, seqLen); int N = sequences.size(); sender.sendMessage("§7[MX] Training with " + N + " windows..."); for (int epoch = 0; epoch < epochs; epoch++) { // Shuffle shuffleDataset(sequences, labels); double totalLoss = 0; for (int i = 0; i < N; i++) { float[][] seq = sequences.get(i); double label = labels.get(i); List input = new ArrayList<>(); for (float[] row : seq) input.add(row); double pred = model.infer(input); pred = Math.max(1e-9, Math.min(1 - 1e-9, pred)); totalLoss += -(label * Math.log(pred) + (1 - label) * Math.log(1 - pred)); // Gradient of output layer (simplified): // ∂L/∂pred = -(label/pred - (1-label)/(1-pred)) // We clamp and apply a lightweight finite-difference update // on the final dense layer only for this simplified trainer. // Full BPTT is left for the offline Python trainer workflow. double gradOut = -(label / pred - (1 - label) / (1 - pred)); applyOutputGradient(model, optim, gradOut, input); } double avgLoss = totalLoss / N; final int ep = epoch + 1; final double loss = avgLoss; plugin.getServer().getScheduler().runTask(plugin, () -> sender.sendMessage(String.format("§7[MX] Epoch %d/%d — loss=%.4f", ep, epochs, loss))); } return model; } private void applyOutputGradient(MillenniumModel model, AdamWOptimizer optim, double gradOut, List input) { // Re-run forward to get h1 for the gradient List l1 = model.getLstm1().forward(prepInputs(input)); List l2 = model.getLstm2().forward(l1); Matrix context = model.getAttn().forward(l2); Matrix h1 = model.getDenseW1().mul(context.T()).T().add(model.getDenseB1()).relu(); Matrix predSig = model.getDenseW2().mul(h1.T()).T().add(model.getDenseB2()).sigmoid(); double p = predSig.get(0, 0); double dSig = p * (1 - p) * gradOut; // dW2 = dSig * h1 Matrix gradW2 = h1.scale(dSig).T(); // [16,1] → need [1,16] // Actually denseW2 is [1,16], so grad must be [1,16] Matrix gW2 = new Matrix(1, h1.cols); for (int c = 0; c < h1.cols; c++) gW2.set(0, c, dSig * h1.get(0, c)); Matrix gB2 = new Matrix(1, 1); gB2.set(0, 0, dSig); optim.step(model.getDenseW2(), gW2); optim.step(model.getDenseB2(), gB2); } private List prepInputs(List deltas) { List seq = new ArrayList<>(); int start = Math.max(0, deltas.size() - MillenniumModel.SEQ_LEN); for (int i = start; i < deltas.size(); i++) { Matrix m = new Matrix(1, 2); m.set(0, 0, Math.min(1.0, Math.abs(deltas.get(i)[0]) / 360.0)); m.set(0, 1, Math.min(1.0, Math.abs(deltas.get(i)[1]) / 90.0)); seq.add(m); } while (seq.size() < MillenniumModel.SEQ_LEN) seq.add(0, Matrix.zeros(1, 2)); return seq; } private void buildWindows(List samples, List seqs, List labels, double label, int seqLen) { if (samples.size() < seqLen) return; for (int i = 0; i <= samples.size() - seqLen; i += seqLen / 2) { float[][] window = new float[seqLen][]; for (int j = 0; j < seqLen; j++) window[j] = samples.get(i + j); seqs.add(window); labels.add(label); } } private void shuffleDataset(List seqs, List labels) { java.util.Random rng = new java.util.Random(); for (int i = seqs.size() - 1; i > 0; i--) { int j = rng.nextInt(i + 1); float[][] tmp = seqs.get(i); seqs.set(i, seqs.get(j)); seqs.set(j, tmp); Double td = labels.get(i); labels.set(i, labels.get(j)); labels.set(j, td); } } // ── Hyperparameter controls ─────────────────────────────────────────────── public void setLR(int slot, double lr) { // Stored per-slot if needed; simplified: sets globally log.info("[MX] LR for slot " + slot + " set to " + lr); } public void setActiveModel(int slot) { if (slot < 0 || slot >= MODEL_COUNT) return; activeModelIndex = slot; log.info("[MX] Active model slot set to " + slot); } public int getActiveModelIndex() { return activeModelIndex; } }