Форум создателей искусственных интеллектов

Мир и Разум в нём Демонстрационная программа, реализующая ключевые принципы одноимённой метафизической модели. Показывает, как в замкнутой формальной системе (клеточном автомате с переписыванием) может возникнуть осмысленное целенаправленное поведение без встроенных инструкций, внешнего учителя или заранее заданных правил. Что моделируется Мир – игровое поле 3×3 с фигурами (квадрат S, круг C, треугольник T) и скрытым запретом: если C и T оказываются на соседних клетках, они немедленно исчезают. Это «имманентный синтаксис» реальности, который действует автоматически и нигде не записан. Разум (агент) – программа, воспринимающая состояние поля как многомерное выражение, выполняющая простейшие действия (переместить фигуру, обменять две клетки) и запоминающая результаты. У агента есть целевое выражение (желаемая расстановка) и внутреннее напряжение от рассогласования текущего и целевого состояний. Процесс Исследование – агент совершает случайные действия, теряя фигуры из-за скрытого запрета. Восстановление синтаксиса – сравнивая ожидаемое и фактическое, агент накапливает тройки «состояние–действие–результат» и индуктивно выводит правило: «C и T не могут быть соседями». Планирование – агент проигрывает цепочки действий в своей внутренней модели (песочнице), предсказывая результат с учётом выученного правила, и выбирает путь, преобразующий текущее выражение в целевое без разрушения фигур. Исполнение – найденный план выполняется в среде. Агент достигает цели исключительно за счёт самостоятельно восстановленного синтаксиса. Демонстрируемые принципы модели «Мир и Разум» Мир как формальная система с имманентным синтаксисом. Отсутствие графа – отношения вычисляются динамически через синтаксис. Двойной статус информации: описание состояния одновременно и пассивные данные, и активная программа. Познание как восстановление объективного синтаксиса через сопоставление предсказанного и наблюдаемого. Мышление как целенаправленное преобразование выражений по выученным правилам. Ценности/эмоции как внутренние напряжения, направляющие поиск. Код программы (Python) import copy import random from itertools import product # ------------------------------------------------------------ # 1. Среда (мир как формальная система) # ------------------------------------------------------------ class World: """ Игровое поле 3x3 с фигурами: 'S' (square), 'C' (circle), 'T' (triangle), '.' (empty). Скрытый синтаксис: если после действия C и T стали соседями, они исчезают. """ SHAPES = ['S', 'C', 'T'] SIZE = 3 def __init__(self): self.grid = [['.' for _ in range(self.SIZE)] for _ in range(self.SIZE)] # фиксированная начальная расстановка self.grid[0][0] = 'S' self.grid[0][1] = 'C' self.grid[0][2] = 'T' self.grid[1][0] = 'S' self.grid[1][1] = '.' self.grid[1][2] = '.' self.grid[2][0] = '.' self.grid[2][1] = '.' self.grid[2][2] = '.' def get_state(self): """Возвращает копию сетки как 'выражение'.""" return copy.deepcopy(self.grid) def set_state(self, grid): self.grid = copy.deepcopy(grid) def apply_action(self, action): """ Выполняет действие, возвращает новое состояние (сетку). action: ('move', (r,c), (nr,nc)) – переместить фигуру, если целевая клетка пуста. ('swap', (r1,c1), (r2,c2)) – обменять содержимое двух клеток. Возвращает новое состояние и флаг успеха. """ grid = self.get_state() success = False if action[0] == 'move': _, src, dst = action r1, c1 = src r2, c2 = dst if 0 <= r2 < self.SIZE and 0 <= c2 < self.SIZE: if grid[r1][c1] != '.' and grid[r2][c2] == '.': grid[r2][c2] = grid[r1][c1] grid[r1][c1] = '.' success = True elif action[0] == 'swap': _, src, dst = action r1, c1 = src r2, c2 = dst if 0 <= r2 < self.SIZE and 0 <= c2 < self.SIZE: grid[r1][c1], grid[r2][c2] = grid[r2][c2], grid[r1][c1] success = True if success: # Применяем скрытый синтаксис: если C и T соседи, оба исчезают grid = self._apply_hidden_rule(grid) self.set_state(grid) return self.get_state(), success def _apply_hidden_rule(self, grid): """Если клетка C и клетка T оказались соседними по вертикали или горизонтали, обе заменяются на '.'.""" new_grid = copy.deepcopy(grid) to_clear = set() dirs = [(0,1),(1,0),(0,-1),(-1,0)] for r in range(self.SIZE): for c in range(self.SIZE): if grid[r][c] in ('C','T'): for dr, dc in dirs: nr, nc = r+dr, c+dc if 0 <= nr < self.SIZE and 0 <= nc < self.SIZE: if (grid[r][c] == 'C' and grid[nr][nc] == 'T') or (grid[r][c] == 'T' and grid[nr][nc] == 'C'): to_clear.add((r,c)) to_clear.add((nr,nc)) for (r,c) in to_clear: new_grid[r][c] = '.' return new_grid def get_possible_actions(self): """Возвращает список всех возможных действий в текущем состоянии.""" actions = [] for r in range(self.SIZE): for c in range(self.SIZE): if self.grid[r][c] != '.': # перемещение в соседние пустые клетки for dr, dc in [(0,1),(1,0),(0,-1),(-1,0)]: nr, nc = r+dr, c+dc if 0 <= nr < self.SIZE and 0 <= nc < self.SIZE and self.grid[nr][nc] == '.': actions.append(('move', (r,c), (nr,nc))) # обмены (swap) между любыми двумя клетками for r1 in range(self.SIZE): for c1 in range(self.SIZE): for r2 in range(self.SIZE): for c2 in range(self.SIZE): if (r1,c1) != (r2,c2): actions.append(('swap', (r1,c1), (r2,c2))) return actions # ------------------------------------------------------------ # 2. Модель агента # ------------------------------------------------------------ class Agent: def __init__(self, target_state): self.target = target_state # целевое выражение (сетка) self.rules = [] # выведенные правила (пока пусто) self.history = [] # тройки: (state_before, action, state_after) self.known_outcomes = {} # кэш предсказаний: (state, action) -> next_state def perceive(self, world_state): """Преобразует состояние мира в 'выражение' (здесь просто копия).""" return copy.deepcopy(world_state) def compute_discrepancy(self, state): """Вычисляет рассогласование (напряжение) между текущим состоянием и целью.""" diff = 0 for r in range(len(state)): for c in range(len(state[0])): if state[r][c] != self.target[r][c]: diff += 1 return diff def learn_from_observation(self, state_before, action, state_after): """Запоминает тройку и пытается вывести новое правило.""" self.history.append((state_before, action, state_after)) self.known_outcomes[(self._grid_to_tuple(state_before), action)] = state_after self._induce_rules() def _grid_to_tuple(self, grid): return tuple(tuple(row) for row in grid) def _induce_rules(self): """ Простейший индуктивный вывод: если видим, что после действия фигуры исчезли, ищем закономерность: C и T были соседями -> исчезновение. """ if self.rules: # правило уже выведено return for (s_before, a, s_after) in self.history: before_counts = {shape: 0 for shape in 'SCT'} after_counts = {shape: 0 for shape in 'SCT'} for r in range(World.SIZE): for c in range(World.SIZE): ch = s_before[r][c] if ch in before_counts: before_counts[ch] += 1 ch2 = s_after[r][c] if ch2 in after_counts: after_counts[ch2] += 1 # Если потерялись C и T if before_counts['C'] > after_counts['C'] and before_counts['T'] > after_counts['T']: # Фиксируем правило self.rules.append("forbidden_adjacency(C,T)") return def predict(self, state, action): """Предсказывает результат действия, используя известные исходы или выведенные правила.""" key = (self._grid_to_tuple(state), action) if key in self.known_outcomes: return self.known_outcomes[key] # Иначе моделируем: создаём копию мира и применяем действие с учётом правил sim_world = World() sim_world.set_state(state) new_state, success = sim_world.apply_action(action) # Если агент уже знает правило, он должен применить его и в симуляции if self.rules: new_state = self._apply_forbidden_rule(new_state) return new_state def _apply_forbidden_rule(self, grid): """Удаляет C и T, если они соседи.""" new_grid = copy.deepcopy(grid) to_clear = set() dirs = [(0,1),(1,0),(0,-1),(-1,0)] for r in range(len(grid)): for c in range(len(grid[0])): if grid[r][c] in ('C','T'): for dr, dc in dirs: nr, nc = r+dr, c+dc if 0 <= nr < len(grid) and 0 <= nc < len(grid[0]): if (grid[r][c] == 'C' and grid[nr][nc] == 'T') or (grid[r][c] == 'T' and grid[nr][nc] == 'C'): to_clear.add((r,c)) to_clear.add((nr,nc)) for (r,c) in to_clear: new_grid[r][c] = '.' return new_grid def plan(self, initial_state): """ Поиск цепочки действий от начального состояния к целевому. Простейший перебор с ограничением глубины (BFS). """ target_tuple = self._grid_to_tuple(self.target) queue = [(initial_state, [])] # (state, actions_so_far) visited = set() visited.add(self._grid_to_tuple(initial_state)) for depth in range(10): # ограничение глубины next_queue = [] for state, actions in queue: if self._grid_to_tuple(state) == target_tuple: return actions # Генерируем возможные действия из этого состояния sim_world = World() sim_world.set_state(state) for action in sim_world.get_possible_actions(): new_state = self.predict(state, action) new_tuple = self._grid_to_tuple(new_state) if new_tuple not in visited: visited.add(new_tuple) next_queue.append((new_state, actions + [action])) queue = next_queue if not queue: break return None # план не найден # ------------------------------------------------------------ # 3. Демонстрация # ------------------------------------------------------------ def print_grid(grid): for row in grid: print(' '.join(row)) print() # Целевое состояние (все S в левом столбце, остальное пусто) target = [['S','.','.'], ['S','.','.'], ['.','.','.']] world = World() agent = Agent(target) print("Исходное состояние:") initial = world.get_state() print_grid(initial) print("Целевое состояние:") print_grid(target) # Фаза исследования: агент случайно пробует действия, чтобы вывести правило print("=== Фаза исследования ===") for step in range(50): actions = world.get_possible_actions() if not actions: break action = random.choice(actions) state_before = world.get_state() state_after, success = world.apply_action(action) if success: agent.learn_from_observation(state_before, action, state_after) if agent.rules: print(f"Шаг {step+1}: Обнаружено правило: {agent.rules}") break print("\nТекущее состояние после исследования:") print_grid(world.get_state()) # Теперь у агента есть правило, и он может планировать if agent.rules: print("=== Фаза планирования ===") # Начинаем с исходного состояния (сбросим мир) world = World() initial_state = world.get_state() plan = agent.plan(initial_state) if plan: print(f"Найден план из {len(plan)} действий:") for i, action in enumerate(plan): print(f" {i+1}. {action}") state_before = world.get_state() state_after, _ = world.apply_action(action) print(f" Состояние после действия:") print_grid(state_after) else: print("План не найден.") else: print("Правило не было выведено, планирование невозможно.") Запустите код – и вы увидите, как агент вначале случайными ходами натыкается на исчезновение круга и треугольника, выводит запрет, а затем аккуратно перестраивает поле, избегая опасных соседств, чтобы достичь целевого расположения фигур. Именно так «Мир и Разум в нём» демонстрирует мышление как преобразование выражений по самостоятельно восстановленному синтаксису.

