Эта идея — основа для понимания моей концепции интеллекта (саморазвивающейся программы). Если интересует создание саморазвивающейся программы, то эта идея не будет лишней. В начале описание идеи, потом описание реализации и описание некоторого дополнительного функционала.

Рассказал идею о создании логики программы динамически. Причём, эта логика не представлена чисто в виде инструкций языка программирования. Она работает на основе конструкций, которые работают на основе инструкций ЯП — это абстракции над ЯП, что-то типа ЯП более высокого уровня, чем python.

Введение

Логика — это определённый способ обработки информации, ход выполнения инструкций, программ, подпрограмм, условий и т. д. Можно сказать, что она является основой программирования. От того, как будет написана логика программы, зависит результат её работы. Логика может быть представлена разными способами, но иметь один и тот же смысл, при котором результат работы программы будет таким же или аналогичным. Или можно представить логику на другом языке программирования или в другом вычислительном виде. Результат изменится только от того, каким именно образом будет произведена обработка информации, т. е. от изменения логики.

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

Этот пример будет в стиле ООП. Это простая система консольного чат-бота, основанная на динамических переменных. Я называю эту концепцию «динамическая логика». Это лишь основы этой концепции, пока я в этом сам не особо разобрался, т. к. сложно представить создание логики «без кода». Это дискретная модель, т. е. без использования вычислений (математических моделей или нейронов).

Описание идеи

В основе команд лежат переменные. Они могут активироваться от ввода строки или от команды (от стимула).

Система команд работает на основе команд. К каждой команде сопоставляется булева переменная, т. е. у каждой команды есть своё состояние, которое отвечает, активна ли эта команда. Если команда активна, то она выполняется.

К каждой переменной команды (переменная 3) сопоставляется другая команда, переменная или блок кода (какие-то инструкции ЯП). При активации команды выполняются эти определённые инструкции ЯП или другая команда.

Каждая команда состоит из набора элементов. В данном случае в качестве элементов выступают слова (подстроки). У каждого слова есть своя булева переменная, которая отвечает за то, активно ли слово, т. е. было ли это слово введено в строке ввода. Если какой-то элемент команды присутствует (если есть сигнал), то его переменная активируется.

У каждой команды есть свой набор элементов. Если все элементы одновременно активны, т. е. были введены все слова данной команды (если были осуществлены все нужные стимулы), то эта команда активируется. После этого выполняется определённый код, который привязан к этой команде или выполняется другая команда.

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

Переменная

Этот тип переменной - булевый. Также можно сделать числовой или строковый. Но для этой реализации тут необходимо указывать булево значение (т. к. любое число или строка в python имеют булево значение True). Также сама логика системы не переводит введённые слова в какие-то типы данных, а сразу активирует переменные.

class Boolean:
    def __init__(self, name, variable_type, value, keywords_to_activate):
        self.name = name
        self.variable_type = variable_type
        self.value = value
        self.keywords_to_activate = keywords_to_activate

Тип переменной — это информация для программы, на основе этого выполняется определённое ветвление. При создании объекта класса можно сразу указать значение переменной: True или False. И список слов, по которым можно активировать данную переменную (сигналы активации), это то же самое, что показано в первой части материалов про систему команд, там для распознавания слова используется логистическая регрессия, только здесь происходит перебор, а не распознавание на основе вычислений (математической модели).

У этой переменной можно изменить значение через специальную команду: «название переменной» «значение». Например, «run false», эта команда изменит значение переменной run на значение False. Этот тип команд нужно сделать как-то более обобщённо, чтобы это сочеталось и с другими типами команд, но кроме этого варианта я ничего не придумал.

У каждой переменной есть её список триггеров — слова, на которые она активируется. Его можно изменять, дополнять или изменять уже имеющиеся триггеры. Также можно изменять саму команду или добавлять новую.

В конце пункта про команду-последовательность показано как выглядит команда для изменения значения переменной в виде динамической логики.

«Булевая» команда

Этот тип команд нужен для изменения значения булевой переменной. Это некие триггеры, которые если активируются, то выполняются какие-то другие команды.

# команда-триггер, триггерная команда
class BooleanCommand:
    def __init__(self, variable, variable_to_process, command_type, command, is_allowed=False):
        self.variable = variable
        self.variable_to_process = variable_to_process
        self.type = command_type
        self.command = command
        self.is_allowed = is_allowed

Передаётся объект булевой переменной variable, если эта переменная будет активна, то выполнится триггерная команда, которая привязана к этой переменной variable. Тут ещё есть тип переменной, который отвечает за то, какая логика будет выполняться на основе этой переменной (ветвление). Также добавлена логика в виде разрешения на выполнение команды is_allowed.

Тип команды может быть sys_command или user_command. Их можно делать любые. Системные выглядят как «run false», т. е. переменная run будет установлена в значение False, либо можно будет узнать значение переменной, если ввести только «run».

