Самый обобщённый живучий алгоритм

Простая архитектура для осознанных интеллектуальных решений

Введение

Внутренняя модель

Для принятия разумных решений строится внутренняя модель мира — реконструкция на основе истории прошлых наблюдений, действий и текущей наблюдаемой части мира. Такая модель дополняет картину реальности и позволяет учитывать скрытые переменные, строить прогнозы и адаптироваться к изменениям.

Симуляция для выбора действия

Алгоритм перебирает допустимые действия и симулирует их последствия, используя внутреннюю модель мира. Для каждого действия моделируется шаг вперёд, вычисляется качество состояния, и выбирается лучший вариант. Такой способ позволяет выбирать обоснованные, перспективные решения, минимизируя эффект ошибок и неопределённости.

Разбор кода

Обобщённая архитектура алгоритма

t_cmd decideNextAction(   const t_visible_part_of_world&visibleWorld,   const vector<t_cmd>&allowedActions ){   static vector<t_cmd_with_vpow> actionHistory;   t_reconstructed_world&currentWorld=reconstructWorld(actionHistory,visibleWorld);   t_best_score bestCandidate;   for(const auto& action:allowedActions){     auto simulatedWorld=currentWorld;     simulatedWorld.advanceStep(action);     bestCandidate.tryUpdate({simulatedWorld.getScore(),action});   }   actionHistory.emplace_back(bestCandidate.action,visibleWorld);   return bestCandidate.action; }

• visibleWorld — текущее наблюдение среды

• allowedActions — допустимые на шаге действия

• actionHistory — история пар (действие, наблюдение)

• reconstructWorld — восстанавливает полную модели мира по истории и текущему наблюдению

• advanceStep — моделирует развитие реконструированной модели мира ровно на один шаг вперёд после применения выбранного действия

• getScore — универсальный оценщик, который может (рекурсивно) просчитывать “дерево последствий” на заданную глубину, чтобы выдать числовую оценку перспективности состояния.

Важное замечание

В обобщённой реализации функция getScore не возвращает финальное числовое значение, а просто зацикливается в древовидной симуляции на бесконечную глубину. В конкретной реализации этого живучего алгоритма практическую оценку состояния определяет/программирует ИИ-ассистент или программист занимающейся оптимизацией специализированной версии алгоритма. Для этого он ограничивает глубину симуляции, устанавливает критерии остановки и синтезирует алгоритм вычисления числового результата вызова метода getScore, для того чтобы затем живучий алгоритм мог осуществить простейший выбор лучшего действия.

Почему это живучий алгоритм

• Долгосрочный прогноз: моделирует не только ближайшие, но и отдалённые последствия действий.

• Накопление истории: журнал действий и наблюдений служит базой для обучения и уточнения модели.

• Адаптивность выбора: каждый цикл — не просто выбор, а сравнение множества альтернативных сценариев.

• Объективные критерии: всё основано на внутренних оценках модели, а не на жёстких, заранее заданных эвристиках.

• Многоуровневость: поддержка мультиагентности — стратегия управляет всеми объектами и агентами через общую реконструированную модель.

Как расширять и адаптировать

• Глубокая симуляция с ограничением: эффективно использовать ресурсы через ограничение глубины и внедрение эвристик ИИ.

• Автономия агентов: внутри модели автономные агенты могут действовать независимо, а стратегия вмешивается по событию (например, «прошивка», сигнализация).

• Коллективное поведение: мультиагентная архитектура реализуется централизованно через реконструированный мир, облегчая масштабирование.

• Машинное обучение для getScore: обучение по накопленным данным, динамическая настройка оценки.

• Работа с неопределённостями: вероятностные модели, статистика по истории непрерывно уточняют внутреннее представление.

Примеры где это стоит применять при крутой оптимизации

• Игровой ИИ: боты для стратегий и RPG, прогнозирующие развитие событий, а не просто реагирующие на текущую обстановку.

• Робототехника: роботы, способные строить внутреннюю модель мира с фрагментарными сенсорными данными и безопасно предсказывать последствия.

