Приветствую. Здесь я приведу пример реализации простейшей функциональной системы на python, подробно опишу как в этом примере все работает и расскажу некоторые идеи о том, как можно развивать этот подход.
Меня зовут Алмаз Хустнутдинов. Я занимаюсь проектом «Теория цифрового интеллекта», создаю различные материалы по машинному обучению и рассказываю идеи о цифровом интеллекте, цель проекта — развитие мышления в области создания СИИ.
Введение
Функциональная система (ФС) — система, состоящая из нескольких основных элементов, которые задают целенаправленность в решении конкретной задачи. Это одна из основных идей в нейрофизиологии, объясняющих целенаправленность деятельности организмов.
Система — более общее понятие, чем понятие агента, это что-то единое целое, что обладает различными аспектами: способность к восприятию, способность выполнять действия, способность выполнять какие-то внутренние процессы и так далее. Понятие агента я понимаю более узко, как некую «личность», которая способна выполнять какие-то действия по каким-то правилам, но при этом, такие аспекты как восприятие (физическое) или выполнение действий (физических) к ней не относятся.
Среда — окружающая среда, с которой может взаимодействовать система.
В этом материале мы разберем простейшую функциональную систему. Модели системы и среды — табличные, все данные и действия — дискретные.
Основные аспекты функциональной системы:
Полезная приспособительная реакция (ППР);
Афферентный синтез возможных решений;
Принятие решения;
Формирование акцептора результата (предсказание результата решения);
Эфферентное возбуждение (выполнение действия);
Обратная афферентация (получение реакции среды или результата действия);
Сравнение результата действия и акцептора результата;
Коррекция (изменение работы ФС, обучение).
В простейшей ФС, я полагаю, нет некоторых элементов: ППР, акцептор, сравнение. Это из-за того, что она решает простейшую задачу, у которой не может быть акцептора, так как это не имеет смысла. Вместо акцептора в системе должен быть реализован базовый механизм «подкрепления», который автоматически получает результат реакции среды на действие системы (или на определенное состояние среды). Для решения более сложных задач акцептор будет нужен, но для этой задачи в нем нет смысла. ППР — это итоговое назначение ФС — решать определенную задачу. А сравнение — это индикатор окончания работы ФС, если предсказанный результат действия совпадает с реальным результатом.
Описание задачи
Есть простая среда, в которой система должна научиться выполнять какие-то действия для поддержания своего базового параметра. У системы должны быть реализованы некоторые базовые механизмы, на основе которых она сможет совершать какую-то деятельность. Идея в том, что система может взаимодействовать со средой на основе доступных ей действий и реализованной логики, а среда может воздействовать на систему, тем самым влияя на ее состояние. Совершая различные действия система может обучаться выполнять заданную задачу — поддерживать базовый параметр в нормальном состоянии.
Система может выполнять одно из 10 действий. Среда может реагировать на действия системы 10 разными способами, в зависимости от действия системы. Когда система совершает действие «1», то ничего не происходит, среда никак не реагирует. Когда система совершает действие «3», то среда реагирует на это действие неким воздействием на систему. Из-за этого воздействия у системы изменяется базовый параметр и включается индикатор, что этот параметр изменился. Если этот параметр изменяется, то система генерирует подкрепление на основе измененного значения базового параметра.
Также нужно понимать, что базовые механизмы должны работать автоматически. Если механизмы работают более сложно, чем просто автоматическое выполнение статической логики, то, по моей теории (на данный момент), такие механизмы относятся к когнитивному уровню системы, такие механизмы должны быть устроены намного сложнее, чем базовые. Здесь приведен очень простой пример с очень простой средой и системой, но несмотря на это, вся программа устроена довольно сложно — это отражает сложность того, как должны быть устроены базовые механизмы. Если усложнить среду и систему, то, по идее, сложность программы не должна увеличиться слишком сильно и должна быть сопоставима с этим простым примером. Но, если переходить к когнитивному уровню, то сложность программы резко увеличится — но это лишь предположение (и это лишь табличная модель без использования нейронов).
После того, как система научится решать одну задачу, можно усложнить среду, чтобы система могла развиваться и учиться выполнять новые задачи. Таким образом у системы будут формироваться различные знания, которые она может использовать для решения все более сложных задач — таким образом происходит эволюционное развитие организмов: усложнение среды — появление новых способностей.
Среда
Среда является подсистемой в программе, а агент — это тоже подсистема, бот. Среда очень простая и выполняет всего лишь одну функцию, возвращает агенту небольшое вознаграждение за определенные действия.
Все переменные имеют тип list — это изменяемый тип объекта в python, так можно обращаться к одной и той же переменной из разных областей видимости. Несмотря на то, что эти объекты объявляются глобально, они не могут использоваться внутри процедур или других подпрограмм (без использования оператора global), так как в python какая-то проблема с областью видимости.
env_reactions = [i for i in range(10)]
env_reaction = [None]
influence_to_env = [None]У среды может быть определенное количество возможных реакций на действия агента, в этом примере в качестве реакций выступают просто числа от 0 до 9. Список реакций среды назван env_reactions.
Когда агент совершает какое-то действие, то среда получает от агента некое воздействие — влияние агента на среду. Это влияние просто обозначается числом от 0 до 9 — возможные действия агента. Эта переменная названа influence_to_env — влияние на среду.
После того, как среда получает действие агента, она генерирует свою реакцию на это действие. Реакция среды хранится в переменной env_reaction.
def env_update():
if influence_to_env[0] == 3:
env_reaction[0] = choice([0.2, 0.3, 0.4, 0.5])В процедуре env_update происходит обработка среды — это как метод update в играх, в котором происходит обработка всех объектов в игре на текущей сцене, в которой находится игрок. Если агент выполнит действие «3», то реакция среды — одно из значений в списке [0.2, 0.3, 0.4, 0.5]. Эта некая награда, которую агент должен собирать — его задача поддерживать значение этой награды ниже значения 0.5, оно повышается каждый тик симуляции. В данном примере частота обновления среды — 1 тик в секунду. Обычно изменения переменных вычисляются на основе изменения времени delta_time, а не на основе числа тиков, так как их число зависит от производительности компьютера и числа обрабатываемых объектов. Это лишь учебный пример, в котором в этом нет необходимости.
Скрытый текст
# action = input("Enter an action (1-10): ")
# action = int(action)
action = choice(env_reactions)
influence_to_env[0] = action
env_update()
influence_to_env[0] = None
reaction = env_reaction[0]
env_reaction[0] = NoneДалее, в бесконечном цикле while, происходит обработка всех объектов, которые участвуют в работе среды и других объектов программы.
Происходит случайный выбор действия, так как действие должно выбираться на основе работы ФС, здесь просто показана заглушка. Также действия можно вводить через текстовый ввод input.
Далее среда получает действие, которое было «выполнено».
Далее происходит обработка объектов самой среды в процедуре env_update. Если будет выбрано случайное действие action со значением «3», то в переменную env_reaction будет записано значение награды для агента.
Далее мы можем получить это значение в переменной env_reaction и как-то его использовать в логике работы системы (агента).
Затем зануляем переменные значением None, чтобы случайно не считывать их несколько раз. Для импульсных нейронов аналогом этого зануления является передача сигналов по синапсам или по нейропутям. Когда сигнал проходит по синапсу, то постсинаптический нейрон может получить значение потенциала с данного синапса только один раз за импульс пресинаптического нейрона.
Система
Логика работы системы аналогична. Нужно создать различные переменные, которые система будет использовать при своей работе. Создать процедуры, которые будут выполняться в общем бесконечном цикле while вместе со средой и ФС. Весь код комментировать не буду, ибо его достаточно много, и к тому же по названию переменных ± все должно быть понятно.
Скрытый текст
actions = [i for i in range(10)]
need_value = [0.35]
need_thr = [0.5]
need_motiv = [False]
decision = [None]
success = [False]
memory = dict() # expirienceСоздаем (объявляем) доступные действия системы. Создаем различные базовые переменные. В основе работы этой системы лежит базовый параметр need — нужда. У него есть различные характеристики: значение (value), порог активации (thr, от слова threshold) и индикатор того, что этот параметр системы является активным (motiv, от слова motivation).
Далее можно создавать различные переменные, структуры, функции, процедуры и так далее, все, что захотите.
В переменной decision будет храниться выбранное системой действие. В success — было ли выполненное действие успешным, то есть получила ли система за выполнение этого действия награду. В memory хранится информация об успешности различных действий, некая политика поведения — отображение действия в его ценность.
Скрытый текст
def need_update():
need_value[0] += 0.02
def update_need_motiv():
if need_value[0] > need_thr[0]:
need_motiv[0] = True
else:
need_motiv[0] = False
def make_action():
if need_motiv[0]:
action = choice(actions)
decision[0] = actionВ процедуре need_update происходит обновление переменной need_vale каждый тик симуляции. В update_need_motiv — активация или выключение индикатора того, что параметр need находится в активном состоянии. Если он активный, то система должна выполнять действия, чтобы вернуть его в нормальное состояние, то есть ниже порога 0.5. В make_action — выбирается случайное действие.
В других процедурах происходит добавление и изменение memory, некое обучение. А потом все эти процедуры выполняются в цикле while, просто происходит симуляция работы системы. Здесь просто показаны заглушки, ведь действия должна выбирать ФС.
Функциональная система
Задача ФС в этом примере — поддерживать базовый параметр need в нормальном состоянии — его значение должно быть ниже порога в 0.5.
ФС состоит из: афферентный синтез возможных решений; принятие одного из возможных решений; получение обратной афферентации, то есть награды за выполненное действие; коррекция, некое обучение системы (агента).
Скрытый текст
random_decision_thr = [2]
selected_actions = list()
decision = [None]
env_reaction_influence = [None] # влияние реакции среды
reaction_accepted = [False]
back_afferentation = [None]
success = [False]
failure = [False]Для работы ФС понадобится очень много всяких переменных, каждая из которых отвечает за какой-то небольшой шаг работы ФС. Эти все переменные — некие буферы, которые хранят различную информацию для работы каждой части ФС.
random_decision_thr — порог случайного выбора действия, генерируется число от 0 до 9, если это число выше порога, то выбирается действие с большим весом, иначе — случайное действие.
selected_actions — список случайных действий и одно с самым большим весом.
decision — хранит выбранное действие.
env_reaction_influence — хранит значение награды, которую сгенерировала среда в ответ на действие системы (реакция среды, влияние реакции среды на систему).
reaction_accepted — совершила ли среда какую-то реакцию в ответ на действие системы или нет.
back_afferentation — хранит значение полученной награды за выполненное действие.
success, failure — успешное или неудачное выполнение действия, то есть получила ли система награду за выполненное действие или нет.
Скрытый текст
def aff_synthesis():
for _ in range(2):
action = choice(actions)
selected_actions.append(action)
if len(memory.keys()) > 0:
best_action_idx = argmax(list(memory.values()))
best_action = list(memory.keys())[best_action_idx]
selected_actions.append(best_action)Афферентный синтез. Здесь происходит синтез возможных действий, которые могут привести к решению задачи. В самом простом виде — выбор случайных физически возможных действий. Затем выбирается одно наилучшее из изученных действий.
Скрытый текст
def make_decision():
decision[0] = choice(selected_actions)
if randint(0, 9) > random_decision_thr[0]:
best_action_idx = argmax(selected_actions)
decision[0] = selected_actions[best_action_idx]
if decision[0] not in memory:
memory[decision[0]] = 0Выбор действия (решения). Сначала выбирается случайное действие. Если порог случайного выбора не выполняется, то выбирается лучшее действие, иначе остается случайное действие. Если действие выполняется впервые, то в память добавляется поле для этого действия.
def execute_action():
if decision[0] == 3:
env_reaction_influence[0] = choice([0.2, 0.3, 0.4, 0.5])
reaction_accepted[0] = TrueЭмуляция выполнения действия в среде. Среда «генерирует» награду, если было «выполнено» действие «3». Активируется индикатор того, что была получена награда (средой выло произведено воздействие на систему).
def update_need_value():
if reaction_accepted[0]:
need_value[0] -= env_reaction_influence[0]Базовый механизм подкрепления. Если была получена награда от среды (реакция среды), то значение базового параметра need изменяется в положительную сторону. А во время симуляции этот параметр постепенно изменяется в отрицательную сторону.
Скрытый текст
def update_back_afferentation(): # БУ афферентации
if reaction_accepted[0]:
success[0] = True
back_afferentation[0] = env_reaction_influence[0]
else:
failure[0] = True
back_afferentation[0] = 0Обратная афферентация. ФС получает значение награды (собирает информацию о результате действия системы). Это базовый уровень (БУ) обратной афферентации, то есть самый минимально возможный способ получения (или генерации) системой информации о результате действия. В качестве примера можно рассмотреть дофамин, который генерируется организмом автоматически — самый минимально возможный способ получения подкрепления. В мозге есть нейронные структуры, которые активируются, когда происходит генерация дофамина — это индикатор получения награды.
def correction(): # learning
if success[0]:
memory[decision[0]] += back_afferentation[0]
if failure[0]:
memory[decision[0]] -= back_afferentation[0]Коррекция. Это некое обучение системы (коррекция работы ФС). Цель ФС — решать определенную задачу, подбор решения будет происходить постепенно, на основе корректирования или получения различных переменных (знаний). Если успех (генерация дофамина), то действие закрепляется как полезное. Если неуспех (генерация норадреналина, если не ошибаюсь), то действие закрепляется как негативное.
Далее в цикле while происходит симуляция работы ФС, выполняются различные процедуры в определенной последовательности — это обязательно, ведь эта программа не может работать асинхронно.
Полный пример
Теперь рассмотрим все вместе.
Скрытый текст
env_reactions = {i: [0] for i in range(10)} # 10 - количество действий
env_reactions[3] = [0.2, 0.3, 0.4, 0.5]
env_reactions[7] = [0.2, 0.3]
env_data = {
"env_to_sys_influence": [0],
"sys_to_env_action": [-1],
"env_inf_done": [False],
}Определение объектов среды. У среды будет 10 возможных реакций на соответствующие действия системы. Для действий «3» и «7» задаем генерацию награды. Данные среды определяем в виде словаря env_data. env_to_sys_influence — реакция среды на действие системы, sys_to_env_action — действие системы, которое направлено на среду, env_inf_done — среда получила действие системы и сгенерировала свою реакцию (или не сгенерировала).
Скрытый текст
def env_update():
sys_action = env_data["sys_to_env_action"][0]
env_data["sys_to_env_action"][0] = -1
if sys_action not in env_reactions:
return
env_reaction = env_reactions[sys_action]
env_influence = choice(env_reaction)
env_data["env_to_sys_influence"][0] = env_influence
env_data["env_inf_done"][0] = TrueОбработка среды. Получаем действие sys_action, которое выполнила система, зануляем этот буфер, чтобы случайно не использовать повторно.
Если в списке доступных реакций среды нет такого действия, то среда никак не реагирует.
Генерируем награду за данное действие, записываем ее в переменную env_to_sys_influence и включаем индикатор того, что среда передала награду системе env_inf_done.
Скрытый текст
actions = [i for i in range(10)]
sys_data = {
"need_value": [0.35],
"need_thr": [0.5],
"need_motiv": [False],
"env_to_sys_influence": env_data["env_to_sys_influence"],
"env_influence_accepted": env_data["env_inf_done"],
"decision": [-1],
}
system_memory = dict() # expirienceОпределяем доступные действия для системы. Базовый параметр, сгенерированная средой награда, индикатор того, что награда была сгенерирована, выбранное решение. На информацию о среде ссылаемся на соответствующие списки — за счет того, что список — это изменяемый объект, поэтому в словаре sys_data и env_data будут считываться одни и те же переменные env_data["env_to_sys_influence"] и env_data["env_inf_done"].
Далее процедура, которая обновляет значение базового параметра каждый тик симуляции: update_need_value.
update_need_motiv — обновляет переменнуд need_motiv.
def make_action():
if sys_data["decision"][0] > -1:
env_data["sys_to_env_action"][0] = sys_data["decision"][0]Сделать действие. Здесь происходит эмуляция выполнения действия. Информация о выбранном действии записывается в переменную sys_to_env_action, которую может считывать среда. После того, как среда считает эту переменную, среда сгенерирует награду.
def accept_need_value():
if sys_data["env_influence_accepted"][0]:
sys_data["need_value"][0] -= sys_data["env_to_sys_influence"][0]Принять значение базового параметра. Здесь происходит эмуляция получения подкрепления, если среда сгенерировала награду, то эта информация считывается из переменной env_to_sys_influence и происходит изменение переменной need_value.
Скрытый текст
fs_data = {
"need_value": sys_data["need_value"],
"need_thr": sys_data["need_thr"],
"need_motiv": sys_data["need_motiv"],
"rand_decision_thr": [2],
"env_to_sys_influence": sys_data["env_to_sys_influence"],
"env_influence_accepted": sys_data["env_influence_accepted"],
"decision": sys_data["decision"],
"selected_actions": list(),
"back_afferentation": [0],
"success": [False],
"failure": [False],
}Определение переменных для работы ФС. Все необходимые данные о системе ФС будет брать у нее. ФС является частью системы, но они должны быть разделены логически, чтобы все было понятно и очевидно — иначе работать с большим количеством различной логики будет невозможно. Разные структуры ссылаются на одни и те же списки, так они могут использовать информацию совместно, при этом работая по разной логике.
Процедуры синтеза и принятия решения такие же.
Скрытый текст
def get_back_afferentation(): # афферентация базового уровня
if fs_data["need_motiv"][0] is False:
return
if fs_data["env_influence_accepted"][0]:
fs_data["success"][0] = True
fs_data["env_influence_accepted"][0] = False
else:
fs_data["failure"][0] = True
# базовый механизм получения обратной афферентации
fs_data["back_afferentation"][0] = fs_data["env_to_sys_influence"][0]
fs_data["env_to_sys_influence"][0] = 0Обратная афферентация. Если индикатор need_motiv не активен, то это значит, что ФС в данный момент не работает, значит эта логика не должна выполняться. Если среда передала системе награду, то это успех, иначе — неуспех, также отключается переменная, что была получена награда, чтобы далее не работала логика, которая зависит от этой переменной.
Базовый механизм получения обратной афферентации — активация в системе определенного индикатора в ответ на влияние среды на систему. Это просто эмуляция. Например, это может быть некая классификация на какие-то входные данные. Когда на рецепторы поступает определенная информация, то в системе активируется механизм, который классифицирует эти входные данные как подкрепление, начинает осуществляться генерация подкрепления.
Скрытый текст
def correction(): # learning
sys_action = fs_data["decision"][0]
fs_data["decision"][0] = -1
if fs_data["success"][0]:
system_memory[sys_action] += fs_data["back_afferentation"][0]
fs_data["success"][0] = False
if fs_data["failure"][0]:
system_memory[sys_action] -= fs_data["back_afferentation"][0]
fs_data["failure"][0] = False
fs_data["back_afferentation"][0] = 0На основе информации, которая появляется в системе после обратной афферентации, происходит коррекция знаний системы. Если награда получена, то вес выполненного действия увеличивается, иначе — уменьшается. Но это лишь простейший пример, обучения таким образом — это не совсем корректно.
Скрытый текст
update_need_value()
update_need_motiv()
aff_synthesis()
make_decision()
update_system_memory()
make_action()
env_update()
accept_need_value()
get_back_afferentation()
correction()
print(f"Need Value: {fs_data['need_value'][0]}")
print(f"motiv: {fs_data['need_motiv'][0]}")
print(system_memory); print()
sleep(0.25)В цикле while обрабатываем все процедуры в определенной последовательности — так как они не работают асинхронно. Sleep нужно вызвать, чтобы не завис процесс, который обрабатывает программу python и нам не нужно много выходных данных для анализа работы программы.
После активации «мотивации» начинается работа ФС. Она работает только тогда, когда выполняется условие работы этой логики. Такая схема похожа на цикл с условием, когда логика в теле цикла выполняется до тех пор, пока не изменится условие цикла.
Значение параметра need постепенно увеличивается, когда оно будет больше 0.5, то активируется «мотивация». После этого начнет работать ФС, которая будет генерировать действия и выполнять их. Постепенно у действий «3» и «7» начнет увеличиваться вес, тогда они будут выбираться почти всегда и значение параметра need будет всегда близко к значению 0.5.
Как все должно работать
Здесь в качестве среды выступает небольшая программа, которая возвращает определенное число на определенные значения действий. В качестве среды может выступать все, с чем может взаимодействовать система.
Взаимодействуя со средой, система должна формировать знания и представления о среде. После того, как они начнут формироваться, система может начать учиться выполнять какие-то действия. После того, как она начнет формировать какие-то знания о своих действиях, она может начать ставить какие-то небольшие цели и пытаться их достигать (метод проб и ошибок), и так далее. Все должно происходить постепенно.
В этом примере система не может получать какую-либо информацию о среде, так как ее просто нет — среда состоит лишь из нескольких значений. Поэтому система сразу начинает пробовать доступные ей действия — это она делает за счет статически созданной ФС. Пробуя различные действия, она постепенно получает знания о том, какие результаты приносят ее действия — таким образом система обучается в этой простейшей среде.
Система состоит из различных компонентов, параметров, функций, процедур, структур и так далее. ФС — одна из структур системы, таких структур в системе может быть много и они могут образовываться динамически — это ключ к созданию СИИ.
ФС является частью системы, но система не является частью ФС. По идее, система должна быть способна работать и без ФС — тогда это будут просто случайные процессы, без всякой целенаправленности.
Здесь у системы есть базовый параметр need, у которого есть несколько полей: значение, порог активации и индикатор об активности (мотивация). Слово «базовый» означает, что он присутствует в системе изначально. Если в системе появляется параметр во время ее работы, то он уже не будет базовым (пока я думаю, что такие параметры должны относиться к когнитивному уровню). Постепенно значение этого параметра увеличивается. После достижения порога активируется индикатор, который сигнализирует системе о том, что необходимо предпринимать какие-то действия, осуществлять какие-то процессы. Активируется ФС и начинает свою работу, либо, если в системе нет ФС, то она должна инициировать создание новой ФС, которая будет решать данную задачу.
Этот индикатор я рассматриваю как мотивацию (в материале про ФС про это будет сказано). Когда появляется мотивация, то в системе начинает работать ФС (или должна появиться новая ФС), цель которой — сделать что-то, что приведет к выключению этой мотивации. Это что-то — совершение определенных действий. Но каких действий? - В системе изначально об этом информации нет, поэтому она сначала совершает случайные действия, а потом начинает выбирать наиболее удачные.
Это похоже на Q-таблицу метода обучения с подкреплением «Q-learning», даже, почти то же самое. Отличие в том, что в Q-learning есть определенная формула для изменения весов действий на основе награды, а здесь изменение происходит прибавлением или вычитанием небольшого значения. И награда в Q-learning генерируется средой, а не агентом. А в этом подходе награду должна генерировать сама система за счет базовых механизмов, но эта среда не обладает какими-либо данными, поэтому система не может сгенерировать награду самостоятельно на основе данных из среды, поэтому здесь генерация награды происходит средой в качестве ее реакции.
У системы есть структура memory, в которой хранятся веса каждого действия. Это не единственно возможная структура, они могут быть любыми и могут хранить любые знания. Эти знания могут быть использованы во время синтеза решений. Подбором или перебором различных подходящих знаний для выполнения какого-то определенного действия, для решения какой-то небольшой задачи. Но знаний в системе будет очень много, поэтому перебор или подбор — слишком долго, нужно делать это как-то очень быстро. Но как? - Ассоциации.
Одним из важнейших механизмов или структур является ассоциативная память, грубо говоря это просто связи между элементами знаний. Она позволяет на этапе синтеза получать ассоциации различных знаний. В самом простом виде ассоциативную память можно представить как ассоциативный массив — два массива с одинаковой длиной. Элементы первого массива — ключи, а второго — значения. В качестве ключей или значений может быть список различных элементов, а может и одновременно, чтобы ключи и значения были списками элементов знаний.
Информация о среде должна поступать на рецепторные структуры. Например, это может быть небольшое поле зрения в виде сектора круга вокруг агента для двумерной среды. Постепенно в системе должны появляться знания о входной информации. Взаимодействуя со средой будут появляться знания об объектах среды и о их влиянии на систему.
Все это должно происходить на основе различных базовых механизмов и формирования новых ФС для решения новых задач, чтобы система могла развиваться и увеличивать свою эффективность нахождения в среде.
Заключение
В этом материале мы рассмотрели простейшую функциональную систему, задача которой — поддерживать базовый параметр системы в нормальном значении. Про то, что такое ФС и про их отдельные аспекты будут отдельные материалы.
Мы рассмотрели как эта идея должна работать и как ее можно развивать. Возможно, это одна из ключевых идей. Также эта идея очень хорошо объединяет различные представления о создании системы ИИ, так как обычно в системе ИИ должны присутствовать все аспекты функциональной системы.
Можно добавить асинхронность, но для этого придется сильно усложнить логику, добавить много дополнительных условий. Асинхронность позволяет программе одновременно (физически или логически) обрабатывать различную логику, но, возможно, она не является одним из свойств системы, в которой возможно появление интеллекта. Ведь интеллект — это способность развиваться и решать новые задачи, а не то, как работает система в принципе.
Это лишь самый простейший пример того, как могут работать функциональные системы. Здесь ФС задана статически — это значит, что она относится к базовому уровню системы, присутствует в ней изначально. В организмах такие ФС формируются изначально в процессе биологического развития, на основе выраженности генов в различных клетках и структурах нервной системы.
По идее, кроме базовых ФС, в системе должны появляться новые ФС динамически для решения новых задач (ведь передавать все знания предков через гены — невозможно, тем более они формируются в процессе жизнедеятельности, а не во время формирования организма). Кроме того, это лишь табличная модель, но на ее основе можно обучаться и строить теорию, а затем применять выведенные принципы на системы на основе нейронов.
Канал сообщества в телеграме.
Страничка проекта «Теория цифрового интеллекта» (содержание). Цель проекта — развитие мышления в области создания СИИ. Приглашаю в сообщество.
