IgdrasilAI — Унифицированная нейросетевая инфраструктура

IgdrasilAI — единая инфраструктура для работы с нейросетевыми бэкендами, локальными и удалёнными LLM, токенизаторами, агентами и мультиагентной сетью.

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

Документация по модулям

Структура модуля (актуально)

IgdrasilAI/
├── Neural/
│   ├── Core/              # Базовые абстракции и IGpuMathOps
│   ├── Text/              # LocalLanguageModel, токенизаторы
│   └── Models/            # Модели/артефакты
├── Text/
│   ├── Conversation/      # Message, histories, converters, remote models
│   ├── Commands/          # Команды (Execute/Memory/Think)
│   ├── Context/           # Управление контекстом
│   └── Network/           # Мультиагентная сеть
└── Docs/
    ├── index.md
    └── *.md

Быстрый старт

1. Инициализация бэкенда

using IgdrasilEngine.Engine.AI;

// Создаём реестр бэкендов
var registry = new NeuralBackendRegistry();

// Регистрируем доступные бэкенды
registry.RegisterBackend("TorchSharp", () => new TorchSharpBackend());
registry.RegisterBackend("ONNX", () => new OnnxBackend());

// Устанавливаем по умолчанию
registry.SetDefaultBackend("TorchSharp");

// Получаем бэкенд
var backend = registry.GetDefaultBackend();
await backend.InitializeAsync();

2. Загрузка модели

// Загружаем модель
var loadedModel = await backend.LoadModelAsync("path/to/model.pt");

Console.WriteLine($"Model: {loadedModel.Metadata.Name}");
Console.WriteLine($"Inputs: {loadedModel.Metadata.InputShapes[0]}");

3. Inference

// Создаём входной тензор
var input = new SimpleTensor(
    shape: new[] { 1, 3, 224, 224 },
    dataType: NeuralDataType.Float32,
    device: backend.ActiveDevice,
    data: imageData
);

// Выполняем inference
var output = await loadedModel.InferenceAsync(input);
var result = await output.GetDataAsFloatAsync();

Console.WriteLine($"Output shape: {string.Join(", ", output.Shape)}");
Console.WriteLine($"First 10 values: {string.Join(", ", result.Take(10))}");

Ключевые концепции

INeuralComponent

Базовый интерфейс для всех компонентов (бэкенды, модели, токенизаторы):

public interface INeuralComponent : IDisposable
{
    string ComponentId { get; }
    NeuralComponentState State { get; }
    Task InitializeAsync(CancellationToken ct = default);
    Task ShutdownAsync();
}

Состояния:

INeuralBackend

Бэкенд для выполнения нейросетевых операций:

public interface INeuralBackend : INeuralComponent
{
    IReadOnlyList<IComputeDevice> AvailableDevices { get; }
    IComputeDevice ActiveDevice { get; set; }
    Task<ILoadedModel> LoadModelAsync(string modelPath);
    bool SupportsAsyncInference { get; }
}

Примеры бэкендов:

INeuralTensor

Унифицированный тензор для работы со всеми бэкендами:

public interface INeuralTensor : IDisposable
{
    int[] Shape { get; }
    NeuralDataType DataType { get; }
    IComputeDevice Device { get; }
    
    Task<float[]> GetDataAsFloatAsync();
    Task SetDataAsync(Array data);
    Task<INeuralTensor> MoveToDeviceAsync(IComputeDevice device);
    Task<INeuralTensor> NormalizeAsync();
    Task<INeuralTensor> ApplyActivationAsync(ActivationFunction activation);
}

Реализации:

IComputeDevice

Представление вычислительного устройства:

public interface IComputeDevice
{
    string DeviceId { get; }
    ComputeDeviceType DeviceType { get; }  // CPU, CUDA, HIP, Metal, TPU
    string DeviceName { get; }
    long AvailableMemoryMB { get; }
    long TotalMemoryMB { get; }
}

ILoadedModel

Загруженная нейросетевая модель:

public interface ILoadedModel : IDisposable
{
    string ModelId { get; }
    IModelMetadata Metadata { get; }
    Task<INeuralTensor> InferenceAsync(INeuralTensor input);
    IAsyncEnumerable<INeuralTensor> InferenceStreamAsync(INeuralTensor input);
}

Примеры использования

Классификация изображений

var backend = registry.GetBackend("TorchSharp");
var model = await backend.LoadModelAsync("resnet50.pt");

// Загружаем изображение
var imageData = LoadImage("photo.jpg");
var input = new SimpleTensor(
    new[] { 1, 3, 224, 224 },
    NeuralDataType.Float32,
    backend.ActiveDevice,
    imageData
);

var output = await model.InferenceAsync(input);
var logits = await output.GetDataAsFloatAsync();

// Берём top-5
var top5 = logits
    .Select((val, idx) => (idx, val))
    .OrderByDescending(x => x.val)
    .Take(5)
    .ToList();

foreach (var (classIdx, score) in top5)
    Console.WriteLine($"Class {classIdx}: {score:F4}");

Streaming генерация текста

var backend = registry.GetBackend("TorchSharp");
var model = await backend.LoadModelAsync("gpt2.pt");

var prompt = "Hello, ";
var tokens = await tokenizer.EncodeAsync(prompt);
var inputTensor = new SimpleTensor(new[] { 1, tokens.Length }, /* ... */);

// Streaming генерация
await foreach (var outputToken in model.InferenceStreamAsync(inputTensor))
{
    var tokenIds = await outputToken.GetDataAsIntAsync();
    var text = await tokenizer.DecodeAsync(tokenIds);
    Console.Write(text);
}

Работа с GPU/CPU

var backend = registry.GetBackend("TorchSharp");

// Выбираем CUDA если доступна
var gpuDevice = backend.AvailableDevices
    .FirstOrDefault(d => d.DeviceType == ComputeDeviceType.CUDA);

if (gpuDevice != null)
{
    backend.ActiveDevice = gpuDevice;
    Console.WriteLine($"Using {gpuDevice.DeviceName}");
}
else
{
    Console.WriteLine("CUDA not available, using CPU");
}

// Загружаем модель на выбранное устройство
var model = await backend.LoadModelAsync("model.pt");

Roadmap (обновлено)

Phase 1: Core (готово)

Phase 2: Backends (выполнено)

Phase 3: Text (LLM) (выполнено)

Phase 4: Agents & Network (выполнено)

Phase 5: Speech (план)

Phase 6: Training (в процессе)

Проект: Igdrasil Engine
Версия: 1.0
Статус: Development (Phase 1)