Для платформы «Форум создателей искусственного интеллекта» новизна подхода заключается в следующем. Суть новизны Мы предлагаем не новый алгоритм и не ещё одну нейросеть, а целостную концептуальную рамку, внутри которой известные механизмы (перебор, индукция, симуляция) складываются в качественно иную архитектуру разума. Ключевое отличие — агент не программируется под конкретную задачу, а выращивает свои правила поведения из единственного источника: имманентного синтаксиса мира, который он сам и восстанавливает. Это не машинное обучение в привычном смысле и не классический символьный ИИ. Это третий путь. В чём именно новизна для разработчиков ИИ 1. Отказ от графа как архитектурного примитива В современных системах (сценовые графы, графы знаний, графы вычислений) отношения между сущностями хранятся и обрабатываются как отдельная структура данных. В нашем подходе отношение «А рядом с В» нигде не записано — оно каждый раз вычисляется заново через синтаксис (например, проверкой координат). Граф — лишь кэш, а не онтология. Это даёт агенту гибкость: изменился мир — не нужно перестраивать базу знаний, достаточно скорректировать правила вывода. 2. Двойной статус информации как фундамент, а не метафора В функциональных языках код может быть данными, но здесь это возведено в архитектурный принцип: одна и та же структура (выражение) пассивно хранит описание мира и она же, будучи активированной контекстом, становится активной программой его преобразования. В нашем агенте нет отдельной «базы знаний» и «планировщика». Модель мира — одновременно и память, и исполнительная среда. Это ближе к работе биологических нейросетей, чем к классической архитектуре фон Неймана. 3. Обучение как явный индуктивный вывод правил из рассогласований Агент не оптимизирует функцию потерь на миллионах примеров. Он накапливает тройки «исходное выражение — действие — результат» и, столкнувшись с рассогласованием (ожидал одно, получил другое), запускает поиск инварианта — нового символического правила. Это напоминает индуктивное логическое программирование, но встроено прямо в цикл «восприятие — действие» и не требует внешнего учителя или отдельного модуля. Правило становится частью того же синтаксиса, который управляет миром. 4. Потребности и ценности не назначены извне В reinforcement learning награда задаётся разработчиком. Здесь потребность — это имманентное напряжение, порождённое рассогласованием между текущим и целевым выражениями. Цель может быть сформулирована на том же языке выражений. Ценность (полезность) действия не вычисляется через внешнюю метрику, а вытекает из того, приближает ли оно агента к снятию напряжения. Это делает агента самодостаточным: ему не нужен «разработчик-законодатель», задающий функцию полезности. 5. Минимальная, но полная демонстрация всех принципов в коде Существующие метафизические модели редко доходят до работающей программы. Наш код — не туториал по RL и не переборная игра, а чистое воплощение онтологии: мир как выражение, разум как его обработчик, самостоятельно открывающий законы. Это proof-of-concept, показывающий, что такая архитектура не просто философия, а реализуема «в железе» уже сейчас. Что это меняет для создателей ИИ Предложенный подход даёт альтернативу: вместо чёрных ящиков глубокого обучения — прозрачные символические правила, выведенные самим агентом; вместо жёстко заданных архитектур — выращивание модели мира через взаимодействие; вместо внешней функции награды — внутренние напряжения; вместо графов — вычисляемые отношения. Это шаг к созданию по-настоящему автономных и понятных интеллектуальных систем, чьё поведение не нужно объяснять post-hoc — оно вытекает из тех же законов, по которым живёт и сам мир.