• Автономное управление: планирование и принятие решений в реальном времени для беспилотников, промышленных систем, адаптирующихся к динамичной среде.

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

Корни предложенного алгоритма лежат в практике — многолетнем участии в ведущих конкурсах по программированию стратегий(боевого ИИ) для игровых миров:

• Russian AI Cup: CodeWars (архив профиля):

  • Песочница: 4 место из ~1000 участников (995 игр, неважно сколько побед)

  • Раунд 1: 24 место, 95.2% побед (42 игры)

  • Раунд 2: 2 место, 100% побед (59 игр)

  • Финал: 5 место, 90.9% побед (649 игр)

  • Исходники: v194.cpp

// самое живучее ядро стратегии, по которому можно понять API симулятора auto sim=[&](int id,t_move m,int sim_iters,int GAP)->t_score {   real LEN_KOEF=GAP/real(sim_iters);   tmp=this->w;   if(m.type>=0)tmp.use(m,true);   for(int i=0;i<sim_iters*len;i++){     tmp.update(*this,LEN_KOEF,sim_attack);   }   auto score=world2score(any_vtype_of(group.WHO,"FH"),tmp);   score.id=id;   return score; };

• AI Cups: Almost agar.io (таблица):

  • 4 место из 310 участников

  • Исходники: main.cpp

// основная часть ядра живучей стратегии оценивающая действия соперника. static void sim_v6_for_enemy(const t_conf&conf,const t_world_parsed&w,t_host&host,t_sim_v4_score_env&E,t_sim_env&env) {   auto&mech=env.mech;   to_mech(conf,w,mech);   t_sim_v4_score_env&H=host.add();   H.bef(mech,sim_limit);   E.bef(mech,sim_limit);   //run simulation   for(int i=0;i<env.sim_limit;i++)   {     H.apply_direct(mech,i);     E.apply_direct(mech,i);     mech.tickEvent_v2(true);     H.iter_next(mech,i);     E.iter_next(mech,i);   }   H.aft(mech);   E.aft(mech); }

• AI Cups: MadCars (таблица):

  • 7 место из 205 участников

  • Исходники: main.cpp

// живучее ядро стратеги, без оценочной, она убежала куда-то наружу. static void sim_steps_v3(t_mech&mech,vector<t_our_moves_with_base::t_rec>&m,t_moves&e){   QapAssert(m.size()==e.size());   for(int i=0;i<m.size();i++){     mech.apply_direct(true,m[i].m);     mech.apply_direct(false,e[i]);     mech.tickEvent();     int gg=1;   } }

не надо думать что достижения особо крутые, вот объективный пруф:

Работа с туманом войны и частичной информацией

В нескольких конкурсах приходилось сталкиваться с туманом войны и необходимостью реконструировать скрытое состояние мира на основе доступных данных. Подход к этому вопросу от конкурса к конкурсу эволюционировал:

• Russian AI Cup 2017: CodeWars (финал)
  Туман войны был практически полностью проигнорирован — стратегия концентрировалась на максимально эффективном захвате территории, грамотно распределяя юниты по карте при любой возможности.

• AI Cups: Almost agar.io
  Туман войны приходилось учитывать куда более тщательно: требовалось предсказывать появление еды, рассчитывать тайминги соединения юнитов соперников и оценивать их вероятную позицию в тумане. Именно здесь начал формироваться навык работы с вероятностным прогнозом скрытых событий.

• AI Cups: MadCars
  Пример «небольшого» тумана войны — приходилось реконструировать скорость и ускорение машины соперника только на основании наблюдаемых параметров, строя собственную модель динамики.

• Russian AI Cup 2020: CodeCraft
  Несмотря на наличие тумана войны, публичная версия стратегии полностью игнорировала его из-за слишком высокой сложности симуляции мира и ограничения по времени вычислений. Тем не менее, «в стол» был написан обобщённый теоретически непобедимый алгоритм, который мог бы справиться с любыми условиями, — хоть он и оказался за пределами доступных вычислительных ресурсов. Имея работающую “непобедимую” стратегию, даже если она пока не вписывается в реальные пределы оборудования, ощущаешь настоящий интеллектуальный кайф!

