ARAMHelper

A .NET 8 project containing a resumable ARAM dataset collector and a minimal Windows lobby detector.

Commands

For a fresh training comparison, first select a local SQLite database with TRAIN_DATABASE=path, or download one from a configured collector host with make backup. Then run make compare with Docker Desktop running. This trains champion-only, pair, and full-synergy models using all history and the latest 3 or 6 patches of the training partition. Every candidate shares the same chronological validation and test matches. Validation log loss selects the winner; test results are reported afterward for comparison. Patch counts refer to patches present in the dataset.

Results go to a timestamped directory under artifacts/training/, or TRAIN_OUTPUT=path. comparison.md and comparison.json contain the scores; .pt files preserve candidate weights. The selected variant is refit on all available matches in its chosen patch window and exported as ONNX with desktop-compatible metadata. Its reported test scores describe the candidate before refitting, not an independent test of that final export. The installed model in models/ is not replaced by make compare.

TRAIN_DATABASE=path pins a particular backup. make train PATCH_WINDOW=N compares the three variants for just that training window and writes the selected refit to models/. Loading streams participant rows; compact match records remain in memory. Training uses CUDA PyTorch on an NVIDIA GPU by default and requires Docker Desktop's NVIDIA runtime. Set TRAIN_DEVICE=cpu to force CPU training; the script then omits Docker's GPU flag. The comparison runs nine candidates and can take substantial time. Epoch validation losses are printed as training progresses. Python CLI options --max-epochs and --patience allow short smoke runs; defaults remain 250 and 20.

Run make help to list everything. Common commands:

make app         # Open the manual lobby detector
make publish     # Create artifacts/ARAMHelper/ARAMHelper.exe
make test        # Run all .NET tests
make status      # Show the local dataset
make backup      # Download a verified VPS database backup
make report      # Print training-data coverage; does not train
make test-model  # Run Python model tests in Docker
make train       # Train from the newest VPS backup
make vps-status  # Check the VPS collector
make vps-counts  # Show the VPS dataset
make vps-logs    # Follow collection logs

make collect runs collection locally. make deploy publishes and deploys the collector to a Linux host over SSH. If RIOT_API_KEY is absent, deployment securely prompts for it; the key is used only for that deployment.

Remote commands require VPS_HOST and VPS_USER. VPS_PORT defaults to 22, and VPS_IDENTITY defaults to %USERPROFILE%/.ssh/id_ed25519. If the identity file does not exist, SSH falls back to its normal authentication flow. For example:

make vps-status VPS_HOST=collector.example.com VPS_USER=deploy VPS_PORT=22

make vps-restart prompts for an optional new Riot key and restarts the existing VPS collector without publishing a release. Press Enter at the key prompt to preserve the server's current key.

make vps-remove permanently stops and disables the collector, deletes /srv/apps/aramhelper including its database and releases, removes the systemd unit, and clears ARAMHelper's temporary deployment/key files in the VPS account. It requires the VPS sudo password.

Visual lobby client

The Windows client scans visible desktop pixels when Detect is pressed and lists the allied composition and ARAM bench. It does not use the League Client API, control the client, or save screenshots.

Champion icons are downloaded from Riot Data Dragon on first launch and cached in %LocalAppData%\ARAMHelper\assets.

Dataset collector

• Queue: standard ARAM (450)
• Collection window: fixed 365-day snapshot
• Storage: SQLite with WAL, idempotent inserts, and persistent work queues
• Privacy: display names and raw Riot JSON are not stored
• Resume: safe after Ctrl+C, reboot, network failure, or API-key expiry

Setup

Set the Riot key for the current PowerShell session:

$env:RIOT_API_KEY = "RGAPI-your-key"

Training requires Docker Desktop. make report reads the newest database in data/backups/vps/ and prints patch, champion, and pair coverage without changing model files. make train runs .NET and Python tests, then writes the ONNX model, metadata, and report to models/; run make publish afterward to embed the updated model in the Windows executable. Use PATCH_WINDOW=N, TRAIN_DATABASE=path, or TRAIN_OUTPUT=path to override the default training input/output.

Remote deployment

The remote host runs a self-contained Linux release under aramhelper-collector.service; it does not need .NET or Docker installed. It must provide SSH, systemd, and a user that can run the required sudo commands. The collector is installed at /srv/apps/aramhelper.

Set the connection values for every make invocation. GNU Make accepts them as command-line variables, so no personal hostname, username, or key path needs to be committed:

$VpsHost = "collector.example.com"
$VpsUser = "deploy"
$IdentityFile = "$env:USERPROFILE\.ssh\id_ed25519"

make vps-status VPS_HOST=$VpsHost VPS_USER=$VpsUser VPS_IDENTITY="$IdentityFile"

For the initial deployment, optionally include an existing local database:

$env:RIOT_API_KEY = "RGAPI-current-key"
.\scripts\Deploy-Collector.ps1 `
    -HostName $VpsHost `
    -RemoteUser $VpsUser `
    -IdentityFile $IdentityFile `
    -Bootstrap `
    -IncludeDatabase

For a new installation without an existing database, omit -IncludeDatabase. Later deployments can use:

make deploy VPS_HOST=$VpsHost VPS_USER=$VpsUser VPS_IDENTITY="$IdentityFile"

The deployment script requires committed tracked changes. Do not use -IncludeDatabase after the remote database becomes the primary dataset, because it would replace that data.

Download a verified backup with the same connection settings:

make backup VPS_HOST=$VpsHost VPS_USER=$VpsUser VPS_IDENTITY="$IdentityFile"

make backup briefly stops an active collector to ensure its downloaded SQLite database has no WAL data, verifies the checksum, then starts the collector again.

RIOT_API_KEY, SQLite databases, build output, and local backups are excluded from Git.