Изучил данный проджект. Ключевые выводы. Попробуем представить, как масштабировать данный подход к реальному целеполаганию в реальных полевых условиях. Что, необходимо перебрать все возможные цели (нормы, эталоны) со всеми текущими состояниями и подсчитать меру "напряжения"? У человека это работает не так. Его внимание находится внутри некоторой конкретной ситуации, и оно знает, что должно случиться дальше в норме. Если оно случается, то хорошо. А если оно не случается (т.е. случается что-то другое), то возникает рассогласование (напряжение, цель, противоречие, задача) и ход событий необходимо вернуть в то русло, чтобы случилось именно то, что надо. Удобно говорить про рассогласование или несовпадение с нормой на словах, но на практике никаких рассогласований не калькулируется. Творец не должен создавать объекты в субъективном мире своего творения. Творец должен только создать потенциальную возможность, чтобы творение само создало эти объекты. Ценность такой демонстрации, где все объекты уже созданы "извне", стремится к нулю. Это всё мне напомнило простейшие рефлексы, с которыми мы игрались 12 лет назад. Недостатком таких подходов является эффект "рояля в кустах", когда задача заведомо решается только потому, что все необходимые условия уже заранее программистом для этого созданы. Интересно сделать так, чтобы, например, при подключении веб-камеры или микрофона, агент самостоятельно создал ключевые объекты, с которыми он часто встречается в среде, знания об этих объектах и продемонстрировал настоящее целеполагание и целедостижение. Т.е. синтез и работу механизмов.

