ТЕХНИЧЕСКОЕ ЗАДАНИЕ: Реализовать market-based делегирование

1. Цель задачи

Спроектировать и реализовать механизм аукциона для делегирования задач между агентами в multi-agent системе. Механизм должен позволять агентам подавать ставки (bids) на задачу, а победитель аукциона назначается на её исполнение. Основная цель — обеспечить, чтобы задача автоматически передавалась агенту с наибольшей эффективностью (наименьшая стоимость / наилучшее качество).

Ключевой результат Рабочий прототип аукционного делегирования, при котором в 90% тестовых сценариев задача назначается самому эффективному агенту (согласно заранее определённой метрике эффективности).

2. Исходные данные

Если нет реального multi-agent фреймворка — симулируем:

1. Написать минимальный asyncio-тредпул с агентами (классы Agent, Task, Auctioneer)
2. Определить профили агентов (например: agent_fast: {cost_per_unit: 10, time_per_unit: 1, quality: 0.8})
3. Создать 10-20 задач разной сложности (units: 1-10) — сохранить в tasks.json

3. Технологический стек

4. Этапы выполнения

Этап 1: Проектирование аукционной модели (30–45 минут)

Действия

1. Определить типы аукционов

   • Sealed-bid first-price (закрытые ставки, победитель платит свою ставку)
   • Sealed-bid second-price (Vickrey — победитель платит вторую максимальную ставку)
   • Выбрать Vickrey как основу (стимулирует bidding|truthful bidding).

2. Определить метрику эффективности агента (score):

   • score = w1 * (1/cost) + w2 * quality + w3 * (1/time) — нормализованные веса.
   • Или total_cost = (cost_per_unit * units) + penalty_for_time.

3. Спроектировать протокол аукциона

   Auctioneer открывает аукцион для задачи.
   Агенты запрашивают спецификацию задачи.
   Агенты вычисляют свою ставку (bid = cost + time * penalty + quality discount).
   Агенты отправляют sealed bid.
   Аукционер раскрывает bids, определяет победителя (min bid).
   Победитель исполняет задачу, аукционер списывает ресурсы и логирует.
   

Ожидаемый результат этапа Документ (markdown) с описанием модели аукциона, формулы ставки и метрики эффективности.

Этап 2: Реализация базовых компонентов (1.5–2 часа)

Действия

1. Создать классы

   @dataclass
   class TaskSpec:
       task_id: str
       complexity_units: int  # от 1 до 10
       deadline_seconds: int
       
   @dataclass
   class Bid:
       agent_id: str
       task_id: str
       price: float
       estimated_time: float
       quality_score: float
       
   class Agent:
       def __init__(self, agent_id, profile: dict)
       async def compute_bid(self, task: TaskSpec) -> Bid
       async def execute(self, task: TaskSpec) -> ExecutionResult
       
   class Auctioneer:
       def __init__(self, agents: list[Agent])
       async def run_auction(self, task: TaskSpec) -> AuctionResult
   

2. Реализовать compute_bid для каждого агента

   • Использовать профиль агента: price = cost_per_unit * complexity_units
   • Если агент занят (current load), увеличить estimated_time
   • quality_score = profile.quality - load_penalty

3. Реализовать логирование всех ставок в JSON-файл auction_log.json:

   {
     "task_id": "task_001",
     "bids": [{"agent_id": "A", "price": 15.0, "time": 2.0, "quality": 0.9}, ...],
     "winner": "A",
     "bid_winner_price": 15.0,
     "execution_time": 2.1,
     "actual_quality": 0.88
   }
   

4. Реализовать механизм выбора победителя (Vickrey):

   sorted_bids = sorted(bids, key=lambda b: b.price)
   winner = sorted_bids[0]
   payment = sorted_bids[1].price  # second price
   return winner, payment
   

Ожидаемый результат этапа Работающие классы Agent, Auctioneer, Bid, функция run_auction возвращает победителя.

Этап 3: Интеграция исполнения и сбор статистики (1–1.5 часа)

Действия

1. Создать симуляцию исполнения задачи

   async def execute_all_tasks(tasks: list[TaskSpec], auctioneer: Auctioneer):
       results = []
       for task in tasks:
           auction_result = await auctioneer.run_auction(task)
           # победитель исполняет (симуляция)
           exec_result = await auction_result.winner.execute(task)
           results.append({
               'task': task.task_id,
               'winner': auction_result.winner.agent_id,
               'payment': auction_result.payment,
               'actual_time': exec_result.time,
               'actual_quality': exec_result.quality
           })
       return results
   