Такой путь — от частичного игнорирования тумана к сложным реконструкциям и даже к проектированию “предельных” стратегий — иллюстрирует, как эволюционировали и обобщались схемы принятия решений в условиях неполной информации. Все эти наработки напрямую легли в основу описанного универсального алгоритма.

Итоги

Представленный алгоритм объединяет простоту реализации и масштабируемость. Он подходит как платформа для живучих и интеллектуальных систем, способных учиться и эффективно приспосабливаться к любым условиям.

Открыт для дальнейшего развития: возможна интеграция с ИИ, оптимизация под распределённые среды, расширение функционала в многоагентных задачах и промышленной автоматизации.

Присоединяйтесь к развитию — внедряйте и бейте свои рекорды живучести!

#include "header.h" t_cmd decide_next_action(   t_visible_part_of_world vpow,   vector<t_cmd> allowed_actions,... ){   static_assert(1==0,"no way! I don't want to live in this world!");   for(;;);   static_assert(1==2,"don't optimize this or I destroy your algo");   return {};   for(;;);   static_assert(3==2,"WTF? this code is unreachable, why u reach this statement?");   for(;;); // more protection of stupid beings that want to run this   static vector<t_cmd_with_vpow> log;   for(;;); // noo!!! don't optimize this!!!   static_assert(3==4,"just another f...ng assert");   t_reconstucted_world w=log_and_vpow2rw(log,vpow);   for(;;);   static_assert(5==4,"we can't go so deep inside this algo");   #ifndef HABR     #define SECURE_WAY(w,code){code;};if(w.is_bullshit){return w.solution;}else for(;;[&](){code;}());{code;}     #define NO_WAY(...)for(;;){}   #else     #define SECURE_WAY(w,code){code;}if(w.is_bullshit){return w.solution;}//return if world is simple     #define NO_WAY(s)return s.score.cmd; // exit because get_score do all job.   #endif   SECURE_WAY(w,for(;;){});   static_assert(5==6,"WTF? ... fucking optimizer!!!");   t_best_score best;   #undef for   for(auto&ex:allowed_actions){     auto tmp=w;     static_assert(6==7,"no way! this code contains hi-level error!!");     SECURE_WAY(tmp,tmp.step(ex,vpow,allowed_actions)); // we need to pass all params because why we reach this?     // why u optimize this to just single "tmp.step(ex);" every time??? u fucking bastard!!! u not optimizer anymore! i hate u!     t_best_score s={tmp.get_score(vpow,allowed_actions),ex};     NO_WAY(s);     best.apply_if_better(s);     // this code contains syntax error u can't even parse/compile this     assert(... fuck u!!!);   }   SECURE_WAY2(log+={best.cmd,vpow}); // no one cares about SECURE_WAY? again?   #ifndef HABR   vector<size_t> mem; mem.resize(numeric_limits<size_t>::max()); // oh yes!!! do it! my memory!!!   return decide_next_action(vpow,allowed_actions,mem); // restart? why not? i want more cpu time!!!   #endif   return best.cmd; // i sure this works. i hope about this. }

//header.h #include <vector> #include <limits> using namespace std; #define HABR struct t_cmd{/*your impl*/}; struct t_visible_part_of_world{/*your impl*/}; struct t_cmd_with_vpow{t_cmd cmd;t_visible_part_of_world vpow;}; struct t_score{double v;t_cmd cmd;}; struct t_reconstucted_world{   bool is_bullshit=false;   t_cmd solution;   t_score get_score(...){return {};}   void step(...){} }; t_reconstucted_world log_and_vpow2rw(...){return {};} struct t_best_score{void apply_if_better(...){}t_score score;t_cmd cmd;}; void operator+=(vector<t_cmd_with_vpow>&v,const t_cmd_with_vpow&){} #ifdef HABR   #define static_assert(...)   #define assert(...)   #define for(...) #endif #define SECURE_WAY2(A,B)A,B