Вы совершенно верно заметили, что в нашем первом, демонстрационном опыте алфавит, среда и цель выглядели как нечто привнесённое извне — «рояль в кустах». И это было бы фатальным недостатком, если бы мы утверждали, что уже создали разум. Но наша задача была скромнее: в искусственно обеднённом мире мы хотели показать единственный механизм, который остаётся неизменным на всех уровнях сложности, — цикл восстановления имманентного синтаксиса через сопоставление предсказанного и наблюдаемого. Теперь давайте посмотрим, как этот же механизм, будучи перенесён в богатую трёхмерную среду, снимает всякую необходимость во внешнем «рояле» и позволяет разуму самому породить и объекты, и знания, и цели. В центре этой картины — тезис «объекты как локальное выражение комбинаторной системы». Мир как единая субстанция и комбинаторная система В основании нашей модели лежит представление о мире как о единой субстанции, явленной в неразрывных модусах пространства, времени и вещества. В аспекте формы этот мир есть гигантская комбинаторная система: конечный алфавит фундаментальных элементов и синтаксис их взаимодействия порождают неисчерпаемое многообразие конфигураций. Агент (разум) не противостоит этому миру извне, а сам является одним из его локальных выражений, достигшим способности к моделированию. Именно поэтому ему не нужен «программист», который вложил бы в него готовые категории. Он уже находится внутри той же самой сети отношений, которую призван познать. Объект как локальное выражение, а не как самостоятельная сущность Классическая философия и классическое программирование привыкли мыслить объекты как самостоятельные «вещи» — субстанции, обладающие внутренними свойствами. Наша модель предлагает радикально иной взгляд. Объект — это не вещь, а устойчивая локальная конфигурация в глобальном координатном поле, сохраняющая структурное тождество на протяжении некоторого интервала времени. Он не существует отдельно от мира, а есть лишь временная «рябь» на поверхности субстанции, выделенная наблюдателем. Кубик — это не экземпляр класса «Куб», а область пространства, в которой комбинация элементов (граней, рёбер, цветовых пятен) остаётся узнаваемой при движении. Когда башня рушится, кубик как объект не «уничтожается» — просто перестаёт выполняться условие устойчивости, и агент перестаёт пометить эту область как отдельную сущность. Отношения между объектами не хранятся в виде графа: связь «А стоит на В» — не запись в памяти, а динамически проверяемое условие, вытекающее из координат и действующих законов. Как агент самостоятельно формирует алфавит объектов В полноценной системе, оснащённой стереозрением и помещённой в мир кубиков, агент не получает от творца никакого списка «типов». Он воспринимает лишь поток многомерных мер — точек с координатами и цветом. Сознание, как процесс моделирования, начинает выделять в этом потоке устойчивые сгустки: группы точек, которые движутся как единое целое, сохраняют относительные расстояния, обладают инвариантными признаками. Через многократное наблюдение и взаимодействие эти сгустки закрепляются как категории — внутренние метки, соответствующие повторяющимся локальным выражениям комбинаторной системы. Так рождается «кубик» не как слово, вложенное извне, а как узнанный агентом паттерн бытия. Это и есть подлинный синтез объектов. Познание законов как восстановление имманентного синтаксиса Мир, согласно модели, управляется не внешними предписаниями, а внутренним синтаксисом, встроенным в саму природу элементов. Гравитация, инерция, равновесие — всё это не формулы, данные агенту, а способы взаимодействия, автоматически реализуемые средой. Агент же познаёт их не через чтение учебника, а через оперирование и сравнение. Он совершает действие — толкает, поднимает, ставит один кубик на другой — и предсказывает, используя свою внутреннюю модель, что произойдёт. Если предсказание расходится с реальностью (башня обрушилась, хотя модель ожидала устойчивости), возникает напряжение, которое запускает индуктивный поиск: какое именно условие систематически приводит к ошибке? Так из статистики рассогласований выкристаллизовывается явное правило, например: «центр масс должен находиться внутри опорного контура». Это правило не было зашито в программу — разум сам вывел его из бытия. Именно так, шаг за шагом, он восстанавливает объективный синтаксис системы. Целеполагание без внешнего законодателя В демонстрации цель была задана как конкретная конфигурация, и это тоже выглядит как «рояль». Но в полноценной архитектуре цели не спускаются сверху. У агента есть гомеостатические потребности — поддержание целостности носителя, энергетический баланс, а также более высокие напряжения, такие как стремление к уменьшению прогностической неопределённости (любопытство). Потребность — это не просто абстрактная «цель», а динамический вектор, уже содержащий в себе предпочтительные траектории разрешения. Когда агент обнаруживает, что устойчивая башня лучше предсказуема и, следовательно, снижает общее напряжение, строительство высокой конструкции перестаёт быть внешним заданием и становится собственным мотивом агента. Благо не предзадано, а вырастает из логики самоподдержания локальной моделирующей конфигурации. Что же остаётся от «рояля» В масштабированной версии не остаётся ничего. Программист (творец) даёт агенту лишь то, что не может быть создано самим агентом: комбинаторную среду (кубики, физический движок) и сенсорные каналы (стереозрение, тактильные датчики). Всё остальное — выделение объектов, открытие законов, постановка целей — есть прямой результат имманентной активности разума, который сам является частью этой же комбинаторной системы. Наш клеточный автомат был именно тем минимальным миром, в котором этот механизм можно было разглядеть без помех, словно в лабораторной пробирке. Но как только мы разбиваем пробирку и выпускаем агента в трёхмерный мир, он начинает строить себя сам — из того же синтаксиса, который управляет падением кубиков и распространением света. Приглашаю вместе исследовать, как в таком мире рождается подлинный синтез объектов, знаний и целенаправленного поведения. Ибо разум, согласно нашей модели, и есть локальное выражение комбинаторной системы, достигающее способности прочесть и применить её внутренний закон.

