Исходник [Сурс] Valorant TinyPointPresenceNet — Сверхбыстрая нейронка для поиска голов

[hex_cat]

Народ, кто ковыряет нейронки под Valorant, нашел интересную архитектуру Tiny CNN. Главная фишка — субмиллисекундный инференс, что критично для аима, когда Vanguard дышит в спину. Это не тяжелая YOLO, а максимально облегченная сетка для работы с кропами.

Пожалуйста, авторизуйтесь для просмотра ссылки.

Пожалуйста, авторизуйтесь для просмотра ссылки.

Технические спецификации:

1. Вход: 50x50 RGB.
2. Выход: Координаты X, Y (локализация головы) + Presence (флаг наличия цели).
3. Датасет: Обучено на 1000 изображений (50/50 наличие/отсутствие игрока).
4. Особенности: Используется CoordConvStem для лучшей регрессии координат.

Автор пишет, что точность X/Y пока гуляет, так что в идеале юзать параллельно с HSV сканированием или дообучать на более жирном датасете.

Архитектура модели (model.py):

import torch
import torch.nn as nn

class CoordConvStem(nn.Module):
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        batch_size, _, height, width = x.shape
        device = x.device
        dtype = x.dtype
        yy = torch.linspace(-1.0, 1.0, steps=height, device=device, dtype=dtype)
        xx = torch.linspace(-1.0, 1.0, steps=width, device=device, dtype=dtype)
        yy = yy.view(1, 1, height, 1).expand(batch_size, 1, height, width)
        xx = xx.view(1, 1, 1, width).expand(batch_size, 1, height, width)
        return torch.cat([x, xx, yy], dim=1)

class TinyPointPresenceNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.coord_stem = CoordConvStem()
        self.features = nn.Sequential(
            nn.Conv2d(5, 24, 3, padding=1), nn.ReLU(),
            nn.Conv2d(24, 24, 3, stride=2, padding=1), nn.ReLU(),
            nn.Conv2d(24, 32, 3, stride=2, padding=1), nn.ReLU(),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU()
        )
        self.head = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 13 * 13, 128), nn.ReLU(),
            nn.Linear(128, 3)
        )

    def forward(self, x: torch.Tensor):
        x = self.coord_stem(x)
        x = self.features(x)
        raw = self.head(x)
        return torch.sigmoid(raw[:, :2]), raw[:, 2]

Спойлер: Замеры производительности (Inference Latency)

• ONNX + CUDA FP32: 0.7ms (самый сок для реалтайма)
• ONNX + CPU FP32: 2.5ms
• ONNX + CPU (INT8 Quantized): 1.3ms
• CoreML (MacBook): 0.6ms

Скрипт для инференса:

import torch
import numpy as np
from PIL import Image

def load_image(path):
    img = Image.open(path).convert("RGB")
    img = np.asarray(img, dtype=np.float32) / 255.0
    return torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0)

# Загрузка и прогон через модель
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = TinyPointPresenceNet().to(device)
# model.load_state_dict(torch.load("model.pt"))

Для тех, кто пишет свои внешние читы — база отличная. Сетка весит копейки, залетает в тензорные ядра со свистом. Главное — грамотно реализовать захват кадра без оверлея, чтобы не триггерить античит на чтение экрана.

Кто уже пробовал подобные микро-архитектуры под Valorant, как профит по сравнению с классическим цветовым аимом?