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