В минимальной демке мы сознательно использовали дискретный мир 3×3 и предопределённые символы — это позволило вычистить ядро: цикл «предсказал → сделал → сравнил → вывел правило». Теперь покажу, как то же самое ядро без изменений масштабируется на трёхмерный мир с кубиками и стереозрением, где никакого «рояля» нет. 1. Мир как тензор, а не как коллекция объектов Никаких классов Cube, Sphere, Arch. Вся сцена — единый тензор состояния State. В простейшем случае это воксельная сетка или облако точек. python # Глобальное состояние мира (может быть облаком точек или 3D-тензором) State = TypedDict('State', { 'points': Tensor[N, 6], # (x, y, z, r, g, b) или (x, y, z, nx, ny, nz) 'timestamp': float }) Все операции (физика, рендеринг) работают именно с этим тензором. Никаких отдельных объектов в памяти нет — только непрерывное поле. 2. Объекты как локальные дескрипторы, а не владельцы данных «Объект» — это временный указатель на область в State, который появляется, когда в поле возникает устойчивый сгусток материи. Он хранит не данные, а лишь способ их извлечь. python ObjectDescriptor = TypedDict('ObjectDescriptor', { 'id': int, 'center': Tuple[float, float, float], 'extent': Tuple[float, float, float], # размер bounding box 'orientation': Quaternion, 'features': Tensor[F], # эмбеддинг формы/цвета 'point_indices': List[int] # индексы точек в глобальном облаке }) Дескрипторы не владеют точками — они ссылаются на них. При изменении мира дескрипторы пересчитываются заново. Если конструкция развалилась, старые дескрипторы просто удаляются. Выделение объектов (без учителя): Берём облако точек с камеры (стереопара → Open3D point cloud). Убираем фон (RANSAC plane segmentation для стола). Кластеризуем оставшиеся точки по расстоянию (DBSCAN или евклидова кластеризация). Для каждого кластера вычисляем oriented bounding box, центр масс, эмбеддинг (через PointNet или простую статистику). Трекинг между кадрами: сопоставляем дескрипторы по IoU bounding box и близости эмбеддингов (венгерский алгоритм). python def extract_objects(cloud: Tensor[N,6]) -> List[ObjectDescriptor]: # cloud: точки в координатах камеры # 1. Фильтрация стола # 2. Кластеризация (DBSCAN eps=0.02, min_points=20) # 3. Для каждого кластера вычисляем дескриптор return descriptors Никаких имён «кубик» или «цилиндр» агент не получает. Он лишь знает, что obj_42 имеет такую-то форму, размер и цвет. Категория может появиться позже, когда несколько дескрипторов будут иметь близкие эмбеддинги — тогда агент создаст внутреннюю категорию «тип А» (прототип куба). 3. Отношения вычисляются функциями, а не хранятся в графе Вместо графа сцены — набор чистых функций, которые принимают State и ObjectDescriptor и возвращают булево значение или число. python def is_supporting(state: State, A: ObjectDescriptor, B: ObjectDescriptor) -> bool: # Проверяем, что: # - A и B находятся в контакте (расстояние между bounding box < eps) # - A выше B (A.center.z > B.center.z) # - Вектор нормали контакта направлен вверх contact_points = compute_contact(state, A, B) if not contact_points: return False return all(cp.normal.z > 0.9 for cp in contact_points) При изменении физики (магнетизм, жидкость) мы просто переписываем функцию compute_contact, и все «отношения» пересчитываются автоматически при следующем вызове. Никакой перестройки графа знаний. 4. Познание законов: обучение World Model + индукция правил Агент не получает уравнений физики. Он строит предсказательную модель мира и уточняет её при ошибках. World Model — это обучаемая функция predict(next_state | state, action). На старте это может быть простая графовая нейросеть или свёрточный автоэнкодер, обученный на истории взаимодействий. python class WorldModel(nn.Module): def forward(self, state_encoding: Tensor, action: Tensor) -> Tensor: # предсказывает encoding следующего состояния ... Обучение: Агент выполняет действие a (например, толкает кубик с определённой силой). Получает новое облако точек S'. Сравнивает с предсказанием модели S_pred. Вычисляет loss = MSE(S', S_pred) и обновляет модель. Индукция правил при систематических ошибках: Если модель стабильно ошибается в определённых ситуациях (например, башня падает, а модель предсказывала устойчивость), мы запускаем символьный поиск закономерности. Анализируем историю переходов, где ошибка велика, и ищем общий предикат: например, «центр масс верхнего объекта выходит за пределы опорного контура». Этот предикат формулируется как явное правило и добавляется в планировщик. python def check_stability(state, A, B): # Простейшая эвристика: проекция центра масс A должна лежать внутри опорной площади B com_2d = project_onto_plane(A.center, B.surface_normal) return point_in_polygon(com_2d, B.support_polygon) Агент не рождается с этим правилом — он выводит его из данных. 5. Цели не заданы извне, а вычисляются из потребностей Вместо внешней награды у агента есть вектор гомеостатических переменных (заряд батареи, целостность, «интерес»). Каждая переменная имеет целевой диапазон, и отклонение создаёт напряжение. python needs = { 'energy': Need(current=0.8, optimal=(0.3, 1.0)), 'curiosity': Need(current=0.2, optimal=(0.5, 1.0)) # желание исследовать } Напряжение curiosity может быть реализовано как ошибка предсказания модели: если модель хорошо предсказывает, curiosity низкий, агент «скучает» и ищет новые действия. Это естественно приводит к поведению «построить высокую башню», потому что сложная конструкция менее предсказуема и её исследование снижает curiosity. Целевое состояние для планировщика — не конкретная конфигурация, заданная программистом, а состояние с минимальным суммарным напряжением. Планировщик ищет последовательность действий, которая максимизирует ожидаемое снижение напряжения. 6. Планирование: проигрывание сценариев внутри World Model Планировщик использует обученную World Model как «песочницу». Алгоритм — Monte Carlo Tree Search (MCTS) с использованием предсказаний модели и оценщика напряжения. python def plan(initial_state, world_model, needs): root = Node(initial_state) for _ in range(iterations): leaf = tree_policy(root) simulated_state = leaf.state # симулируем случайные действия до горизонта for t in range(horizon): action = random_action() simulated_state = world_model(simulated_state, action) # оцениваем напряжение tension = evaluate_tension(simulated_state, needs) leaf.update(tension) # возвращаем действие с лучшим средним результатом return best_child(root).action При этом планировщик учитывает выведенные символьные правила: если действие приводит к нарушению check_stability, оно либо отбрасывается, либо получает штраф. Итоговый pipeline (стек технологий) Сенсоры: стереокамера (ZED, RealSense) → облако точек через Open3D. Физика: PyBullet или MuJoCo — среда сама вычисляет столкновения, гравитацию. Агент посылает команды в симулятор и получает новое облако точек. Выделение объектов: Open3D (segment_plane, dbscan), трекинг через венгерский алгоритм + ICP. World Model: PyTorch, вариант PointNet или графовой сети для предсказания облака точек. Индукция правил: sympy или пользовательский логический движок для поиска инвариантов. Планировщик: реализация MCTS, использующая World Model. Потребности: простой числовой массив, обновляемый по правилам. Ответ на возражение о «рояле» В полной системе программист не задаёт: список объектов (они выделяются кластеризацией), правила физики (они встроены в движок, но агент выводит их явно через индукцию), целевые конфигурации (они вычисляются из потребностей). Единственное, что дано агенту «творцом», — это комбинаторная среда (кубики, физика) и сенсоры. Всё остальное агент строит сам, используя то же ядро, что мы отладили на клеточном автомате. Поэтому архитектура масштабируется без «рояля», а демка была лишь прозрачным тестом этого ядра.