2. Добавить baseline-стратегии для сравнения

   • Random: задача назначается случайному агенту.
   • Round-robin: агенты по очереди.
   • Cheapest-known: выбирается агент с минимальной заявленной стоимостью (без аукциона).

3. Собрать метрики для 3 стратегий на одних и тех же задачах:

   • Total cost / payment
   • Average quality of execution
   • Total time to complete all tasks
   • Load balance (std dev of tasks per agent)

Ожидаемый результат этапа Сравнительная таблица метрик (auction vs random vs round-robin).

Этап 4: Анализ и визуализация (30–45 минут)

Действия

1. Запустить симуляцию на 100 задачах (с разной сложностью):

   tasks = [TaskSpec(f"task_{i}", random.randint(1,10), random.randint(10,60)) for i in range(100)]
   

2. Построить графики

   • Распределение задач по агентам (bar chart)
   • Cumulative cost по времени (line)
   • Quality vs cost scatter

3. Рассчитать метрику "efficiency gap

   efficiency_gap = (optimal_cost - actual_cost) / optimal_cost * 100
   optimal_cost = min over agents of true cost for each task (если бы мы знали истинные затраты)
   

4. Зафиксировать результат

   • Если efficiency_gap < 5% — задача решена успешно.

Ожидаемый результат этапа Jupyter notebook (или Python-скрипт) с графиками и итоговой таблицей.

Этап 5: Документирование и рефакторинг (30 минут)

Действия

1. Написать docstrings для всех публичных методов.
2. Подготовить README.md
   • Описание архитектуры аукциона.
   • Инструкция по запуску: python auction_simulation.py --tasks=100 --agents=5
   • Пример вывода лога и сравнения метрик.
3. Проверить корректность Vickrey-аукциона победитель платит вторую цену, а не свою.

Ожидаемый результат этапа Готовый GitHub-репозиторий (или папка) с кодом, README, логом аукциона, графиками.

5. Критерии приемки (Definition of Done)

• Агенты могут вычислить ставку на основе своей загрузки и профиля.
• Аукцион корректно выбирает победителя по минимальной цене.
• Реализован Vickrey-механизм (вторая цена) — payment = вторая минимальная ставка.
• Задача не может быть назначена агенту, который занят (загрузка > 90%).
• Аукцион выполняется асинхронно (asyncio) — все агенты подают ставки конкурентно.
• Логирование всех ставок в JSON с временными метками.
• Сравнение с baseline (random, round-robin) показывает, что аукцион снижает total cost минимум на 15%.
• Покрытие тестами: unit-тесты compute_bid, run_auction, execute (минимум 5 тестов).
• README содержит раздел "Метрики" с численными результатами симуляции.

6. Ожидаемый результат

Основной артефакт Папка market_auction/ со следующей структурой:

market_auction/
├── README.md
├── requirements.txt
├── config.py
├── models.py            # Agent, TaskSpec, Bid, AuctionResult
├── auctioneer.py        # Auctioneer implementation
├── simulation.py        # main() for running experiments
├── analyze.py           # Pandas analysis + plots
├── logs/
│   └── auction_log.json # Пример лога на 100 задач
├── plots/
│   ├── task_distribution.png
│   └── cost_comparison.png
└── tests/
    └── test_auction.py

Содержание Рабочий аукцион на асинхронных корутинах, лог с детальными ставками, сравнительная статистика по 3 стратегиям, графики. Дополнительно возможность запуска с разными параметрами (количество агентов, количество задач, веса в метрике).

7. Возможные сложности и их решение

8. Бюджет времени (оценка)

Примечание Для первого выполнения с учётом написания кода и отладки рекомендуется заложить 8 часов (один рабочий день).

9. Связанные вопросы из базы знаний

10. Чек-лист самопроверки

• Я реализовал sealed-bid second-price (Vickrey) аукцион.
• Агенты вычисляют ставку динамически: учитывают загрузку и профиль.
• Победитель определяется корректно, payment = вторая минимальная цена.
• Запустил симуляцию на минимум 50 задачах и сохранил лог.
• Построил графики сравнения с random и round-robin.
• Написал хотя бы 5 unit-тестов (pytest) для core-логики.
• README описывает, как запустить, и содержит численные результаты.
• Код асинхронный, нет гонок (использую asyncio.Lock).
• Я зафиксировал метрику efficiency_gap и она < 5% (или объяснены причины).