Для пользовательского типа команд я ничего не реализовал, но что-то добавить будет не сложно. Этот тип команды позволяет выполнять какие-то команды или активировать какие-то переменные самой системой. Т. е., если активируется какой-то триггер, то будут активированные какие-то переменные (или команды), а далее начнёт выполняться какая-то логика, которая привязана к активации этих переменных. Получается что-то в роде возможности для создания любой логики.

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

Команда-последовательность

class SequenceCommand:
    def __init__(self, sequences_to_activate_command, variable_to_process):
        self.sequences_to_activate_command = sequences_to_activate_command
        self.variable_to_process = variable_to_process

Это группа переменных-слов. Если ввести несколько слов, то активируется команда, у которой есть введённый набор слов. В качестве последовательности sequences_to_activate_command выступает список переменных типа Boolean. Если все переменные из одного списка одновременной активны, значит была введена эта команда, значит нужно активировать переменную этой команды. Переменная этой команды передаётся через переменную variable_to_process, она тоже типа Boolean.

Теперь про то, как можно создавать логику динамически. В предыдущем пункте было сказано про другой тип команд. С помощью того типа команд можно изменять значение переменной, например, «run false». После того, как в системе будет создана эта команда, её можно привязать к другой команде, в частности, к команде-последовательности. В этом типе команд можно создавать текстовый вид команды, в виде последовательности слов. Получается, что можно динамически создать эти два типа команды для изменения какой-то переменной, а потом связать их, таким образом мы можем создавать логику динамически, на основе имеющегося в программе кода и не дописывать новый код.

В коде это выглядит так.

SequenceCommand(
	sequences_to_activate_command=[
		[vs["run"], vs["0"]],
	],
	variable_to_process=self.variables["run_to_false"]
)

vs это объект класса, в котором реализован метод "__getitem__", он вызывается оператором «[]» - получение элемента по ключу. Этот метод проверяет наличие переменной по её названию и возвращает объект переменной типа Boolean.

Можно привязать изменение переменной к любой последовательности слов (подстрок), в данном случае это «run» и «0». Мы привязали эту команду к переменной run_to_false. Когда будет введена команда «run 0», то переменная run_to_false активируется и выполнится другая команда, которая изменяет значение этой переменной. К переменной в другом месте программы run_to_false привязан объект типа BoleanCommand, когда run_to_false активируется, то выполнится команда из объекта типа BoleanCommand, эта команда изменит значение другой переменной.

Дополнительная логика в данном примере

Это всё обёрнуто в классы и различные методы, которые занимаются обработкой переменных, команд и различной логики. В главном цикле осуществляется ввод через input и далее всё проверяется и выполняется.

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

Команда «команда не распознана» выполняется автоматически, если введённая команда не распознана. Т. е. переменная команды «команда не распознана» изначально активна, если какая-то команда активируется, то переменная «команда не распознана» становится неактивной.

Добавлена возможность разрешения или запрета на выполнение команды. Если разрешения на выполнение нет, то система команду не выполнит. Это реализовано в виде чистого кода, по идее, это так же должно быть реализовано в виде команд, возможно, в виде другого типа команд, чтобы можно было это изменять динамически.

В идеале, команда (или понятие) is_allowed должна появляться в системе в виде команды и автоматически привязываться к командам, через переменные. В коде есть ветвление, в котором проверяется тип команды, если её тип пользовательский, то активируются переменные, которые привязаны к этой команде. Таким образом, можно динамически добавить логику в программу через разные типы команд.

В некоторых местах расставлены raise Exception, они будут вызываться если возникает какая-то ошибка или у системы нет подходящих инструкций для выполнения. Такие ошибки так же должны обрабатываться командами, а не чистым кодом. Таким образом можно будет динамически настраивать различные моменты, в которых у системы нет нужных команд действий. Основная идея же состоит в том, что, если система обладает интеллектом, то она сможет создавать нужные команды для таких случаев самостоятельно, никаких ошибок возникать не будет, вся логика будет создаваться и дополняться системой.

Весь код рассматривать не буду. В телеграме будут скрины всего кода и сам код — можете изучить детали.

Заключение

В этом материале мы рассмотрели основы идеи о том, как в программе может создаваться логика её работы динамически, без добавления новых инструкций ЯП.

Может показаться, что это какой-то бред, что это глупо. Что проще сразу сделать проверку введённой строки ветвлением, ещё и подкрутить какую-нибудь классификацию. Но в этом и заключается смысл создания логики динамически. Для её создания нужны подобные конструкции с различными привязками и обозначениями одного через другое. Динамическая логика — это основа для создания саморазвивающейся программы.

Как можно использовать описанную идею про систему команд. Через строку ввода можно создавать команды разных типов, сохранять их в памяти (память программы или память системы), а потом их связывать. И, если система будет обладать некоторой базовой логикой и нужными механизмами, то она сможет создавать и соединять эти команды сама. В этом заключается основная идея создания системы динамической логики (система команд != система динамической логики).

Строка ввода — это среда, от которой система получает какую-то информацию, поэтому вместо текста может быть любая другая информация.

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

Далее будут более интересные идеи и их объединение в виде теории цифрового интеллекта. Канал в телеграме. Страничка проекта.