Первые шаги

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

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

Заходим на страницу авторизации и попробуем ввести логин:

форма авторизации.

Получим ошибку про неправильный логин.

получили ошибку.

И это радует.

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

F12 спешит на помощь

Автоматизируем подбор логина, используя только средства разработчика в Firefox.

На текущей странице нужно:

1. нажать f12,
2. открыть вкладку «Сеть»,
3. далее ввести какие-либо данные в поля логина и пароля,
4. нажать «login»,
5. и во вкладке «Сеть» отобразятся все запросы, которые были отправлены со страницы.

вкладка сеть и запросы.

Нам нужно найти POST запрос со статусом 200 и ключевым словом login.

1. Клик правой кнопкой мыши по строке с данным запросом вызовет контекстное меню.
2. Выбираем "Использовать как fetch в консоли" (запрос будет скопирован в буфер и появится во вкладке ниже)

скопировали запрос в консоль.

Это и есть наш POST запрос, в котором указаны username=1 password=2.
Модифицируем этот код так, чтобы вместо параметра username подставлялось значение из списка логинов.

Подготовка к bruteforce

1. Подготовим массив с логинами:

готовим массивы с данными в js.

Добавим цикл перебора логина. Логин будем подставлять прямо в запросе:

модифицируем запрос.

Скопируем этот код и вернёмся в Firefox..

2. Использование консоли и вкладки "Сеть" в FF

Этот модифицированный скрипт и вставим в консоль на странице с формой и жмакнем enter, чтобы запустить цикл:

запускаем цикл отправки запросов.

Далее Перейдём на вкладку «Сеть» - здесь куча POST запросов со статусом 200 это и есть перебор логинов.

все отправленные со страницы запросы.

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

Об этом будет свидетельствовать изменение ошибки на «Incorrect password».

В текущем случае - это пользователь af, так как теперь на странице выводится ошибка, что пароль не верный.

3. Теперь подберём пароль.

В коде с циклом пропишем логин пользователя, раз мы его уже нашли, а бежать мы теперь будем по массиву паролей (который составлен аналогично usernames):

подставим найденный логин в запрос и переберем пароли.

Отправка запросов

Этот модифицированный скрипт опять вставим в консоль на странице с формой:

В ответах на вкладке «Сеть» теперь будем искать POST запрос со статусом 302: под ним и будет нужный пароль. В текущем случае пароль mustang.

ищем запрос с редиректом на профиль.

Итак, логин и пароль подобраны и для этого на не понадобилось никакое специальное ПО.

картинка с котиками

Оригинальный адрес статьи: http://inclab.ru/articles/podbor-logina-i-parolya-pereborom

]]> Sat, 13 Apr 2024 23:48:27 +0400 http://inclab.ru/articles/min-element-v-matrice http://inclab.ru/articles/min-element-v-matrice Поиск минимального элемента в строке матрицы

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

А встроенные полезные функции для работы с матрицами описаны в этом материале, а линейной алгебры - в этом.

Постановка задачи

Сформировать матрицу \( M(7,5) \) по правилу \( M(i, j) = cos(i^2 - \frac{j}{2}) \). Определить наименьший элемент в каждой строке матрицы и записать его в соответствующий элемент вектора \( V \). Вывести на экран сформированную матрицу и полученный вектор \(V \), сравнить результат со встроенной функцией.

Приступим к работе

Создадим заглушку функции, которая будет генерировать элементы матрицы по заданному правилу:

Создадим заглушку функции, которая будет искать минимальный элемент в каждой строке матрицы и формировать вектор:

Генерируем матрицу

Создавать матрицу по заданному правилу будем построчно во вложенном цикле:

Ищем заданный элемент в строке

Разобьем поиск заданного элемента в строке матрицы на два процесса: раздел матрицы по строкам в цикле \(for\) и сам поиск элемента в функции \(findMinInRow\). (Так будет удобно модифицировать функцию поиска элемента с наименьшего на наибольший, например).
Результат запишем в вектор \(mVector\).

Пройдёмся по строкам матрицы:

Искать наименьший элемент в строке матрицы будем перебором.

В переданной строке \(curRow\), примем, что первый элемент \(curRow(1)\) - есть искомый \(curMinElement\).
Далее, пробегая строку, т.е. увеличивая номер столбца, будем сравнивать текущий элемент \(curRow(j)\) с "минимальным" \(curMinElement\). Если найденный будет меньше минимального - обновим минимальный.

Код пользовательской функции поиска мин элемента будет слудующий:

Добавим вектор, полученный с помощью встроенной scilab функции поиска минимального эдемента в строке матрицы:

Выводим результаты

Вывалим в консоль всё, что нагенерировали:

Окончательно, наша программа на scilab будет выглядеть так:

Оригинальный адрес статьи: http://inclab.ru/articles/min-element-v-matrice

]]> Mon, 14 Aug 2023 16:13:10 +0400 http://inclab.ru/articles/summa-ryada-v-scilab http://inclab.ru/articles/summa-ryada-v-scilab Подсчёт конечной суммы бесконечного ряда с заданной точностью

Рассмотрим простую задачку из матана: как посчитать конечную сумму ряда приближенно в scilab, задав предварительно точность для сравнения с аналитическим значением.

Постановка задачи

Вычислить приближенное значение бесконечной суммы \( \frac{1}{1\cdot 3} + \frac{1}{2\cdot 4} + \frac{1}{3\cdot 5}...\) с точностью \( \varepsilon = 0,0001 \). Сравнить полученный результат c точным значением, равным \( 0.75 \)

Вводим входные параметры

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

Задание необходимых параметров в функции

Для подсчета суммы в пользовательской функции нам потребуется:

• накопитель \(curSum \):
• текущая ошибка \(curErr \):
• счетчик итераций \(n \)
• и максимальное число суммирований чтобы не упасть в бесконечный цикл \(maxIteration \):

При этом, \(myRange \) функция примет вид:

Подсчет частичной суммы в цикле

Создадим цикл с ограничением на допустимое отклонение от эталона и максимальное число итераций

На каждом шагу цикла будем:
-- прибавлять одно слагаемое ряда

-- считать отклонение от заданного значения

-- увеличивать счетчик

В итоге, цикл примет вид:

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

Оригинальный адрес статьи: http://inclab.ru/articles/summa-ryada-v-scilab

]]> Mon, 14 Aug 2023 16:21:44 +0400 http://inclab.ru/articles/pishem-neyroset-na-scilab http://inclab.ru/articles/pishem-neyroset-na-scilab Реализация на Scilab процесса настройки нейросети

Реализация на Scilab процесса обучения нейронной сети

Соберём уже знакомые функции, которые нам понадобятся:

Зададим число узлов (нейронов) и слоёв в нашей сети:

И сгенерируем нейросеть со случайными матрицами весовых коэффициентов:

здесь
\(net - \) это матрица нейросети размером \( 5\times 4 \), первый столбец которой - случайный входной вектор, например:

\( net = \begin{pmatrix} 0.21 & 0. & 0. & 0. \\ 0.76 & 0. & 0. & 0.\\ 0. & 0. & 0. & 0.\\ 0.33 & 0. & 0. & 0.\\ 0.67 & 0. & 0. & 0. \end{pmatrix} \)

\(matr - \) гипер-структура list, элементами которой являются весовые матрицы размером \( 5\times 5 \) со случайно сгенерированными значениями, например:

\( weightMatrixes(1) = \begin{pmatrix} 0.29 & 0.65 & 0.61 & 0.57 & 0.12\\ 0.86 & 0.99 & 0.85 & 0.57 & 0.73\\ 0.85 & 0.05 & 0.06 & 0.82 & 0.27\\ 0.53 & 0.75 & 0.83 & 0.06 & 0.55\\ 0.99 & 0.41 & 0.93 & 0.56 & 0.99 \end{pmatrix} \)

Зададим количество итераций \( lim \), массив для сбора результата каждой эпохи \( epoch \), скорость обучения нейросети \( educationSpeed \) и эталонный выход \( vectorOutputEtalon \):

И с помощью цикла \( for \) проведём обучение неросети на Scilab:

В первом вложенном цикле происходит прямое распространение сигнала в нейросети - заполнение всех столбцов матрицы \( neuralNetwork \).

Далее в текущий столбец \( epoch \) записывается полученный выходной вектор нейронки, он нам пригодится позже для отслеживания процесса обучения.

После каждого прямого прохода по сети, мы расчитываем ошибку на каждом из слоёв :
- cначала, на выходном,- как разницу эталонного и текущего выхода,
- а далее, во втором вложенном цикле, - на остальных слоях, вплоть до входного.

И, наконец, расчитываем весовую поправку \( dW \) и обновляем коэффициенты весовых матриц \( weightMatrixes \).

Обработка результа тренировки нейронной сети на Scilab

Для того, чтобы не сверять самостоятельно циферки на выходе нейросети с эталонными значениями, выведем график зависимости выходного слоя от эпохи (итерации) обучения:

Приближение выходных значений нейросети к эталонным на Scilab

Оригинальный адрес статьи: http://inclab.ru/articles/pishem-neyroset-na-scilab

]]> Mon, 04 Jul 2022 18:11:21 +0400 http://inclab.ru/articles/obuchenie-neyronnoy-seti http://inclab.ru/articles/obuchenie-neyronnoy-seti Обратное распостранение ошибки в нейроннонной сети и корректировка весовых коэффициентов по методу градиентного спуска

Ранее мы улучшали поведение простого линейного классификатора и рассмотрели, как по входу и матрицам весов нейросети вычислить её выход.

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

Выясним, как мы будем обновлять матрицы весов.

Заготовка распределения ошибки. Изображение из (1)

Обратное распространение ошибки в нейронной сети

Воспользуемся методом ОРО, пропорционально распределяя ошибку между имеющимися узлами:

Простая сеть и ошибка на узлах. Изображение из (1)

Определим ошибку на выходном слое \( e^{О}\), как разность между эталонным значением \( t_{i}\) и полученным \( o_{i}\) на выходе нейросети :

\( e^{О}_{i} = t_{i} - o_{i}\)

Тогда, глядя на рисунок выше, заключим, что ошибка \( e^{О}_{1}\) распределяется пропорционально весам \( w_{11}\) и \( w_{21}\), а ошибка \( e^{О}_{2}\) должна распределяться пропорционально весам \( w_{12}\) и \( w_{22}\).

Запишем эти доли в явном виде:

\( e^{O}_{1} = \displaystyle\frac {w_{11}}{w_{11} + w_{21}}; \quad e^{O}_{2} = \displaystyle\frac {w_{12}}{w_{12} + w_{22}}, \)

Итак, на основе отклонения текущего выхода от эталонного, мы будем обновлять весовые коэффициенты во всей нейросети, двигаясь с конца к её началу.

Распределение ошибки по слоям. Изображение из (1)

Но если сначала мы использовали ошибку выходного слоя, то какую ошибку использовать для узлов скрытого слоя? Ведь мы не можем указать очевидную ошибку для узла в таком слое.
Разберёмся, как определить ошибку для скрытого узла.

Ошибка скрытого слоя

Мы можем воссоединить ошибки, распределенные по связям следующим образом: ошибка на первом скрытом узле \( e^{H}_{1} \) представляет собой сумму ошибок, распределенных по всем связям, исходящим из этого узла в прямом направлении:

\( e^{H}_{1} = e^{O}_{1} \cdot \frac {w_{11}}{w_{11} + w_{21}} + e^{O}_{2} \cdot \frac {w_{12}}{w_{12} + w_{22}}, \)

или как показано на иллюстрации ниже:

Метод ОРО. Изображение из (1)

Применять данную методику мы будем до тех пор, пока не доберёмся до входного слоя:

Расчет ошибки на внутренних узлах. Изображение из (1)

Векторизация метода ОРО в нейросети

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

Зададим эталонный вектор \( V_{e}\), тогда ошибка \( E_O\) на выходном слое \( O\) считается самым простым способом:

\( E_O = V_{e} - O \)

Ошибка \( E_H \) на скрытом слое \( H\) будет считаться с учетом вклада каждого узла следующим образом:

\( E_H = \begin{pmatrix} \frac {w_{11}}{w_{11} + w_{21}} & \frac {w_{12}}{w_{12} + w_{22}} \\ \frac {w_{21}}{w_{21} + w_{11}} & \frac {w_{22}}{w_{22} + w_{12}} \end{pmatrix} \cdot E_o \)

Здесь \( w_{ij} \) - элементы матрицы \( W_{HO} \), задающей веса для слоёв выходной-скрытый.

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

\( E_H = \begin{pmatrix} w_{11} & w_{12} \\ w_{21} & w_{22} \end{pmatrix} \cdot E_O \)

Итак, ошибка \( E_H \) скрытого вычисляется с учётом ошибки \(E_O\) выходного слоя и матрицы \( W_{HO} \):

\( E_H = W_{HO}^T \cdot E_O\)

Аналогично, для входного слоя ошибка \( E_I \) будет вычисляться с учётом ошибки \(E_H\) предыдущего слоя в связи с матрицей \( W_{IH} \), определяющей веса входной-скрытый слоёв:

\( E_I = W_{IH}^T \cdot E_H\)

Обновление весовых коэффициентов

Для обновления весовых коэффициентов мы воспользуемся методом градиентного спуска (подробнее в (1)).

При подсчёте ошибки на каждом из слоёв, будем немного корректировать весовые коэффициенты соответвующей весовой матрицы на величину \( \Delta w \), которая на векторно-матричном языке может быть представлена как:

\( \Delta w = - \alpha \cdot E_k \cdot O_k \cdot (1 - O_k) \cdot O^T_j, \)

где
\(\alpha - \) скорость обучения нейронной сети \(\alpha \in (0,1) \),
\(E_k - \) ошибка текущего слоя (вектор столбец),
\(O_k - \) текущий слой (вектор-столбец),
\(O^T_j - \) предыдущий слой (вектор-столбец).

А обновлённая матрица весов примет вид:

\( W^{new} = W^{cur} - \Delta w \)

Осталось лишь собрать всё в программный код обучения нейросети 😁

Данная статья создана на основе чудесной книги(1) с реализацией автором приведённых примеров на Scilab.

Оригинальный адрес статьи: http://inclab.ru/articles/obuchenie-neyronnoy-seti

]]> Mon, 04 Jul 2022 18:08:38 +0400 http://inclab.ru/articles/reshenie-slu-oslu-v-scilab http://inclab.ru/articles/reshenie-slu-oslu-v-scilab Функции наиболее часто применяемые для решения СЛАУ.

Основные функции для работы с матрицами рассмотрены в статье Массивы в Scilab.
Специальные функции для работы с матрицами рассмотрены в статье Специальные матричные функции в Scilab.

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

Характериститики матрицы

Найдём определитель матрицы A: функция det() в Scilab

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 3 \\ 2 & 7 & 1 \\ 0 & 4 & 1 \end{pmatrix} & d = 27 \end{matrix} \)

Найдём ранг матрицы A: функция rank() в Scilab

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 3 \\ 2 & 7 & 1 \\ 0 & 4 & 1 \end{pmatrix} & r = 3 \end{matrix} \)

Найдём норму матрицы: функция norm(A,option) в Scilab

option - число или строка. Принимает значения:
2 - вычисляет 2-ю норму матрицы (её наибольшее сингулярное значение).
1 - вычисляет 1-ю норму матрицы (её наибольшая сумма в столбцах).
'inf' - вычисляет бесконечную норму матрицы (её наибольшая сумма в строках).
'fro' - вычисляет евклидову норму матрицы (корень из суммы квадратов всех элементов матрицы).

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 3 \\ 2 & 7 & 1 \\ 0 & 4 & 1 \end{pmatrix} & |A|_2 = 8.3940402 & |A|_1 = 11 & |A|_{inf} = 10 & |A|_{fro} = 9 \end{matrix} \)

Найдём число обусловленности матрицы A по 2-й норме: функция сond() в Scilab

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 3 \\ 2 & 7 & 1 \\ 0 & 4 & 1 \end{pmatrix} & с = 8.0199286 \end{matrix} \)

Функции для решения систем линейных уравненений

Найдём собственные значения и собственные вектора матрицы A: функция spec() в Scilab

Найдём обратную матрицу к A: функция inv() в Scilab

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 3 \\ 2 & 7 & 1 \\ 0 & 4 & 1 \end{pmatrix}& A^{-1} = \begin{pmatrix} 0.1111111 & 0.4444444 & -0.7777778\\ -0.0740741 & 0.037037 & 0.1851852\\ 0.2962963 & -0.1481481 & 0.2592593 \end{pmatrix} \\ A\cdot A^{-1} = E \end{matrix} \)

Если появляется ошибка Задача вырождена, значит определитель исходной матрицы равен или близок к нулю

\( \begin{matrix} B = \begin{pmatrix} 1 & 2 & 3 \\ 1 & 4 & 5 \\ 1 & 6 & 7 \end{pmatrix}& det(B) = 0 \end{matrix} \)

Решаем СЛАУ \( A\cdot x+b=0\): функция linsolve(A,b) в Scilab

1) Решим систему линейных алгебраических уравнений привычного вида:

\( \begin{cases} 2x_1 + x_2 = 1 \\ x_1 - 2x_2 = 3 \end{cases} \)

Для начала её нужно привести к виду, который принимает Scilab - перенести вектор свободных членов влево:

\( \begin{cases} 2x_1 + x_2 -1 = 0 \\ x_1 - 2x_2 - 3 =0 \end{cases} \)

Теперь определим вид матрицы А и вектора b:

\( \begin{matrix} A = \begin{pmatrix} 2 & 1 \\ 1 & -2 \end{pmatrix}& b = \begin{pmatrix} -1 \\ -3 \end{pmatrix} & A\cdot x+b=0 \end{matrix} \)

Зададим матрицу и вектор-столбец в Scilab и решим его силами полученную СЛАУ:

Получим красивый ответ:

\( X = \begin{pmatrix} 1 \\ -1 \end{pmatrix} \)

2) Если СЛАУ имеет бесконечное число решений, Scilab выведет только одно из них.

Решим систему линейных алгебраических уравнений вида:

\( \begin{cases} x_1 - 3x_2 = 1 \\ 2x_1 - 6x_2 = 2 \end{cases} \)

Зададим матрицу и вектор-столбец в Scilab:

Получим одно из возможных решений:

\( X = \begin{pmatrix} 0.1 \\ -0.3 \end{pmatrix} \)

3) Если возникает ошибка Конфликтующие линейные ограничения, значит система не имеет решений.

Решим систему линейных алгебраических уравнений вида:

\( \begin{cases} x_1 - x_2 = 1 \\ 2x_1 - 2x_2 = -1 \end{cases} \)

Зададим матрицу и вектор-столбец в Scilab:

Получим ошибку: ВНИМАНИЕ: Конфликтующие линейные ограничения.

Чтобы убедиться, что в матрице системы есть ЛНЗ строки или столбцы, потребуется приведение матрицы к ступенчатому виду.

Приводим систему линейных уравнений к ступенчатому виду: функция rref(A) в Scilab

Приведём матрицу к треугольной форме методом Гаусса:

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 3 \\ 2 & 7 & 1 \\ 0 & 4 & 1 \end{pmatrix} & \tilde{} & \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \end{matrix} \)

Функции разложения матрицы

Треугольное разложение матрицы \(A = L\cdot U\): функция lu() в Scilab

\(L-\) нижне-треугольная матрица, \(U-\) верхне-треугольная матрица:

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 & 3 \\ 2 & 7 & 1 \\ 2 & 4 & 1 \end{pmatrix}\\ L = \begin{pmatrix} 0.5 & 0.5 & 1\\ 1 & 0 & 0\\ 1 & 1 & 0 \end{pmatrix} & U = \begin{pmatrix} 2. & 7. & 1. \\ 0.& -3. & 0. \\ 0. & 0.& 2.5 \end{pmatrix} \end{matrix} \)

Разложение матрицы на ортогональную и верхне-треугольную \(A = Q\cdot R\): функция qr() в Scilab

\(Q-\) ортогональная матрица, \(U-\) верхне-треугольная матрица:

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 & 3 \\ 2 & 7 & 1 \\ 2 & 4 & 1 \end{pmatrix}\\ Q = \begin{pmatrix} -0.3333333 & 0.2981424 & -0.8944272\\ -0.6666667 & -0.745356 & 0. \\ -0.6666667 & 0.5962848 & 0.4472136 \end{pmatrix} & R = \begin{pmatrix} -3. & -8. & -2.3333333\\ 0. & -2.236068 & 0.745356 \\ 0. & 0. & -2.236068 \end{pmatrix} \end{matrix} \)

Основные функции для работы с матрицами рассмотрены в статье Массивы в Scilab.

Оригинальный адрес статьи: http://inclab.ru/articles/reshenie-slu-oslu-v-scilab

]]> Mon, 27 Jun 2022 21:56:25 +0400 http://inclab.ru/articles/specialnye-matrichnye-funkcii http://inclab.ru/articles/specialnye-matrichnye-funkcii Для работы с матрицами и векторами в существуют специальные функции Scilab. Рассмотрим наиболее часто используемые из них.

Основные функции для работы с матрицами рассмотрены в статье Массивы в Scilab.
Другие полезные функции рассмотрены в статье Функции для решения задач линейной алгебры в Scilab

Ниже остановимся на специальных функциях: поиска минимального и максимального элементов, сортировки, объединения массивов в Scilab и т.д..

Задание матриц/векторов специального вида

Создаём матрицу из единиц: функция ones(n,m) в Scilab

Указываем число строк и число столбцов матрицы.

Задаём вектор-строк и вектор-столбец единиц

\( \begin{matrix} R = \begin{pmatrix} 1 & 1 & 1 \end{pmatrix} & C = \begin{pmatrix} 1 \\ 1 \\ 1 \end{pmatrix} \end{matrix} \)

Задаём матрицу из единиц размерностью m на n

\( \begin{matrix} A = \begin{pmatrix} 1 & 1 \\ 1 & 1 \\ 1 & 1 \end{pmatrix} & S = \begin{pmatrix} 1 & 1 \\ 1 & 1 \end{pmatrix} \end{matrix} \)

Задаём матрицу D из единиц, той же размерности, что и матрица A

\( \begin{matrix} A = \begin{pmatrix} 1 & 5 & 4 \\ 3 & 2 & 6 \end{pmatrix} & D = \begin{pmatrix} 1 & 1 & 1\\ 1 & 1 & 1 \end{pmatrix} \end{matrix} \)

Создаём матрицу из нулей: функция zeros(n,m) в Scilab

Указываем число строк и число столбцов матрицы.

Задаём вектор-строк и вектор-столбец нулей

\( \begin{matrix} R = \begin{pmatrix} 0 & 0 & 0 \end{pmatrix} & C = \begin{pmatrix} 0 \\ 0 \\ 0 \end{pmatrix} \end{matrix} \)

Задаём матрицу нулей размерностью m на n

\( \begin{matrix} A = \begin{pmatrix} 0 & 0 \\ 0 & 0 \\ 0 & 0 \end{pmatrix} & S = \begin{pmatrix} 0 & 0 \\ 0 & 0 \end{pmatrix} \end{matrix} \)

Задаём матрицу D из нулей, той же размерности, что и матрица A

\( \begin{matrix} A = \begin{pmatrix} 1 & 5 & 4 \\ 3 & 2 & 6 \end{pmatrix} & D = \begin{pmatrix} 0 & 0 & 0\\ 0 & 0 & 0 \end{pmatrix} \end{matrix} \)

Создаём единичную матрицу: функция eye(n,m) в Scilab

Указываем число строк и число столбцов матрицы.

Задаём единичную матрицу нулей размерностью m на n

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1 \end{pmatrix} & B = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0 \end{pmatrix} & V = \begin{pmatrix} 1 \\ 0 \\ 0 \end{pmatrix} \end{matrix} \)

Задаём единичную матрицу D, той же размерности, что и матрица A

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 \\ 4 & 5 \end{pmatrix} & D = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \end{matrix} \)

Создаём случайную матрицу/вектор: функция rand(n,m, key) в Scilab

Указываем число строк и число столбцов матрицы и необязательный параметр key - это символьная переменная с помощью которой можно задать тип распределения случайной величины (по умолчанию равномерное - 'uniform': гауссовское - 'normal').

Задаём матрицу m на n случайных чисел

\( \begin{matrix} A = \begin{pmatrix} 0.2113249 & 0.3303271\\ 0.7560439 & 0.6653811 \\ 0.0002211 & 0.6283918 \end{pmatrix} & V = \begin{pmatrix} -0.7335813 \\ 0.1034169 \\ 0.8915736 \end{pmatrix} \end{matrix} \)

Создаём квадратную матрицу с элемнтами V на k-oй диагонали: функция diag(V[,k]) в Scilab

Задаём вектор V и указываем, на какой диагонали его разместить.

\( \begin{matrix} A = \begin{pmatrix} 1 & 0 & 0\\ 0 & 2 & 0\\ 0 & 0 & 3 \end{pmatrix} \end{matrix} \)

\( \begin{matrix} B = \begin{pmatrix} 0 & 1 & 0 & 0\\ 0 & 0 & 2 & 0\\ 0 & 0 & 0 & 3 \\ 0 & 0 & 0 & 0 \end{pmatrix} & C = \begin{pmatrix} 0 & 0 & 0 & 0\\ 1 & 0 & 0 & 0\\ 0 & 2 & 0 & 0\\ 0 & 0 & 3 & 0 \end{pmatrix} \end{matrix} \)

Создаём нижне-треугольную матрицу: функция tril(A[,k]) в Scilab

Указывавем матрицу, из которой будем формировать нижне-треугольную и диагональ, с которой начинать

\( \begin{matrix} A = \begin{pmatrix} 1 & 1 & 1\\ 2 & 2 & 2 \\ 3 & 3 & 3 \end{pmatrix} & B_1 = \begin{pmatrix} 1 & 0 & 0\\ 2 & 2 & 0 \\ 3 & 3 & 3 \end{pmatrix} & B_2 = \begin{pmatrix} 1 & 1 & 0\\ 2 & 2 & 2 \\ 3 & 3 & 3 \end{pmatrix} & B_3 = \begin{pmatrix} 0 & 0 & 0\\ 2 & 0 & 0 \\ 3 & 3 & 0 \end{pmatrix} \end{matrix} \)

Создаём верхне-треугольную матрицу: функции triu(A[,k]) в Scilab

Указывавем матрицу, из которой будем формировать верхне-треугольную и диагональ, с которой начинать

\( \begin{matrix} A = \begin{pmatrix} 1 & 1 & 1\\ 2 & 2 & 2 \\ 3 & 3 & 3 \end{pmatrix} & B_1 = \begin{pmatrix} 1 & 1 & 1\\ 0 & 2 & 2 \\ 0 & 0 & 3 \end{pmatrix} & B_2 = \begin{pmatrix} 0 & 0 & 1\\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} & B_3 = \begin{pmatrix} 1 & 1 & 1\\ 2 & 2 & 2 \\ 0 & 3 & 3 \end{pmatrix} \end{matrix} \)

Создаём разреженную матрицу: функции \( sparse(V_1, V_2) \) в Scilab

\( V_1 \) - вектор координат(строка, столбец) ненулевых эелемнтов
\( V_2 \) - вектор значений ненулевых эелемнтов

\( \begin{matrix} A = \begin{pmatrix} 0. & 8. & 0. & 0. & 0.\\ 0. & 0. & 0. & 0. & 9.\\ 15. & 0. & 0. & 11. & 0. \end{pmatrix} \end{matrix} \)

Функции преобразования матриц/векторов

Изменяем размер матрицы: функция matrix(A [,n,m]) в Scilab

\( A = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{pmatrix} \)

Указываем матрицу, которую меняем, потом число строк и число столбцов новой матрицы.

\( \begin{matrix} B_1 = \begin{pmatrix} 1 & 5 & 4 \\ 3 & 2 & 6 \end{pmatrix} & B_2 = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{pmatrix} & B_3 = \begin{pmatrix} 1 & 2 & 3 & 4 & 5 & 6 \end{pmatrix} & B_4 = \begin{pmatrix} 1 \\ 3 \\ 4 \\ 5 \\ 6 \end{pmatrix} \end{matrix} \)

Конкатенация (склейка) матриц/векторов: функция cat(n, A, B) в Scilab

Склеиваем матрицы по строкам, т.е. друг под другом

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} & B = \begin{pmatrix} 5 & 6 \\ 7 & 8 \end{pmatrix} & C = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \\ 7 & 8 \end{pmatrix} \end{matrix} \)

Объединяем вектора (массивы) по строкам, т.е. друг под другом

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 & 3 & 4 \end{pmatrix} & B = \begin{pmatrix} 5 & 6 & 7 & 8 \end{pmatrix} & C = \begin{pmatrix} 1 & 2 & 3 & 4\\ 5 & 6 & 7 & 8 \end{pmatrix} \end{matrix} \)

Склеиваем матрицы по столбцам, т.е. друг за другом

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} & B = \begin{pmatrix} 5 & 6 \\ 7 & 8 \end{pmatrix} & C = \begin{pmatrix} 1 & 2 & 5 & 6 \\ 3 & 4 & 7 & 8 \end{pmatrix} \end{matrix} \)

Объединяем вектора (массивы) по столбцам, т.е. друг за другом

\( \begin{matrix} A = \begin{pmatrix} 1 & 2 & 3 & 4 \end{pmatrix} & B = \begin{pmatrix} 5 & 6 & 7 & 8 \end{pmatrix} & C = \begin{pmatrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \end{pmatrix} \end{matrix} \)

Сортируем элементы матриц/векторов: функция gsort(A,option,direction) в Scilab

option - символьная строка. Она задаёт тип требуемой сортировки:
'r' - сортируется каждый столбец A
'c' - сортируется каждая строка A
'g' - сортируются все элементы A. Это значение по умолчанию.

direction - символьная строка. Она задаёт направление сортировки:
'i' устанавливает порядок возрастания,
'd' устанавливает порядок убывания (по умолчанию).

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 \\ 4 & 10 \end{pmatrix} & B_1 = \begin{pmatrix} 7 & 10 \\ 4 & 2 \end{pmatrix} & B_2 = \begin{pmatrix} 7 & 2 \\ 10 & 4 \end{pmatrix} & B_3 = \begin{pmatrix} 10 & 4 \\ 7 & 2 \end{pmatrix} & B_4 = \begin{pmatrix} 2 & 7 \\ 4 & 10 \end{pmatrix} \end{matrix} \)

Функции вычисления различных характеристик матриц/векторов

Определяем размер матриц/векторов: функция size(A,option) в Scilab

option - символьная строка. Она возволяет определить:
'r' - число строк матрицы A
'c' - число столбцов матрицы A.

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 & 1\\ 3 & 4 & 10 \end{pmatrix} & m = 2 & n = 3 \end{matrix} \)

Найдём сумму элементов массива/матрицы: функция sum(A,option) в Scilab

option - символьная строка. Она возволяет определить:
'r' - поэлементную сумму строк матрицы A. Возвращает строку.
'c' - поэлементную сумму столбцов матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается сумма всех элементов.

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 & 1\\ 3 & 4 & 10 \end{pmatrix} & R = \begin{pmatrix} 10 & 6 & 11 \end{pmatrix}& V = \begin{pmatrix} 10 \\ 17 \end{pmatrix} & S = 27 \end{matrix} \)

Найдём произведение элементов массива/матрицы: функция prod(A,option) в Scilab

option - символьная строка. Она возволяет определить:
'r' - поэлементное произведение строк матрицы A. Возвращает строку.
'c' - поэлементное произведение столбцов матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается произведение всех элементов.

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 & 1\\ 3 & 4 & 10 \end{pmatrix} & R = \begin{pmatrix} 21 & 8 & 10 \end{pmatrix}& V = \begin{pmatrix} 14 \\ 120 \end{pmatrix} & P = 1680 \end{matrix} \)

Найдём наибольший элемент массива/матрицы: функция max(A,option) в Scilab

option - символьная строка. Она возволяет определить:
'r' - наибольший элемент в каждом столбце матрицы A. Возвращает строку.
'c' - наибольший элемент в каждой строке матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается наибольший элемент во всей матрице.

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 & 1\\ 3 & 4 & 10 \end{pmatrix} & R = \begin{pmatrix} 7 & 4 & 10 \end{pmatrix}& V = \begin{pmatrix} 7 \\ 10 \end{pmatrix} & M = 10 \end{matrix} \)

Найдём наименьший элемент массива/матрицы: функция min(A,option) в Scilab

option - символьная строка. Она возволяет определить:
'r' - наименьший элемент в каждом столбце матрицы A. Возвращает строку.
'c' - наименьший элемент в каждой строке матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается наименьший элемент во всей матрице.

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 & 1\\ 3 & 4 & 10 \end{pmatrix} & R = \begin{pmatrix} 3 & 2 & 1 \end{pmatrix}& V = \begin{pmatrix} 1 \\ 3 \end{pmatrix} & M = 1 \end{matrix} \)

Найдём среднее значение массива/матрицы: функция mean(A,option) в Scilab

option - символьная строка. Она возволяет определить:
'r' - среднее значение в каждом столбце матрицы A. Возвращает строку.
'c' - среднее значение в каждой строке матрицы A. Возвращает столбец.

Если option отсутствует, то возвращается среднее значение всей матрицы.

\( \begin{matrix} A = \begin{pmatrix} 7 & 2 & 1\\ 3 & 4 & 10 \end{pmatrix} & R = \begin{pmatrix} 5 & 3 & 5.5 \end{pmatrix}& V = \begin{pmatrix} 3.3333 \\ 5.6666 \end{pmatrix} & M = 4.5 \end{matrix} \)

Основные функции для работы с матрицами рассмотрены в статье Массивы в Scilab.

Оригинальный адрес статьи: http://inclab.ru/articles/specialnye-matrichnye-funkcii

]]> Mon, 27 Jun 2022 21:50:51 +0400 http://inclab.ru/articles/risuem-geometricheskie-obekty-v-scilab http://inclab.ru/articles/risuem-geometricheskie-obekty-v-scilab Примеры того, как нарисовать сложные фигуры в Scilab

Рассмотрим, как в Scilab строить эллипсы, прямоугольники и произвольные геометрические фигуры.

Прямая линия

Начнём с простого примера построения линии.

Прежде всего, сделаем заготовку графической области, на которой будем рисовать

Квадратная область с сеткой в Scilab

Для того, чтобы нарисовать прямую нам понадобятся две точки и функция \(plot() \).
Итак, для линии, идущей из точки (-1.5, 0) в (1, 1.5) зададим два массива \(х-ов \) и \(у-ков \) соответственно:

А далее просто построим наш график по заданным точкам (которых всего две):

В итоге получим зелёную полужирную прямую с кругляшами на концах:

Прямая линия в Scilab

Ломаная линия

Эту линию, конечно, можно продолжить, просто добавив новые элементы в массивы \(xpts \), \(ypts \):

Ломаная линия в Scilab

Произвольный многоугольник

Из линии можно сделать многоуголиник, если в массивы координат последними элементами добавить их начальные значения:

Неправильный многоугольник в Scilab

Этот многоугольник можно закрасить, используя способ 1 polyline_style:

Закрашенный многоугольник в Scilab

Если же требуется более тонкая настрока цветов, то нуно прибегнуть к способу 2 и вместо polyline_style испольщовать fill_mode и closed. При этом, замыкать ломаную вручную необязательно:

Закрашенный многоугольник в Scilab

Правильный n-угольник

Теперь, когда мы натренеровались строить и настравивать отображение фигур в Scilab, построим правильный многоугольник, вписанный в единичную окружность.

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

Следовательно, интересующие нас координаты - это \(cos() \) и \(sin()\) текущего угла.
А чтобы начинать движение из точки (0, 1), нужно прибавить \( \pi/2 \) к текущему углу:

Нарисуем правильный пятиугольник в Scilab, замкнув ломаную и изменим толщину линий и их цвет на графике

Правильный многоугольник в Scilab

Эту задачу можно решить и другим способом - с помощью \(xpoly()\)

Правильный многоугольник с помощью xpoly()

Для того, чтобы нарисовать закрашенный многоугольник, нужно использовать функцию \(xfpoly()\)

Правильный многоугольник с помощью xfpoly()

Эллипс

Для построения эллипса нужно задать 6 значений:

Значения матрицы эллипса

Координаты (xLeftTop, yLeftTop) верхнего левого угла прямоугольника, в который будет вписан эллипс;

Ширину elWidth и Высоту elWidth прямоугольника, в который будет вписан эллипс;

Угол angleStart, откуда будет стартовать дуга эллипса и Угол angleEnd, где дуга остановится.

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

Сам эллипс по заданным параметрам строится с помощью функции \(xarcs()\):

Сектор

Из эллипса можно строить произвольные сектора, располагая их в желаемом месте на координатной сетке.

Произвольные сектора

Построим два сектора на основе эллипса с заданными параметрами:

Звезда Сименса

В заключении построим Звезду Сименса изображение, применяемое для проверки остроты зрения (wiki).

Звезда Сименса с 50 лучами

Оригинальный адрес статьи: http://inclab.ru/articles/risuem-geometricheskie-obekty-v-scilab

]]> Fri, 24 Jun 2022 00:38:48 +0400 http://inclab.ru/articles/prosteyshaya-neyronnaya-set-na-scilab http://inclab.ru/articles/prosteyshaya-neyronnaya-set-na-scilab Рассмотрим поэтапно прямое распространение импульса на примере трёхслойной нейронной сети в Scilab

Ранее был рассмотрен вопрос настройки линейного классификатора, как заготовки для понимания принципов машинного обучения.

В даннном материале попробуем углубиться в тему и рассмотрим, как распространяется импульс в искусственной нейронной сети.

Искусственная нейросеть из 3-х слоёв

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

Трёхслойная нейросеть. Изображение из (1)

Каждый нейрон принимает сигнал, неким образом его обрабатывает и передаёт дальше.

Функция активации

В качестве правила, по которому происходят метаморфозы сигнала внутри нейрона мы будем использовать логистическую функцию вида:

\( \sigma = \displaystyle\frac{1}{1+e^{-x}} \quad (1) \)

Функция (1) называется ещё и сигмоидой, она очень популярна в области искусственного интеллекта благодаря своей гладкости и простоте расчётов.

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

Итак, структура сети определена, функция активации выбрана, осталось определить, каким образом наша сеть будет обучаться.

Весовые коэффициенты

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

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

Определим для каждого соединения его вес:

Задание весов в нейросети. Изображение из (1)

Посмотрим внимательно на схему распределения весов.

Заметим, что весовой коэффициет \( w_{i,j} \) соответствует сигналу, передаваемому от \( i-го\) узла текущего слоя к \( j-му\) узлу следующего слоя.

Например к 1-му нейрону 2-го слоя подходят три стрелочки: от 1-го, 2-го и 3-го нейронов 1-го слоя, с весами \( w_{1,1}, w_{2,1}, w_{3,1} \) соотвественно.

Согласно общепрянотой терминологии, мы будем называть слои следуюющим образом:

• Первый слой узлов будем называть \(входным\);

• Последний слой - \(выходным\);

• А все слои между ними - \(скрытыми\).

Прямое распространение сигнала в нейронной сети

Приступим к пошаговой реализации распространения сигнала в нашей нейросети.

Задание весов в нейросети. Изображение из (1)

Входной слой

Зададим вектор входных сигналов:

\( I = \begin{pmatrix} 0.9 \\ 0.1 \\ 0.8 \end{pmatrix} \)

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

Хорошо. что Scilab - матрично-ориентированный язык, поэтому задание вектора входного сигнала будет выглядеть следующим образом:

Скрытый слой

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

Вход скрытого слоя

Предположим, весовые коэффициенты для связи между входным и скрытым слоями заданы следующим образом:

\( w_{1,1}=0.9, w_{2,1}=0.3, w_{3,1}=0.4 \)

\( w_{1,2}=0.2, w_{2,2}=0.8, w_{3,2}=0.2 \)

\( w_{1,3}=0.1, w_{2,3}=0.5, w_{3,3}=0.5 \)

Индексы весовых коэффициентов показывают откуда куда идут стрелочки.

Соответственно, чтобы вычислить вход 1-го нейрона скрытого слоя \( H_{i}(1) \), необдимо взять сумму весов \( w_{1,1}=0.9, w_{2,1}=0.3, w_{3,1}=0.4 \) (стрелочки идут от 1-го, 2-го и 3-го нейрона входного слоя к 1-му нейрону скрытого), умноженных на соответсвующий выход предыдущего слоя:

\( H_{i}(1) = w_{1,1}\cdot I(1) + w_{2,1}\cdot I(2) + w_{3,1}\cdot I(3) = 0.9\cdot0.9 + 0.3\cdot0.1 + 0.4\cdot0.8=1.16 \)

Аналогично вычислим вход 2-го и 3-го нейронов скрытого слоя \( H_{i}(2), H_{i}(3) \):

\( H_{i}(2) = w_{1,2}\cdot I(1) + w_{2,2}\cdot I(2) + w_{3,2}\cdot I(3) = 0.2\cdot0.9 + 0.8\cdot0.1 + 0.2\cdot0.8=0.42 \)

\( H_{i}(3) = w_{1,3}\cdot I(1) + w_{2,3}\cdot I(2) + w_{3,3}\cdot I(3) = 0.1\cdot0.9 + 0.5\cdot0.1 + 0.6\cdot0.8=0.62 \)

Кажется, имеется некоторая закономерность в производимых действиях 😉. Действительно, если из весовых коэффициентов сформировать матрицу:

\( W_{IH} = \begin{pmatrix} w_{1,1} & w_{2,1} & w_{3,1} \\ w_{1,2} & w_{2,2} & w_{3,2} \\ w_{1,3} & w_{2,3} & w_{3,3} \\ \end{pmatrix} \)

То вход скрытого слоя можно отыскать простым матричным умножением:

\( H_{i} = W_{IH}\cdot I \quad (2) \)

Зададим матрицу весов входной-скрытый на Scilab:

А чтобы посчитать вход скрытого слоя напишем функцию согласно (2):

Отобразим входные сигналы для скрытого слоя на диаграмме.

Вход скрытого слоя. Изображение из (1)

Итак, мы сформировали вектор-столбец входных сигналов скрытого слоя:

\( H_i = \begin{pmatrix} 1.16 \\ 0.42 \\ 0.62 \end{pmatrix} \)

Пока что все хорошо, но нам еще остается кое-что сделать.

Выход скрытого слоя

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

\( H_{o} = \sigma(H_i) \quad (3) \)

Применяя сигмоиду ко входу скрытого слоя, получим его выход:

\( H_o = \begin{pmatrix} 0.761 \\ 0.603 \\ 0.650 \end{pmatrix} \)

Вход и выход скрытого слоя. Изображение из (1)

В Sciab нет встроенной функции сигмоиды, поэтому напишем свою:

Заметьте, что в функции присутствует "./" - это поэлементное деление в Scilab, так как в качестве параметра мы передаём вектор 😎

И применим её ко входу скрытого слоя:

Функция \( roundToDecimal(\cdot, \cdot); \) нам нужна, чтобы округлять результат до нужного знака после запятой. Выглядит она предельно просто:

Выходной слой

Для выходного слоя задача прохождения сигнала (О чудо!) ничем не отличается от предыдущего шага!

Перелесть проделанных на шаге 2 действий в том, что сколько бы слоёв ни было в нашей сети, вход каждого из них будет вычисляться путём умножения соответствующей матрицы весов и на выход предыдущего слоя, а его выход - путём применениия функции активации к полученному результату 👏

Итак, по аналогии со скрытым слоем, зададим матрицу весовых коэффициентов скрытый-выходной:

\( W_{HO} = \begin{pmatrix} w_{1,1} & w_{2,1} & w_{3,1} \\ w_{1,2} & w_{2,2} & w_{3,2} \\ w_{1,3} & w_{2,3} & w_{3,3} \\ \end{pmatrix} = \begin{pmatrix} 0.3 & 0.7 & 0.5 \\ 0.6 & 0.5 & 0.2 \\ 0.8 & 0.1 & 0.9 \\ \end{pmatrix} \)

И посчитаем вход выходного слоя:

\( O_i = W_{HO}\cdot I_o = \begin{pmatrix} 0.3 & 0.7 & 0.5 \\ 0.6 & 0.5 & 0.2 \\ 0.8 & 0.1 & 0.9 \\ \end{pmatrix} \cdot \begin{pmatrix} 0.761 \\ 0.603 \\ 0.650 \end{pmatrix} = \begin{pmatrix} 0.975 \\ 0.888 \\ 1.254 \end{pmatrix} \)

Все, что нам остается, это применить сигмоиду к \( O_i \)

\( O_o = \sigma \begin{pmatrix} 0.975 \\ 0.888 \\ 1.254 \end{pmatrix} = \begin{pmatrix} 0.726 \\ 0.708 \\ 0.778 \end{pmatrix} \)

И, наконец, мы получили сигналы на выходе нейронной сейти:

Вход и выход выходного слоя. Изображение из (1)

Проделаем те же действия в Scilab:

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

Цикл для прямого распределения сигнала в нейронке

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

Соберём все собственные функции:

Зададим желаемое число нейронов и слоёв в нейросети:

И сгенерируем заготовку для сети:

\( neuralNetwork = \begin{pmatrix} 0 & 0 & 0\\ 0 & 0 & 0\\ 0 & 0 & 0 \end{pmatrix} \)

Первый столбец в матрице сети- это входной вектор \( I \). Зададим первый стобец матрицы, как в разобранном примере:

\( neuralNetwork = \begin{pmatrix} 0.9 & 0 & 0\\ 0.1 & 0 & 0\\ 0.8 & 0 & 0 \end{pmatrix} \)

Далее необходимо задать матрицы весов. Чтобы с ними было удобно работать, объединим матрицы в гипер-структуру - список \( list(); \) и зададим две матрицы \( W_{IH}, W_{HO} \), как в примере выше:

Теперь элемент списка \( weightMatrixes(); \) - это целиком весовая матрица:

\( \begin{matrix} weightMatrixes(1) = \begin{pmatrix} 0.9 & 0.3 & 0.4\\ 0.2 & 0.8 & 0.2\\ 0.1 & 0.5 & 0.6 \end{pmatrix} & weightMatrixes(2) = \begin{pmatrix} 0.3 & 0.7 & 0.5\\ 0.6 & 0.5 & 0.2\\ 0.8 & 0.1 & 0.9 \end{pmatrix} \end{matrix} \)

Осталось лишь запустить цикл вычисления скрытого и выходного слоёв.
Каждый новый слой (столбец матрицы neuralNetwork) - это результат применения сигмоиды к произведению текущего слоя (столбца) и соответствующей весовой матрицы:

Убедимся, что результат совпадает с посчитанным поэтапно:

\( neuralNetwork = \begin{pmatrix} 0.9 & 0.761 & 0.726\\ 0.1 & 0.603 & 0.708\\ 0.8 & 0.65 & 0.778 \end{pmatrix} \)

Отлично! Результат совпал. Можно двигаться дальше.

Далее мы приступим к разбору метода обратного распределения ошибки и корректировки весов 🤓

Данная статья создана на основе чудесной книги(1) с реализацией автором приведённых примеров на Scilab.

Оригинальный адрес статьи: http://inclab.ru/articles/prosteyshaya-neyronnaya-set-na-scilab

]]> Mon, 04 Jul 2022 17:15:53 +0400 http://inclab.ru/articles/nastroyka-grafikov-v-scilab-polnyy-gayd http://inclab.ru/articles/nastroyka-grafikov-v-scilab-polnyy-gayd Рассмотрим, как изменить вид графиков в Scilab.

Основы построения графиков рассмотрены в статье, а в статье подробно рассмотрен вопрос настройки толщины и начертания графиков.

Создадим заготовку графика, который будем всячески кастомизировать.

Название графика и подписи осей

Чтобы задать название графика в Scilab, запишем:

Изменим цвет и размер шрифта у названия графика:

Настройка отображения заголовка на графике в Scilab

Похожим образом зададим подписи горизонтальной и вертикальной осей:

И изменим начертание и размер шрифта у подписей осей:

Настройка отображения подписей осей на графике в Scilab

Положение осей

Начнем с того, что поменяем расположение горизонтальной и вертикальной осей на графике.

Чтобы переместить ось абсцисс, нужно воспользоваться командой:

Где xyz - принимает значения: "bottom", "top", "middle", "origin".

Варианты расположения оси х на графике в Scilab

Аналогично можно поменять расположение оси ординат, для этого нужно воспользоваться командой:

Где xyz - принимает значения: "left", "right", "middle", "origin".

Варианты расположения оси y на графике в Scilab

Настройка сетки

Добавим на наш график сетку с помощью стандартной команды:

Чтобы поменять цвет grid, нужно воспользоваться командой:

Где вектор из трех индексов цветов [xCol, yCol, zCol], используется для рисования сетки в соответствующих направлениях. Чтобы отменить сетку в направлении, используйте -1 в качестве индекса.

Разные цвета сетки на графике в Scilab

Заодно можно изменить толщину сеткти grid. Для этого нужно воспользоваться командой:

Где вектор [xLineThick, yLineThick, zLineThick] состоит из 2 или 3 положительных десятичных чисел, задающих толщину линий сетки вдоль соответствующих направлений (в 2D или 3D).

Разная толщина сетки на графике в Scilab

Кроме того, линиям сетки сеткти grid можно задать разное начертание. Для этого нужно воспользоваться командой:

Где вектор [xLineStyle, yLineStyle, zLineStyle] состоит из 2 или 3 идентификаторов стилей линий от 1 до 10 (сплошные, штрихи, точки и т. д.), используемые для рисования сетки в соответствующих направлениях (в 2D или 3D).

Разныый стиль линий сетки на графике в Scilab

Пример настройки plot

Не только ради развлеения, но и для практической пользы, поиграем с настройками параметров графика в Scilab.

А теперь приступим к изменению параметров графика.

Зададим название графика и подписи осей.

Приступим к разукрашиванию.

В итоге получится вот такой результат:

График в форме сердца в Scilab

Оригинальный адрес статьи: http://inclab.ru/articles/nastroyka-grafikov-v-scilab-polnyy-gayd

]]> Wed, 22 Jun 2022 00:12:14 +0400 http://inclab.ru/articles/vosstanovlenie-signala-i-ehffekt-gibbsa http://inclab.ru/articles/vosstanovlenie-signala-i-ehffekt-gibbsa Сгенерируем прямоугольный импульс с заданными характеристиками, построим его спектр и попробуем его восстановить по нескольким гармоникам.

Сгенерируем прямоугольный импульс с заданными характеристиками, построим его спектр и попробуем его восстановить по нескольким гармоникам.

Построение прямоугольного импульса

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

Прямоугольный импульс с амплитудой 1, длиной 4 и периодом 12.

Зададим период и длительность импульса, а также временной промежуток, на котором будем строить импульс:

Далее напишем функцию, которая будет строить импульс на заданном промежутке:

В функции \( imp() \) сначала формируется вектор, заполненный нулями той же размерности, что и временной промежуток.

Чтобы построить прямоугольный импульс, нам нужно на первых 4-х секундах задать его высоту = 1, оставив остальные элементы вектора без изменения (потому что они уже нулевые), а далее повторить эту процедуру с заданным периодом, т.е. через каждые 12 с.

Повторение импульса обеспечивает деление по модулю, которое в Scilab реализовано функцией \( modulo( \cdot, \cdot) \)

Осталось лишь вызвать функцию \( imp() \) с заданными параметрами импульса и немного подкорректировать первый и последний элементы сформированного вектора:

Построим график нашей функции, чтобы убедиться, что всё идёт по плану:

Прямоугольный импульс с амплитудой 1, длиной 4 и периодом 12.

Заметьте, что здесь заголовок графика формируется с учетом заданных характеристик, которые переводятся в строку функцией \( string() \).

Разложение несимметричного импульса в комплексный ряд Фурье

Для несимметричного импульса с амплитудой 1 комплексные коэффициенты Фурье примут вид:

\( c_k = \displaystyle\frac{1}{T} \displaystyle\int_{0}^{\tau} e^{-i\frac{2\pi k t}{T}}dt = \left( \frac{1}{\pi k} sin \left( \frac{\pi k \tau}{T} \right) \right) e^{-i\frac{\pi k \tau}{T}} \quad (1) \)

При этом, на нулевой частоте было деление на 0, поэтому её нужно задать отдельно в виде:

\( c_0 = \displaystyle\frac{\tau}{T} \)

Вычислим коэффициенты \( c_k \) разложения несимметричного импульса в Scilab по формуле (1), заодно посчитаем частоты гармоник \( \omega_k \).

Выделяем амплитудный и фазовый спектр

Вещественные коэффициенты \( A_k \) и \( \phi_k \), где

\( A_k = |c_k| \quad \phi_k = arg(c_k) \)

несут полную информацию о периодической с известным периодом \( T \) функции.

Набор \( A_k \) называется амплитудным спектром, а коэффициенты \( \phi_k \) определяют фазы отдельных гармоник, их совокупность называется фазовым спектром.

Из сформированных комплекснозначных коэффициетов Фурье \( c_k \) выделим амплитудный и фазовый спект в Scilab: для нахождения модуля комплексного числа воспользуемся функцией \( abs() \), а угол \( \phi_k \) найдём с помощью функции \( atan(\cdot, \cdot) \).

Напоминание про комплексные числа.

Построим графики найденных спектров. Здесь стоит отметить, что \( A_k \) и \( \phi_k \) - это дискретные величины. Чтобы построить дискретный график в Scilab воспользуемся функцией \( plot2d3() \) в совокупности с классическим \( plot() \), который будет формировать кружочки:

Фаза и амплитуда прямоугольного импульса.

Восстанавливаем несимметричный импульс

Периодическая функция, представленная в виде комплексного ряда Фурье, может быть восстановлена по найденным коэффициентам (1) согласно формуле:

\( x(t) = c_0 + 2 \displaystyle \sum_{k=1}^{+\infty} |c_k| cos(\omega_k t + arg(c_k)) \quad (2) \)

Представим формулу (2) на языке Scilab. Чтобы процесс был более наглядным, выражение под знаком суммы в (2) вынесем в отдельную функцию, аргументами которой будут: модуль комлекных коэффициентов \( |c_k| \) , частоты гармоник \( \omega_k \), временной промежуток - транспонированный вектор \( t \) и аргумент комлекных коэффициентов \( arg(c_k) \):

Заметьте, что коэффициент \( |c_0| \) представлен как \( С(1) \), так как нумерация элементов массива в Scilab начинается с 1.

Функция \( summ() \) будет иметь следующий вид:

Итак, осталось лишь вывести восстановленный сигнал и посмотреть, насколько он совпадает с оригинальным:

Исходный импульс и восстановленный по 15 гармоникам

На графике можно заметить осцилляции в точках излома импульса.

Если взять число гармоник \( N=50\), то картина улучшится, но кардинально не изменится:

Исходный импульс и восстановленный по 50 гармоникам

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

Оригинальный адрес статьи: http://inclab.ru/articles/vosstanovlenie-signala-i-ehffekt-gibbsa

]]> Wed, 22 Jun 2022 00:31:20 +0400 http://inclab.ru/articles/realizaciya-svertki-v-scilab http://inclab.ru/articles/realizaciya-svertki-v-scilab Проведём пошаговую операцию свёртки двух сигналов, чтобы детально разобраться в смысле данной математической операции.

Свёртка это математическая операция, применимая к \( f(t) \) и \( g(t) \), которая порождает третью функцию и определяется формулой:

\( y(t) = (f * g)(t) = \displaystyle\int_{-\infty}^{\infty}f(\tau)g(t-\tau)d\tau \) (1)

Рассмотрим реализацию свёртки двух сигналов на примере. Пусть сигналы \( f(t) \) и \( g(t) \) задаются в следующем виде:

\begin{matrix} f(t) = \begin{cases} 2, \quad 0 \leq t < 1 \\ -2t+4, \quad 1 \leq t < 2 \\ 0, \quad t<0 \text{ or } t \geq 2 \\ \end{cases} & g(t) = \begin{cases} 1, \quad t = 0 \\ 1 - \frac{1}{3}t, \quad 0 < t < 3 \\ 0, \quad t<0 \text{ or } t \geq 3 \\ \end{cases} \end{matrix}

Их графики, соответственно будут представлять собой ломаные, как показано ниже

Графики сигналов f(t) и g(t)

Пример свёртки двух функций пошагово

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

Итак, начнём с того, что в интегральном выражении у функции \( g(t-\tau) \) по переменной, которой производится интегрирование, стоит знак "-", а значит график нужно отразить по горизонтальной оси относительно оси ординат, как показано на рисунке ниже:

Отражённый сигнал g(t)

Выражение \( (t-\tau) \) означает, что движение будет происходить оси \( t \). Причём, если \( t<0 \), то график функции \( g(t) \) будет двигаться влево, при \( t \geq 0 \) движение будет происходить вправо.

Далее необходимо вычислить произведение \( g(t)(t-\tau) \) для каждого значения \( t \) и посчитать площадь получившейся в результате произведения двух графиков фигуры.

На рисунке ниже показано, какие случаи пересечений нам необходимо просчитать по мере движения графика по оси \( t \) .

Графичекая пошаговая интерпретация свёртки сигналов f(t) и g(t)

Остановимся на каждом из 6-ти случаев и произведём расчёты площадей получившихся фигур.

1. При \( t<0 \) графики сигналов не пересекаются, а значит и площадь фигуры их пересечения нулевая, то есть, результирующий интеграл примет вид:

   \( \displaystyle\int_{-\infty}^{0}f(\tau)g(t-\tau)d\tau=0 \)

2. На интервале \( 0 \leq t < 1 \) сигнал \( f(t) \) представляет собой константу: \( f(t)=2 \) , а график сигнала \( g(t) \) - есть прямая \(1 - \frac{1}{3}t\). Исходя из вышесказанного, результатом сворачивания двух функций будет функция \( y(t) \) вида:

   \( y(t) = \displaystyle\int_{0}^{t} 2 \left(1 - \frac{1}{3}(t-\tau)\right) d\tau = 2t - \frac{t^2}{3} \)

3. На интервале \( 1 \leq t < 2 \) результирующий интеграл можно разбить на 2 интеграла: первый вида, описанного в пункте b). Второй интеграл будет представлять собой площадь фигуры, имеющей стороны, описываемые прямыми \(1 - \frac{1}{3}t\) и \( -2t+4 \) . В результате, функция \( y(t) \) примет вид:

   \( y(t) = \displaystyle\int_{0}^{1} 2 \left(1 - \frac{1}{3}(t-\tau)\right) d\tau + \displaystyle\int_{1}^{t} \left( 4 - 2\tau \right) \left(1 - \frac{1}{3}(t-\tau)\right) d\tau = \frac{t^3}{9} -\frac{5}{3}t^2 + \frac{13}{3}t - \frac{10}{9} \)

4. На интервале \( 2 \leq t < 3 \) результатом свёртки будет функция \( y(t) \):

   \( y(t) = \displaystyle\int_{0}^{1} 2 \left(1 - \frac{1}{3}(t-\tau)\right) d\tau + \displaystyle\int_{1}^{2} \left( 4 - 2\tau \right) \left(1 - \frac{1}{3}(t-\tau)\right) d\tau = \frac{34}{9} -t \)

5. Предпоследним, дающим непустое пересечение графиков, будет интервал \( 3 \leq t < 4 \), который породит функцию \( y(t) \):

   \( y(t) = \displaystyle\int_{t-3}^{1}2 \left(1 - \frac{1}{3}(t-\tau)\right) d\tau + \displaystyle\int_{1}^{2}\left( 4 - 2\tau \right) \left(1 - \frac{1}{3}(t-\tau)\right) d\tau = \frac{1}{3}t^2 -3t + \frac{61}{9} \)

6. Результирующей функцией на интервале \( 4 \leq t < 5 \) будет второе слагаемое из предыдущего случая со своими пределами интегрирования:

   \( y(t) = \displaystyle\int_{t-3}^{2} \left( 4 - 2\tau \right) \left(1 - \frac{1}{3}(t-\tau)\right) d\tau = \frac{1}{9}t^3 + \frac{5}{3}t^2 - \frac{25}{3}t + \frac{125}{9} \)

Таким образом, результатом свёртки игналов \( f(t) \) и \( g(t) \) будет функция \( y(t) \), задаваемая совокупностью уравнений:

\begin{matrix} y(t) = \begin{cases} 0, \quad t<0 \text{ or } t \geq 5 \\ 2t - \frac{t^2}{3}, \quad 0 \leq t < 1 \\ \frac{t^3}{9} -\frac{5}{3}t^2 + \frac{13}{3}t - \frac{10}{9}, \quad 1 \leq t < 2 \\ \frac{34}{9} -t, \quad 2 \leq t < 3 \\ \frac{1}{3}t^2 -3t + \frac{61}{9}, \quad 3 \leq t < 4 \\ \frac{1}{9}t^3 + \frac{5}{3}t^2 - \frac{25}{3}t + \frac{125}{9}, \quad 4 \leq t < 5 \\ \end{cases} \end{matrix}

На рисунке ниже приведена функция являющаяся результатом сворачивания двух сигналов на каждом из смысловых промежутков.

Функция y(t) - результат свёртки сигналов f(t) и g(t)

Реализация свёртки на Scilab

Для реализации в численных методах, рассматривается дискретный случай свертки двух функций \( f(j) \) и \( g(j) \)

\( z(k) = \displaystyle\sum_{j=max(1, k+1-L_g)}^{min(k,L_f)} f(j)\cdot g(k+1-j), \quad k=1,..,L_f+L_g \quad (3) \)

где \( L_f, L_g\) - количество элементов функций \( f(j) \) и \( g(j) \) соответственно.

Прежде всего, зададим функции \( f(j) \) и \( g(j) \) с помощью условных операторов в Scilab:

Далее на пишем функцию, реализующую свёртку, согласно формулы (3)

И посмотрим, сойдётся ли результат, полученный с помощью нашей функции \( myconv() \) с результатом, полученным при использовании встроенной функции \( conv() \)

Глядя на изображение ниже, можно с уверенностью сказать, что результаты совпадают :)

Результат наложения встроенной и самописной функции свёртки

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

Корректировка результатов свёртки

Для корректного отображения результирующего графика нам потребуется несколько модифицировать функцию \( myconv() \). Прежде всего, заведём переменную, отвечающую за сдвиг результата по горизонтальной оси:

И изменим функцию \( myconv() \) следующим образом:

Посмотрим, как теперь будет выглядеть результат:

Результат модификации свёртки

Стало значительно лучше: мы укладываемся в интервал и стартуем из нуля.

Реализация анимации свёртки двух сигналов

Прежде всего, выведем графики сигналов, которые сворачиваем:

Чтобы графики выглядели поприличнее, нужно уменьшить шаг дискретизации, например до \( d=0,01 \) и настроить их толщину с помощью \( gca().children.children.thickness \)

Графики функций f(t) и g(t)

Осталось лишь реализовать анимационный цикл.

В статьедано описание основ анимации в Scilab.

Здесь на каждом шагу цикла мы рисуем i-ю точку свёртки, а зелёный график рисуем и стираем, что имитирует его движение.

В результате получим такую анимированную картинку движения графика и построения результирующего интеграла-свёртки:

Анимация свёртки

Оригинальный адрес статьи: http://inclab.ru/articles/realizaciya-svertki-v-scilab

]]> Tue, 21 Jun 2022 19:48:32 +0400 http://inclab.ru/articles/nastroyka-lineynogo-klassifikatora-scilab http://inclab.ru/articles/nastroyka-lineynogo-klassifikatora-scilab Обучение линейного классификатора на эталонной выборке с целью правильно классифицировать жуков, относя их к гусеницам или божьим коровкам

Рассмотрим задачу классификации данных на примере разделения садовых жуков.

Будем рассматривать гусениц и божьих коровок, разделяя их в зависимости от размера.

Гусеницы длинные и узкие	Божьи коровки короткие и широкие
Image from Pixabay	Image from Pixabay

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

Тогда на введённой шкале всех жуков можно условно разделить следующим образом:

Жуки в системе координат. Изображение из (1)

Попробуем разделить наших жуков с помощью прямой. Уравнение прямой имеет вид:

\( y = Ax, \)

где A это коэффициент наклона.

Проведём пару разделительных линий:

Попытка разделить жуков 1. Изображение из (1)	Попытка разделить жуков 2. Изображение из (1)
Тут мы попали в гусениц. То, что выше линии гусеницы, то, что ниже линии - гусеницы и божьи коровки. Плохо разделили 🤨	Тут мы ни в кого не попали, однако, выше линии оказались и гусеницы, и божьи коровки, а снизу никого. Совсем не разделили жуков 🤔

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

Идеальный классификатор. Изображение из (1)

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

Вот как-то, как на графике:

Определение типа жука по его положению. Изображение из (1)

Тренировочные данные

Сейчас мы займемся тренировкой (обучением) нашего линейного классификатора и научим его правильно классифицировать жуков, относя их к гусеницам или божьим коровкам.

Первое, что нам понадобится - это эталонные данные, на основе которых мы будет тренировать классификатор.

Чтобы не усложнять себе жизнь, мы ограничимся двумя простыми примерами, приведенными ниже.

Итак, для обучения классификатора у нас в арсенале имеются:

• жук, имеющий ширину 3.0 и длину 1.0, который, как нам известно, является божьей коровкой;
• жук, имеющий ширину 1.0 и длину 3.0, которым является гусеницей.

Изобразим их на нашей шкале:

Положение эталонных жуков на координатной сетке. Изображение из (1)

И попробуем построить классификатор. То есть, провести прямую \( y=Ax \) с некоторым коэффициентом наклона \( A \).

Возьмём \( А=0.25\). Тогда уравнение прямой будет иметь вид \( y=0.25x\). Изобразим наш классификатор на графике с жуками и посмотрим, каких результатов мы достигли:

Классификатор с А=0.25. Изображение из (1)

Так себе классификатор, честно говоря.

С таким классификатором мы не можем делать выводы вида: «Если точка данных располагается над линией, то она соответствует гусенице».

А именно к этому мы и стремимся: по графику понять, что за жук перед нами. Если он выше прямой - гусеница, ниже - коровка.

Процесс настройки классификатора

Приступим к выработке алгоритма, который бы подбирал оптимальный коэффициент наклона прямой.

Шаг 1

Возьмём первого эталонного жука - божью коровку: у неё ширина 3 (это х), длина 1 (это у). Подставим ширину жука в наш классификатор:

\( y = 0.25 \cdot 3 = 0.75 \)

Получили \(у=0.75 \), а по эталону должно было получиться \( y_э = 1 \). Налицо отклонение от эталона.

Шаг 2

Считаем ошибку которая вычисляется, как разница между желаемым значением и фактическим результатом.

\(e = y_э - y = 1 - 0.75 = 0.25 \)

Давайте подумаем, каким должно быть подходящее желаемое значение \( y \).

Если положить его равным 1, как в эталоне, то линия пройдет через точку с координатами (х, у) = (3; 1), соответствующую божьей коровке. Само по себе это неплохо, но это не совсем то, что нам нужно.

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

Поэтому, мы немного приподнимем классификатор, т.е.

отступим от \( y_э = 1 \) на небольшое значение \( D=0.1\)

Тогда ошибка будет вычисляться следующим образом:

\(e = y_э - y = 1.1 - 0.75 = 0.35 \)

На графике наши манипуляции с углом наклона прямой будут выглядеть так:

Немного корректируем угол наклона классификатора. Изображение из (1)

Шаг 3

Выясним как связаны \(A\) и \(D\).

Так как брать величину поправки с потолка нехорошо, формализуем поиск этого самого \(D\) - величины, на которую мы хотим изменить наклон классификатора.

Изначально классификатор имел уравнение

\(y=Ax \)

Приподняв его, мы произвели изменение угла наклона, получив прямую

\(y=(A+D)x \)

А теперь подставим эти данные в ошибку \( e \):

\(e = y_э - y = (A + D)x - Aх = Aх + Dx - Ax = Dx. \)

Итак, ошибка \( e \) связана с \( D \) очень простым соотношением. Используем информацию об ошибку для определения величины поправки \( D \):

\( D = \frac{e}{x} \)

Теперь мы можем использовать ошибку \( e \) для вычисления величины, на которую следует изменить наклон классификатора. В нашем случае:

\( D = \frac{0.35}{3}=0.1167 \)

Шаг 4

Корректируем наклон классификатора. Текущее значение \(А=0.25\) необходимо изменить на величину \( D = 0.1167 \), стало быть, улучшенное уравнение классификатора примет вид:

\( y = (0.25+0.1167)x=0.3667x \)

Итак, новый классификатор \( у=0,3667х \) получен на основе всего одного эталонного значения.

Проделаем те же манипуляции для второго жука, но уже с подстроенным классификатором \( у=0,3667х \).

Шаг 1

Подставим гусеницу \( (x,y) = (1, 3) \) в классификатор:

\( y = 0.3667 \cdot 1 = 0.3667 \)

Шаг 2

Посмотрим на эталон:

\( y_э = 3 \)

Отступим от эталона на \(D=0.1\) и посчитаем ошибку:

\(e = 2.9 - 0.3667 = 2.5333 \)

Шаг 3

Вычислим величину \( D \), на которую нужно изменить наклон классификатора: .

\( D = \frac{2.5333}{1}=2.5333 \)

Шаг 4

Корректируем наклон классификатора:

\( y = (0.3667 + 2.5333)x=2,9x \)

Отобразим на графике проделанные манипуляции:

Процесс настройки классификатора по двум эталонным данным. Изображение из (1)

Глядя на график, мы видим, что нам не удалось добиться того наклона прямой, которого мы хотели.

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

Давайте это исправим.

Сглаживание поправки

Воспользуемся идеей, которая играет ключевую роль в машинном обучении.

Вместо того чтобы каждый раз с энтузиазмом заменять \(А \) новым значением, мы используем лишь некоторую долю поправки \(D \) , а не всю ее целиком.

Ну что ж, сделаем перерасчет шагов 1-3 для обоих жуков, на этот раз добавив сглаживание в формулу обновления коэффициента наклона:

\( D = L \frac{e}{х} \)

Фактор сглаживания, обозначенный здесь как \( L\), часто называют коэффициентом скорости обучения.

Выберем \( L=0,5 \) в качестве разумного начального приближения. Это означает, что мы собираемся использовать поправку вдвое меньшей величины, чем без сглаживания.

Повторим шаги 1-4 для обоих жуков, используя начальное значение \( А=0,25 \).

Тестирование божьей коровки \( (x,y) = (3, 1) \) дает нам:

1. Вычисленное значение

   \(у = 0.25 \cdot 3 = 0.75 \)

2. При целевом значении \(y_э = 1.1 \) ошибка \( e = 0.35 \)

3. Поправка равна

   \( D = L \frac{e}{х} = 0.5 \frac{0,35}{3} = 0.0583 \)

4. Обновленное значение

   \( А = 0.25 + 0.0583 = 0.3083 \)

   В итоге на первом жуке уравнение прямой преобразуется к виду

   \( y = 0.3083x\)

Проведём расчеты с новым значением \( А \) для гусеницы \( (x,y) = (1, 3) \).

1. Вычисленное значение

   \(у = 0.3083 \cdot 1 = 0.3083 \)

2. При целевом значении \(y_э = 2.9 \) ошибка \( e = 2.9 - 0.3083 = 2.5917 \)

3. Поправка равна

   \( D = L \frac{e}{х} = 0.5 \frac{2.5917}{1} = 1.2958 \)

4. Теперь обновленное значение

   \( А = 0.3083 + 1.2958 = 1.6042 \)

   В итоге на втором жуке уравнение прямой преобразуется к виду

   \( y = 1.6042x\)

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

Результат настройки классификатора с коэффициентов обучения=0.5. Изображение из (1)

Это действительно отличный результат!

Всего лишь с двумя простыми тренировочными данными и относительно простым методом обновления мы, используя сглаживание поправки на основе скорости обучения, смогли очень быстро получить хорошую разделительную линию \( у=Ах \).

Теперь подав на вход данного классификатора некоторого жука \( (x,y) \), мы сможем определить, гусеница он или божья коровка, лишь взглянув на график. Стоит отметить, что классификатор будет тем лучше настроен, чем больше эталонных данных он обработает.

Реализация на Scilab настройки линейного классификатора по эталонной выборке

Для начала, создадим массив с жуками

Далее, чтобы не привязываться к размерностям и без опаски добавлять\удалять элементы выборки, узнаем число строк в матрице:

Пусть тренировочная выборка составляет 40% от всей выборки - на ней будем настраивать классификатор, на остальных 60% будем проверять классификатор:

Зададим начальный коэффициент классификатора \( A \), скорость обучения \( L \), величину поправки \( d \):

Проведём в цикле обучение на тренировочной выборке:

Функция проверки "божья ли коровка попалась" имеет вид:

Чтобы посмотреть, как прошла тренировка классификатора, нарисуем жуков, покрасив божьих коровок красным, на которых тренировались и сам классификатор:

Результат настройки классифкатора и данные из обучающей выборки.

А теперь посмотрим, как классификатор разделяет оставшихся жуков:

Результат настройки классифкатора и данные из экспериментальной выборки.

Прекрасно справляется. В конец выборки можно подобавлять значения и посмотреть, как справляется классификатор. А также, рекомендуется поизменять размер тренировочной выборки и параметры \( d \) и \( L \) .

Данная статья создана на основе чудесной книги(1) с реализацией автором приведённых примеров на Scilab.

Оригинальный адрес статьи: http://inclab.ru/articles/nastroyka-lineynogo-klassifikatora-scilab

]]> Fri, 27 May 2022 20:58:33 +0400 http://inclab.ru/articles/animaciya-stabilizacii-mayatnika-v-scilab http://inclab.ru/articles/animaciya-stabilizacii-mayatnika-v-scilab Стабилизация программной позиции маятника путём линеаризации уравнений в отклонениях

На примере простой механической системы посмотрим, как "оживить" картинки в Scilab без дополнительных плагинов и без использования comet().

Будем стабилизировать простой математический маятник.

Рисунок. Математический маятник.

Уравнения которого имеют вид.

\( \ddot{\theta} + b\dot{\theta} + asin\theta = cT \)

Стабилизировать маятник будем в программной позиции \( \theta = \delta=const \) с помощью вращающего момента: \( T = u \)

\( \ddot{\theta} + b\dot{\theta} + asin\theta = cu \) (1)

Найдём программное управление \( u^p \)

Программное управление \( u^p \) - это управление, которое обеспечивает программную позицию, т.е. отклоняет маятник на угол \( \delta \). Подставим \( \theta = \delta \) в (1):

\( \ddot{\delta} + b\dot{\delta} + asin\delta = cu^p \)

Так как угол \( \delta \) - это постояннная величина, ведь мы хотим, чтобы маятник остановился в таком положении, её производные будут равны 0, следовательно:

\( 0 + 0 + asin\delta = cu^p \)

Откуда можно выразить искомое программное управление \( u^p \):

\( u^p = \frac{a}{c}sin\delta\) (2)

Перейдём к системе д.у.

Подробно переход к системе ДУ рассматривается в этом материале.

Введём фазовые координаты:

\( x_1 = \theta, x_2 = \dot{\theta} \)

Тогда исходное уравнение (1) второго порядка сведётся к системе из двух дифференциальных уравнений первого порядка:

\begin{cases} \dot{x_1} = x_2 \\ \dot{x_2} = cu - bx_2 - asinx_1 \quad (3)\end{cases}

Программная позиция для системы

Наша задача - обеспечить скорейшую остановку маятника в заданной позиции, т.е. перевести маятник в позицию \( \theta = \delta \), где скорость=0. Запишем это условие для фазовых координат

\( x_1 = \delta, x_2 = \dot{\delta} = 0 \)

Итак, для системы (3) нас интересует позиция:

\begin{cases} \dot{x_1} = \delta \\ \dot{x_2} = 0 \quad (4) \end{cases}

Для того, чтобы к системе (3) можно было применят теоремы об асимтотической устойчивости нулевого положения равновесия, нам неоходимо перенести систему коордиинат в точку, где позиция \( (\delta, 0) \) - это нуль.

Переход к системе в отклонениях

Введём отклонения от программной позиции (4) в системе (3):

\begin{cases} y_1 = x_1 - \delta \\ y_2 =x_2 - 0 \end{cases} (5) \begin{cases} x_1 = y_1 + \delta \\ x_2 =y_2 \end{cases}

Подставим (5) в (3), тогда система в отклонениях примет вид:

\begin{cases} \dot{y_1} = y_2 \\ \dot{y_2} = cu - by_2 - asin\left( y_1 + \delta \right) \end{cases}

Корректировка управляющего воздействия

Как правило, для эффективного управления динамическими системами одного программного управления \( u^p \) бывает недостаточно из-за неточностей в измерениях и влияния внешних источников, поэтому мы введём добавочное стабилизирующее управление \( u^{st}\) :

\( u = u^p + u^{st} \)

Тогда системе в отклонениях получим:

\begin{cases} \dot{y_1} = y_2 \\ \dot{y_2} = c\left( u^p + u^{st} \right) - by_2 - asin\left( y_1 + \delta \right) \end{cases}, или \begin{cases} \dot{y_1} = y_2 \\ \dot{y_2} = c \cdot \frac{a}{c} sin\delta\ + c \cdot u^{st} - by_2 - asin\left( y_1 + \delta \right) \end{cases}, что приводит к \begin{cases} \dot{y_1} = y_2 \\ \dot{y_2} = asin\delta\ + cu^{st} - by_2 - asin\left( y_1 + \delta \right) \quad (6) \end{cases}

Линеаризация системы в отклонениях

Так как эффективнее всего теоремы об устойчивости работают для линейных систем, начнём с линеаризации системы (6).

Разложжим \( sin\left( y_1 + \delta \right) \) в окрестности нуля:

\( sin\left( y_1 + \delta \right) \sim y_1cos(\delta) + sin\delta \)

Подставляя данное разложение в (6), получим:

\begin{cases} \dot{y_1} = y_2 \\ \dot{y_2} = asin\delta\ + cu^{st} - by_2 - ay_1cos(\delta) - asin\delta \end{cases}

Таким образом, система (6) примет вид:

\begin{cases} \dot{y_1} = y_2 \\ \dot{y_2} = - acos(\delta)y_1 - by_2 + cu^{st} \quad (7) \end{cases}

Запишем систему (7) в векторно-матричном виде, чтобы с ней было бы удобнее работать:

\begin{matrix} \dot y= { \begin{pmatrix} 0 & 1 \\ - acos(\delta) & -b \end{pmatrix} } y + { \begin{pmatrix} 0 \\ c \end{pmatrix} } u^{st} \quad (8) \end{matrix}

Найдём стабилизирующее управление \(u^{st} \)

Прежде всего, сделаем из системы (8) однородную систему. Для этого выберем \(u^{st} \) вида:

\( u^{st}= -Ky, \quad K = (k_1, k_2) \quad (9) \)

и подставив (9) в (8), получим чудесную линейную однородную систему дифуров:

\begin{matrix} \dot y= { \begin{pmatrix} 0 & 1 \\ - acos(\delta)-сk_1 & -b-ck_2 \end{pmatrix} } y \quad (10) \end{matrix}

Стабилизиирующее управление \(u^{st} \) - это управление, которое стабилизирует систему. То есть обеспечивает асимтотическую устойчивость нулевого положения равновесия этой системы.

В обычных условиях, система (10) сосвем не обязательно будет ас. устойчивой, но чтобы победить эту несправедливость мы и ввели управление \(u^{st} \) в виде \( u^{st}= -Ky \), подрегулировав значения \(k_j \) которого, мы добьёмся того, чтобы корни характеристического уравнения системы (10) были бы "левыми".

Значения \(k_j \), кстати, называются коэфффицентами усиления.

Итак, нам предстоит найти условия на основе \(k_j \), при которых собственные значения матрицы

\begin{matrix} { \begin{pmatrix} 0 & 1 \\ - acos(\delta)-сk_1 & -b-ck_2 \end{pmatrix} } \quad (11) \end{matrix}

были бы расположены в левой полуплоскости комплекной плоскости.

Условия гурвицевости матрицы (11)

Чтобы не утруждаться поиском с.з. и с.в. матрицы (11), воспользуемся критерием асисмтотической устойчивости вида:

\begin{cases} trA < 0 \\ |A| > 0 \end{cases}

Откуда получим условия на \(k_1 \) и \(k_2 \) :

\begin{cases} k_2 > -\frac{b}{c} < 0 \\ k_1 > \frac{a}{c}cos(\delta) \end{cases}

Итак, выбирая стабилизирующее упарвление в виде:

\(u^{st} = -k_1y_1 - k_2y_2 \)

мы добьёмся стабилизации линейной системы в отклонениях (7), что, в свою очередь будет значить схождение моделируемого движения маятника к программной позиции при решении задачи стабилизации положения равновесия, где управление будет складываться из программного и стабилизирующего управлений

\(u = u^p + u^{st} \)

Программная реализация

Приступим, наконец, к моделированию процесса стабилизации математического маятника в Scilab. Для этого нам понадобятся:

• Система (3)
• Управление (2)
• Управление (12)
• Замена (5)

Сначала зададим параметры, фигурирующие в системе:

Далее зададим программное положение \(\delta \) и пaраметры стабилизирующего управления \(k_j \):

Зададим начальные условия, шаг дискретизации и отрезок интегрирования для решения системы ОДУ в Scilab:

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

Этого, в принципе, достаточно, чтобы получить статическую графическую интерпретацию решения нашей задачи.

Координата и скорость маятника под действием управления, (к1, к2) = (0.1, 10)

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

Координата и скорость маятника под действием управления, (к1, к2) = (0.1, 50)

При этом, без управления маятник будет бултыхаться довольно долго и остановится в устойчивом положении равновесия (0,0):

Координата и скорость маятника без управляющего воздейсвтия

Создание анимации движения в Scilab

Пойдём дальше и приступим к реализации движущегося объекта.

Для начала, повернём сетку координат на 90 градусов, чтобы маятник смотрела вниз :)

Добавим звёздочки на координатную сетку - начальное положение и программную позицию маятника

И изобразим маятник в исходном положении с помощью ломаной линии с координатами \( (0, 0) - ( L*cos(X_r(1,1)), L*sin(X_r(1,1)) ) \):

Далее отредактируем параметры элемента xpoly(). Наличие соединений mark имитирует груз на конце стержня маятника, mark_style = 9 говорит, что это кружочек, а mark_offset = 1 отвечает за смещение кружочка относительно линии:

Прямая с кружочком

Приступим к имитации движения маятника. Его траектория - это решени системы ОДУ, т.е. элементы матрицы X_r. В первой строке этой матрицы содержится координата маятника \( X_1 = \theta \) в момент времени \( i \), а во второй строке - скорость маятника \( X_2 = \dot\theta \) в этот момент времени. Нам нужна координата для изменения позиции палочки с кружком, причём, центр маятника так и будет оставаться в положении \( (0,0) \), двигаться же будет его не закреплённый конец:

Под действием выбранного управления, маятник быстренько стабилизируется и не бултыхается безумно:

Стабилизация маятника с управлением

Если же в теле функции systNelin() исключить найденное управление из процеса стабилизации маятника, получим поведения объекта под действием на него исходных внешних сил:

Стандартное поведение маятника

Оригинальный адрес статьи: http://inclab.ru/articles/animaciya-stabilizacii-mayatnika-v-scilab

]]> Fri, 27 May 2022 17:26:28 +0400 http://inclab.ru/articles/markovskiy-sluchaynyy-process-s-diskretnymi-sostoyaniyami http://inclab.ru/articles/markovskiy-sluchaynyy-process-s-diskretnymi-sostoyaniyami При моделировании информационных систем часто встречаются ситуации, которые указать заранее невозможно.

Непрерывная цепь Маркова

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

В данной ситуации не удастся обойтись детерминированной матрицей переходов, как в дискретном случае ведь вероятность \(p_{i}\) оказаться в состоянии \(S_i\) будет функцией времени, то есть:

\(p_{i}(t) = p(S_i(t)) \quad i = 1,...,n, \quad t \geq 0 \)

Более того, вместо вероятности перехода \(p_{ij}\), мы теперь будем говорить о плотности вероятности перехода \(\lambda_{ij}(t)\) из состояния \(S_i\) в состояние \(S_j\) в момент времени t:

\( \lambda_{ij}(t) = \displaystyle\lim_{\Delta t \to 0} \frac{p_{ij}(t,\Delta t)}{\Delta t} \)

которая запросто может становиться больше 1.

Вероятности \(\lambda_{ij}(t)\) будут составлять матрицу плотностей вероятностей переходов:

\begin{matrix} \Lambda= { \begin{pmatrix} \lambda_{11}(t) & \lambda_{12}(t) & ... & \lambda_{1n}(t) \\ ... & ... & ... & ... \\ \lambda_{n1}(t) & \lambda_{n2}(t) & ... & \lambda_{nn}(t) \end{pmatrix} \quad (1)} \end{matrix}

Однако, несмотря на то, что всё меняется, некоторые вещи остаются неизменными, но становятся другими :)

В случае с непрерывным временем тоже будет иметь место равенство суммы вероятностей 1, которое будем называть нормировочным условием:

\( \displaystyle\sum_{i=1}^{n} p_{i}(t) = 1, \quad \forall t \geq 0 \quad (2) \)

Как же отыскать \(p_{i}(t)\), если они в явном виде нигде не заданы?

Здесь на помощь приходят дифференциальные уравнения Колмагорова, которые и помогут найти исходные \(p_{i}(t)\).

Итак, вероятности состояний \(p_{i}(t)\) - это решение системы дифференциальных уравнений вида:

\( \displaystyle\frac{dp_{i}(t)}{dt} = \displaystyle\sum_{j=1}^{n} \lambda_{ji}(t)\cdot p_{j}(t) - \displaystyle\sum_{j=1}^{n} \lambda_{ij}(t)\cdot p_{i}(t) \quad (3) \)

Рассмотрим подробнее, что из себя представляет 1-е уравнение системы (3). Для этого заменим все \( i \) на 1 в (3):

\( \displaystyle\frac{dp_{1}(t)}{dt} = \displaystyle\sum_{j=1}^{n} \lambda_{j1}(t)\cdot p_{j}(t) - \displaystyle\sum_{j=1}^{n} \lambda_{1j}(t)\cdot p_{1}(t) \quad \)

Теперь стало понятно, что в сумме с плюсом надо пробежаться по 1-му столбцу матрицы (1), домножив каждый элемент на соответствующую вероятность \(p_{j}(t)\),
а в сумме с минусом надо пробежаться по 1-ой строке матрицы (1), домножив каждый элемент на вероятность \( p_{1}(t) \).

Если перевести последнее высказывание на язык графов, то получим, что:
производная вероятности 1-го состояния - это сумма произведений входящих стрелок на интенсивности соответствующих потоков
минус сумма произведений исходящих стрелок на интенсивность 1-го потока.

Отсюда можно вывести правило составлений уранений Колмагорова:

• В левой части каждого из них стоит производная вероятности i-го состояния.

• В правой части
  с плюсом - суммарная интенсивность всех потоков, приводящих систему в данное состояние:
  с минусом - суммарная интенсивность всех потоков, выводящих систему из данного состояния.

Финальные вероятности

Уравнения Колмогорова дают возможность найти все вероятности состояний как функции времени. Особый интерес представляют вероятности системы в предельном стационарном режиме, т.е. при \( t \to \infty \), которые называются предельными (или финальными) вероятностями состояний.

Финальные вероятности состояний находятся путем решения СЛАУ, которые получаются из дифференциальных уравнений Колмогорова (3), если приравнять производные к нулю, а вероятностные функции состояний \( p_1(t),..., p_n(t) \) в правых частях уравнений заменить соответственно на неизвестные финальные вероятности \( p_1^*(t),..., p_n^*(t) \) и добавить нормировочное условие (2).

\( \begin{cases} 0 = \displaystyle\sum_{j=1}^{n} \lambda_{ji}(t)\cdot p^*_{j} - \displaystyle\sum_{j=1}^{n} \lambda_{ij}(t)\cdot p^*_{i} \quad \\ \displaystyle\sum_{i=1}^{n} p^*_{i} = 1 \end{cases} \)

Модель взаимодействия копмонент ПО средств активной защиты

Рассмотрим процесс активной защиты информационной компьютерной системы, в которой функционируют 5 комплексов программ.

Пусть плотности вероятности \(\lambda_{ij}\) описывают интенсивность передачи управления от \(i\)-го компекса ПО к \(j\)-му в процессе решения задач активной защиты КС.

Предположим, что \(\lambda_{ij}\) задаются в виде:

\( \lambda_{12} = \frac{1}{T_1}; \lambda_{21} = \frac{1-\alpha}{T_2}; \lambda_{23} = \frac{\alpha}{T_2}; \lambda_{34} = \frac{1}{T_3}; \)
\( \lambda_{43} = \frac{1-\beta}{T_4}; \lambda_{45} = \frac{\beta}{T_4}; \lambda_{51} = \frac{1}{T_5}; \)

где \(\alpha\) - вероятность того, что вторжение злоумышленника бедут распознано САЗ,
\(\beta\) - вероятность того, что выявленная уязвимость в КС будет использована для ответных атак.

Через \( p_i(t) \) зададим вероятность того, что в момент времени \( t\) в КС выполняется \(i\)-й компекс программ.

Пусть взаимодействие комплексов ПО в КС описывается с помощью графа на рис.1

Рисунок 1. Граф связи комплексов ПО в КС.

Тогда соответствующая система ДУ Колмагорова будет иметь вид:

\( \begin{cases} \dot p_1 = -\lambda_{12}p_1 + \lambda_{21}p_2 + \lambda_{51}p_5 \\ \dot p_2 = \lambda_{12}p_1 - (\lambda_{21} + \lambda_{23})p_2 \\ \dot p_3 = \lambda_{23}p_2 - \lambda_{34}p_3 + \lambda_{43}p_4 \\ \dot p_4 = \lambda_{34}p_3 - (\lambda_{43} + \lambda_{45})p_4 \\ \dot p_5 = \lambda_{45}p_4 - \lambda_{51}p_5 \end{cases} (4) \)

Для того, чтобы с уравнениями Колмагорова было удобнее работать в Scilab, перепишем систему (4) в матричном виде:

\begin{matrix} \dot p = { \begin{pmatrix} -\lambda_{12} & \lambda_{21} & 0 & 0 & \lambda_{51}\\ \lambda_{12} & -(\lambda_{21} + \lambda_{23}) & 0 & 0 & 0\\ 0 & \lambda_{23} & -\lambda_{34} & \lambda_{43} & 0\\ 0 & 0 & \lambda_{34} & - (\lambda_{43} + \lambda_{45}) & 0\\ 0 & 0 & 0 & \lambda_{45} & -\lambda_{51}\\ \end{pmatrix} }p \quad (5) \end{matrix}

Кратко:

\( \dot p = Bp \)

Зададим начальные условия для системы (5), т.е. вектор начального состояния (6):

\( p_0 = (1, 0, 0, 0, 0) \quad (6) \)

Решение ДУ Колмагорова в Scilab

Решим задачу Коши для системы (5), с н.у. (6) в Scilab.

Решение данной задачи почти не отличается от рассмотренных ранее двумерных систем.

Единственное нововведение - это замена в матрице системы (5) одной из строк на нормировочное условие (2). Это необходимо сделать, т.к. пара уравнений в (5) являются линейно зависимыми.

На рис.2 представлены интегральне кривые системы (5), которые и представляют собой вероятности состояний КС как функции времени.

Рисунок 2.Решение ДУ Колмагорова.

Решение СЛАУ Колмагорова в Scilab

Так как марковский процесс, описывающий взаимодействие компонент ПО САЗ не имеет поглощающих состояний (см. рис.1), то с некоторого момента времени все компоненты КС будут функционировать в стационарном режиме, достигнув финальных вероятностей.

Найдём финальные вероятности \( p_i^* \). Для этого в системе (5) приравняем производные к нулю и решим СЛАУ с условием нормировки (2):

\( \begin{cases} 0 = { \begin{pmatrix} -\lambda_{12} & \lambda_{21} & 0 & 0 & \lambda_{51}\\ \lambda_{12} & -(\lambda_{21} + \lambda_{23}) & 0 & 0 & 0\\ 0 & \lambda_{23} & -\lambda_{34} & \lambda_{43} & 0\\ 0 & 0 & \lambda_{34} & - (\lambda_{43} + \lambda_{45}) & 0\\ 0 & 0 & 0 & \lambda_{45} & -\lambda_{51}\\ \end{pmatrix} }p^* \\ 1 = p_1^* +p_2^* + p_3^* + p_4^* + p_5^* \quad \end{cases} (7) \)

Чтобы не запутаться в последовательности линейных преобразований в системе (7), поручим эти действия Scilab.

Прежде всего, приведём матрицу B к ступенчатому виду. Для этого в Scilab имется функция rref:

Убедимся, что rB действительно ступенчатая да ещё и с одной нулевой строкой (вспомните про ЛЗ уравнений в (5) ) :

Рисунок 3.Ступенчатый вид матрицы В.

Далее нам необходимо заменить последнюю строку матрицы на условие нормировки (2). Это условие выражено 6-м уравнением в системе (7). В нём фигурируют все элементы вектора p с коэффициентами 1. Поэтому последняя строка ступенчатой матрицы превратится в строку единиц.
Последнюю строку матрицы в Scilab можно отыскать с помощью символа $

Рисунок 4.Ступенчатая матрица со строкой из 1.

Осталось лишь численно решить систему алгебраических уравнений.
В Scilab для решения системы линейных уравнений припасена функция linsolve(A, b), которая ищет вектор x в системе уравнений вида:

\( A*x + b = 0 \)

В нашем случае первый аргумемнт функции linsolve(*, *) - это матрица rB, а второй аргумент - это вектор f, сформированный из неоднородностей системы (7), перенесённых за знак "=".

Нарисуем финальные вероятности \( p_i^* \), чтобы убедиться, что именно к ним сходится решение ДУ Колмагорова:

Рисунок 5.Выход на финальные вероятности интегральных кривых.

Итак, где-то с 90сек. ПО в системе активной защиты КС будет функционировать в установившемся режиме.

Оригинальный адрес статьи: http://inclab.ru/articles/markovskiy-sluchaynyy-process-s-diskretnymi-sostoyaniyami

]]> Thu, 12 May 2022 12:40:00 +0400 http://inclab.ru/articles/realizaciya-markovskoy-cepi http://inclab.ru/articles/realizaciya-markovskoy-cepi

Марковский случайный процесс с дискретным состоянием и дискретным временем

Предположим, что автоматизированная информационная системы может находиться в следующих n состояниях \( S_1, S_2, . . . , S_n\). При этом переход системы из i-го состояния в j-е характеризуется вероятностью \(p_{ij}\), где i, j = 1, 2, . . . , n.

Поскольку система может пребывать в одном из состояний, то для каждого момента времени t необходимо задать \(n^2\) вероятностей перехода \(p_{ij}\), которые удобно представить в виде следующей матрицы:

\begin{matrix} P= { \begin{pmatrix} p_{11} & p_{12} & ... & p_{1n} \\ p_{21} & p_{22} & ... & p_{2n} \\ ... & ... & ... & ... \\ p_{n1} & p_{n2} & ... & p_{nn} \end{pmatrix} (1)} \end{matrix}

Матрица (1) называется матрицей перехода системы.

В матрице перехода располагаются:
\(p_{ij} \) - вероятность перехода системы за один шаг из состояния \(S_i\) в состояние \(S_j\);
\(p_{ii}\) - вероятность задержки системы в состоянии \(S_i\).

Таким образом, в обозначении \(p_{ij} \) первый индекс указывает номер предшествующего состояния, а второй номер последующего.

Переходной вероятностью \(p_{ij} \) называют условную вероятность того, что из состояния \(S_i\), в котором система оказалась в результате некоторого испытания, безразлично какого номера, в итоге следующего испытания система перейдет в состояние \(S_j\).

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

\( \displaystyle\sum_{j=1}^{n} p_{ij} = 1, \quad i = \bar{1,n} \)

Марковский случайный процесс с дискретными состояниями и дискретным временем называют марковской цепью.
Для такого процесса моменты \( t_1, t_2, ...\), когда система может менять свое состояние, рассматривают как последовательные шаги процесса, а в качестве аргумента, от которого зависит процесс, выступает не время \( t\), а номер шага \( 1, 2, ... , k, ... \).

Случайный процесс в этом случае характеризуется последовательностью состояний \( S(0), S(1), S(2), ... , S(k), ... \), где
\(S(0)\) - начальное состояние системы (перед первым шагом);
\(S(1)\) - состояние системы после первого шага;
\(S(k)\) - состояние системы после k-го шага.

Вероятностями перехода системы за \( k \) шагов из \(S_i\) состояния в \(S_j\) называются вероятности \( P_{ij}(k) \) того, что в результате \( k \) шагов система перейдет из состояния \( S(0) = S_i \) в состояние \( S(k) = S_j \) \( i, j = 1, 2, ... \).

Например, \( P_{36}(8) \) - вероятность того, что за 8 шагов система перейдет из состояния \(S_3\) в \(S_6\).

Заметим, что при \(n = 1 \) вероятности состояний цепи Маркова \( P_{ij}(1) \) совпадают с переходными вероятностями \( p_{ij} \).

Кроме того, как и в случае (1) должно выполняться равенство:

\( \displaystyle\sum_{j=1}^{n} P_{ij}(k) = 1, \quad i = \bar{1,n}, \quad \forall k \quad\quad (2) \)

Начальным распределением вероятностей Марковской цепи называется распределение вероятностей состояний в начале процесса:

\( p_1(0), p_2(0), ... , p_n(0) \quad\quad (3) \).

Если для однородной Марковской цепи заданы начальное распределение вероятностей (3) и матрица P переходных вероятностей (1), то вероятности состояний системы \( p_i(k) (i = 1, 2, . . . ,) \) определяются по рекуррентной формуле:

\( p_{i}(k) = \displaystyle\sum_{j=1}^{n} p_{ji} \cdot p_{j}(k-1) = 1 \quad\quad (4) \)

Итак, у нас имеются:

• Вектор \( (p_1(0), p_2(0), ... , p_n(0)) \) начального распределения (3). Это вероятности стартовать из каждого из состояний.

• Переходные вероятности \( p_{ij} \). Это вероятности перейти из состояния \(S_i\) в \(S_j\) за 1 шаг. Из \( p_{ij} \) составлена матрица перехода (1).

• Вероятности состояний системы \( p_{i}(k) \). Это вероятности оказаться в состояния \(S_i\) через \( k \) шагов.

• Чудесная формула (4), по которой, зная начальное положение системы, можно рассчитать вероятность оказаться в том или ином состоянии через определённое число шагов.

Моделирование АИС с двумя зависимыми внутренними угрозами с помощью цепи Маркова

Пусть дана информационная система с двумя зависимыми внутренними угрозами, орграф которой изображен на рис. 1.

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

1. Неквалифицированная политика по управлению информационной безопасностью организации;

2. Отсутствие должной квалификации персонала по обеспечению деятельности и управлению информационной безопасностью.

Рисунок 1. Граф переходов (состояний) АИС с двумя зависимыми внутренними угрозами.

Данная система моделируется Марковской цепью. Она содержит невозвратные состояния, называемые поглощающими. Из поглощающего состояния нельзя перейти ни в какое другое. На графе поглощающему состоянию соответствует вершина, из которой не выходит ни одна дуга. Поглощающему состоянию соответствует вероятность, равная 1.

Пусть наша система может находиться в одном из четырех состояний:

• \(S_1\) - состояние, в котором внутренние угрозы ИБ не проявились,

• \(S_2\) - состояние, в котором первая внутренняя угроза ИБ проявилась с вероятность \(p_{12}\),

• \(S_3\) - состояние, в котором вторая внутренняя угроза ИБ проявилась с вероятность \(p_{13}\),

• \(S_4\) - поглощающее состояние, в котором внутренние угрозы ИБ реализовались с вероятностями \(p_{24}\) и \(p_{34}\) соответственно.

Для данной системы у нас заданы:

• Вектор начального распределения:

  \( (p_1(0), p_2(0), p_3(0) , p_4(0)) = (1, 0, 0, 0) \)

  То есть, при запуске, мы стартуем всегда из 1-го состояния.

• Матрица перехода:

  \begin{matrix} P= { \begin{pmatrix} 0,2 & 0,3 & 0,5 & 0 \\ 0,4 & 0 & 0,3 & 0,3 \\ 0,1 & 0,4 & 0 & 0,5 \\ 0 & 0 & 0 & 1 \end{pmatrix} } \end{matrix}

А выяснить мы хотим вероятности состояний информационной системы через три шага, воспользовавшись формулой (4).

Приступим к реализации на scilab пошагового моделирования марковского процесса.

Зададим вектор начального распределения Po и матрицу вероятностей перехода P.

А далее итерационно воспользуемся формулой (4), бережно сохранив промежуточные результаты в Y.

В консоли можно наблюдать за изменением вероятностей оказаться в каждом из 4-х состояний на 1,2 и 3-м шагах:

Рисунок 2. Изменение вероятностей состояния на каждом шаге.

Если же число шагов увеличить до 10, то можно наблюдать, как система все вероятнее перейдёт в поглошающее 4-е состояние.

Рисунок 3. С ростом числа испытаний, вероятность оказаться в S4 возрастает.

Отдельно стоит отметить, что сумма элементов вектора = 1.

Для пущей наглядности сходимости вероятностей, построим графики зависимости вероятностей Pj от числа шагов.

Рисунок 3. Распределение вероятностей состояний в зависимости от шага.

Серия экспериментов для цепи Маркова, граф которой изображён на рис.1

Посмотрим, действительно ли состояние 4 будет являться поглощающим в различных условиях. Для этого сгенерируем 9 случайных векторов состояний и, стартуя каждый раз из 1-го состояния, промоделируем поведение Марковской цепи с заданной матрицей перехода на протяжении 10-ти шагов.

Ниже моделирование цепи повторяется 9 раз.

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

Рисунок 4. Моделирование цепи Маркова для АИС с 2-мя угрозами.

Оригинальный адрес статьи: http://inclab.ru/articles/realizaciya-markovskoy-cepi

]]> Sun, 08 May 2022 21:02:40 +0400 http://inclab.ru/articles/modelirovanie-upravlyaemoy-sistemy-v-scilab-xcos http://inclab.ru/articles/modelirovanie-upravlyaemoy-sistemy-v-scilab-xcos

Итак, на данный момент читатель последовательно прошёл путь от создания простейшей блок-схемы Xcos, состоящей всего из трёх блоков, до визуального моделирования полноценных управляемых динамических систем, описываемых матричными уравнениями.

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

Данная задача особенно актуальна, так как при моделировании управляющего воздействия динамической системы, как бы удобно ни было управлять состоянием \( x\), его измерение, чаще всего не доступно. Поэтому на практике для управляемых динамических систем строится специальный наблюдатель \( y\), который сам по себе представляет динамическую систему.

Построение непрерывного наблюдателя

Построение системы наблюдения происходит так, чтобы на вход наблюдателя подавались значения  \( u,y\), а на выходе формировался бы сигнал \( \hat{x} \). При этом, матрицы системы наблюдения должны быть подобраны таким образом, чтобы разность \( x-\hat{x} \) стремилась бы к нулю не зависимо от выбранных начальных условий или самого вида наблюдателя. Отличительной особенностью наблюдателей такого рода, является устойчивость к возмущениям.

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

Рассмотрим пример построения линейного наблюдателя для динамической системы, описываемой в пространстве состояний матричными дифференциальными уравнениями вида:

(1) \[ \begin{cases} \dot x = Ax+Bu\\ \dot y = Cx\\ \end{cases} \]

где \(A, B, C\) - матрицы с постоянными коэффициентами.

Непрерывный наблюдатель в данном случае, строится следующим образом:

(2) \[ \dot{\hat{x}} = A\hat{x}+Bu+K(y-C\hat{x})\]

при этом, элементы матрицы усиления \( K \) выбираются так, чтобы матрица \( H=A-KC \) была бы устойчивой, то есть, все собственные значения матрицы \( H \) должны иметь отрицательные действительные части.
Построение матрицы \( H \) становится очевидным, если в (1) раскрыть скобки:

\[ \dot{\hat{x}} = A\hat{x}+Bu+Ky-KC\hat{x} = (A-KC)\hat{x} + Bu + Ky \]

Далее определнмся, почему требование устойчивости матрицы \( H \) обеспечивает сходимость к нулю разности \( x-\hat{x} \) .

Введём обозначение \( \widetilde{x} = x-\hat{x} \), тогда \( \dot{\widetilde{x}} = \dot{x}-\dot{\hat{x}} \). Из системы (1) имеем:

\[ \dot{x} = Ax+Bu, y=Cx \]

В уравнении (2), раскрывая скобки, получим:

\[ \dot{\hat{x}} = A\hat{x}+Bu+Ky-KC\hat{x} \]

Теперь вычислим \( \dot{\widetilde{x}} \) :

\[ \dot{\widetilde{x}} = \dot{x}-\dot{\hat{x}} = Ax+Bu - (A\hat{x}+Bu+Ky-KC\hat{x} ) = A - A\hat{x} - Ky + KC\hat{x}= \] \[ = A(x-\hat{x}) - KCx + KC\hat{x}= A(x-\hat{x}) - KC(x-\hat{x}) = (A- KC)\widetilde{x}\]

Таким образом, приходим к однородной системе матричных дифференциальных уравнений с постоянными коэффициентами вида:

\[ \dot{\widetilde{x}} = (A-KC) \widetilde{x}, \quad\quad \text{или} \quad\quad \dot{\widetilde{x}} = H \widetilde{x} \]

об устойчивость решения \( \widetilde{x} \) которой, можно судить по виду корней соответствующего характеристического уравнения \( \chi (\lambda) = |H-\lambda E| \).

Итак, с обоснованием корректности построения описанного непрерывного наблюдателя покончено, перейдём теперь к реализации блок-схемы Xcos.

Для моделирования системы (24) с непрерывным наблюдателем (25) потребуются блоки GENSIN_f и CLOCK_c с палитры «Источники сигналов и воздействий», блоки CSСOPE и END с палитры «Регистрирующие устройства», и блок CLSS с палитры «Системы с непрерывным временем».

Моделирование данной системы подразумевает задание матриц \( A, B, C, D \) , которые используются в блоке CLSS. В нашем случае все элементы матриц некоторые случайные константы, поэтому мы можем их задать в контексте с помощью генератора случайных чисел с некоторыми поправками.

Для начала зададим размерности матрицы в контексте:

и сгенерируем матрицу размерности nxn:

Для того, чтобы избежать экспоненциальной неустойчивости рассматриваемой системы, изменим матрицу \( A\) так, чтобы каждый из её элементов, стоящих на главной диагонали, не превышал бы собственного значения с максимальной действительной частью \( \widetilde{\lambda} \).
Введём обозначение \( \widetilde{\lambda} = max_{j}{(Re(\lambda_j))} \) , тогда матрица \( \widetilde{A}\) будет вычисляться как \( \widetilde{A} = A- \widetilde{\lambda}E \). В контексте данное равенство реализуется следующим образом:

где функция spec(A) – вычисляет собственные значения матрица , функция real() – выделяет действительную часть своего аргумента, функция max() вычисляет максимальное из поданных в неё значений, а eye() – генерирует единичную матрицу совместной размерности.

Далее сгенерируем матрицы совместных размерностей \( B, C, D \):

И вектор-столбец \( x^0 \) случайных начальных условий:

Для генерации матрицы усиления воспользуемся встроенной Scilab – функцией ppol(A,B,v), которая по заданным матрицам \( A,B \) и вектору полюсов \( v \) подбирает элементы матрицы \( K \) так, чтобы собственные значения матрицы \(A-BK\) были бы полюсами.
Однако для нашего наблюдателя должно выполняться то же условие, но для уравнения \( A-KC \), поэтому в контекст необходимо добавить строку:

где символ «\( ' \) » означает транспонирование матрицы, а функция ones() возвращает матрицу составленную из единиц того же размера, что и вектор \( x^0 \).

Теперь необходимо собрать все сгенерированные матрицы в систему, что делается с помощью функции syslin(dom,A,B,C [,D [,x0] ]), которая генерирует систему вида

\[ \begin{cases} s \cdot x = Ax+Bu\\ y = Cx + Du\\ x(0)=X0\\ \end{cases} \]

После задания в контексте всех необходимых параметров системы, нужно перейти к редактированию внутренних параметров блока CLSS, где необходимо задать правильные матрицы:

Рисунок 101.Внутренние параметры блока CLSS при моделировании системы (1)-(2)

Блок схема, реализующая моделирование системы имеет несложный вид:

Рисунок 102а.Блок-схема системы с непрерывным наблюдателем

Результат моделирования представлен на рисунке 102(б):

Рисунок 102б. Графики 3-х фазовых переменных и двумерный наблюдатель

Построение дискретного наблюдателя

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

Построение дискретного наблюдателя подчиняется тем же правилам, что непрерывного, основанных на получении полюсов в качестве собственных значений матрицы \(H = A-KC \).

Поэтому алгоритм, прописанный на данный момент в контексте рабочей области, полностью удовлетворяет нашим требованиям. Остаётся только задать шаг дискретизации и дикретизировать полученную систему \( SYST \) . Для этого добавьте в контекст строки:

где Scilab-функция dscr() производит дискретизацию непрерывной системы \( SYST \) с указанным шагом , \( dt \) а встроенная функция abcd() возвращает 4 матрицы \( A,B,C,D \) , использующиеся в поданной на вход дискретной системе и записывает их в соответствующие выходные матрицы \( Ad, Bd, Cd, Dd \) .
В итоге контекст должен принять вид:

Для внедрения дискретного наблюдателя воспользуемся блоком с палитры «Системы с дискретным временем». Кроме того нам понадобятся блоки MUX и DEMUX с палитры «Маршрутизация сигналов» и блок сумматора BIGSOM_f  с палитры «Математические операции». Блок-схема реализующая математическое моделирование системы дифференциальных уравнений с дискретным наблюдателем, представлена на рис. 103

Рисунок 103. Реализация динамической системы с дискретным наблюдателем в Xcos

Внутренние параметры блока дискретной линейной системы DLSS представлены на рис. 104

Рисунок 104. Внутренние параметры блока DLSS при моделировании дискретизированной системы (1)-(2)

Результат моделирования линейной динамической системы с дискретным наблюдателем представлен на рис. 105.

Рисунок 105. Фазовые координаты и дискретныйнаблюдатель динамической системы

Оригинальный адрес статьи: http://inclab.ru/articles/modelirovanie-upravlyaemoy-sistemy-v-scilab-xcos

]]> Mon, 10 Jan 2022 18:18:52 +0400 http://inclab.ru/articles/modelirovanie-dinamicheskih-sistem-v-matrichnom-vide-xcos http://inclab.ru/articles/modelirovanie-dinamicheskih-sistem-v-matrichnom-vide-xcos

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

• в виде последовательного интегрирования,

• в виде системы дифференциальных уравнений,

• и через передаточную функцию \( H(s)\).

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

Немного теории

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

Модель системы, построенная в пространстве состояний предполагает использование ОДУ первого порядка. Если же для описания процесса функционирования рассматриваемой системы требуется использование дифференциальных уравнений порядка выше 1, каждое из таких уравнений сводится в совокупности ОДУ первого порядка, что всегда возможно, как было сделлано с помощью пользовательских функций Scilab и блоков Xcos.

При этом, переменные, которые используются для составления дифференциальных уравнений, называются фазовыми координатами и полностью описывают динамическую систему и её реакцию на определённые входные данные. Число фазовых переменных равняется порядку ОДУ, описывающему динамическую систему. Кроме того, фазовые переменные – это как раз те переменные, для которых задаются начальные условия, число которых, как известно, также, совпадает со степенью исходного ОДУ.

Модель пространства состояний формируется из уравнений входа и выхода, где для случая управляемой линейной системы из \(n\) переменных состояния, имеющей  \(p\) входов и \(q\) выходов, матричные уравнения имеют вид:

(1) \[ \begin{cases} \dot x(t) = A(t)x(t)+B(t)u(t)\\ \dot y(t) = C(t)x(t)+D(t)u(t)\\ \end{cases} \quad\quad\text{где} \quad x(t)\in \mathbb{R}^n, y(t)\in \mathbb{R}^q, u(t)\in \mathbb{R}^p \]

\(x=(x_1,x_2,...,x_n)^T \) - вектор состояния, элементы которого называются состояниями системы,
\(y=(y_1,y_2,...,y_q)^T \)- вектор выхода,
\(u=(u_1,u_2,...,u_p)^T \)- вектор управления,
\( A_{n\times n} \)- матрица системы,
\( B_{n\times p} \)- матрица управления,
\( C_{n\times q} \)- матрица выхода,
\( D_{q\times p} \)- матрица прямой связи.

Структурная схема описанной системы представлена на рис. 89.

Рисунок 89. Структурная схема непрерывной линейной динамической системы (1)

Управление грузом на пружине с демпфером

Разобравшись с терминологией, перейдём к примерам. Рассмотрим груз массы \(m\) с закреплённой пружиной жёсткости \(k\) и демпфером с коэффициентом демпфирования \(c\), движение которого осуществляется при помощи силы \(F\)  (см. рис. 90)

Рисунок 90. Передвигаемый груз с пружиной и демпфером

Уравнения движения описанного груза имеют вид:

(2) \[ F-kx-c\frac{dx}{dt}-m\frac{d^2x}{dt^2}=0 \]

В принципе, уравнения (2) уже достаточно, чтобы собрать его блок-схему с использованием подходов, рассмотренных ранее. Однако наша цель – матрицы, которые на данном этапе не видны.

Прежде всего, определим, степень рассматриваемого уравнения. Наибольшая производная, фигурирующая в (2) – второго порядка, стало быть, перед нами ОДУ 2-го порядка.

В статье рассматривался способ решения подобного дифференциального уравнения, путём сведения его к системе. Этот подход и лежит в основе представления динамической системы в пространстве состояний. Вспомним, что мы делали:
1) переписывали уравнения так, чтобы слева от знака равно осталась наивысшая производная,
2) делали замену и получали систему.
Приступим. Преобразуем (2) к желаемому виду:

(3) \[ \ddot{x}=\frac{1}{m}\left( -c\dot x-kx+F \right) \]

Вопрос, сколько получится ОДУ первой степени из ОДУ 2-й степени? Правильно, два. Вторая степень уравнения, - два уравнения в системе. А как получить эти два уравнения? Правильно, ввести переменные состояния . Вторая степень уравнения – две переменных состояния. Введём замену:

(4)\[ \begin{cases} z_1 = x\\ z_2 = \dot x\\ \end{cases} \quad\quad \Rightarrow \begin{cases} \dot z_1 = \dot x\\ \dot z_2 = \ddot x\\ \end{cases} \]

Итак, исходно обыкновенное дифференциальное уравнение второй степени (2), путём замены (4) сводится к системе из двух ОДУ первой степени:

(5)\[ \begin{cases} \dot z_1 = z_2\\ \dot z_2 = \frac{1}{m}\left( -cz_2-kz_1+F \right) \\ \end{cases} \]

На первый раз, раскроем скобки в (5) и запишем фазовые переменные друг под другом:

\[ \begin{cases} \dot z_1 = \quad 0\cdot z_1 + \;\;\;1\cdot z_2 + 0\cdot F\\ \dot z_2 = -\frac{k}{m}\cdot z_1 -\frac{c}{m}\cdot z_2 + \frac{1}{m}\cdot F \\ \end{cases} \]

Запишем систему (5) в матричной форме:

(6) \[ \begin{pmatrix} \dot z_1 \\ \dot z_2 \end{pmatrix} = \begin{pmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{c}{m} \end{pmatrix} \begin{pmatrix} z_1 \\ z_2 \end{pmatrix} + \begin{pmatrix} 0 \\ \frac{1}{m} \end{pmatrix} F \]

Теперь, мы с лёгкостью можем определить матрицу состояний:

\[ A_{2\times 2}= \begin{pmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{c}{m} \end{pmatrix} \]

и матрицу управления:

\[ B_{2\times 1}= \begin{pmatrix} 0 \\ \frac{1}{m} \end{pmatrix} \]

Для определения выходного вектора \( y \) и матриц \( C,D \) , нужно обозначить величину, измеряемую на выходе. Допустим, мы хотим измерять положение груза, следовательно, выходное уравнение будет иметь вид:

\( y=z_1 \)

соответственно, в матричной форме:

\[ \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = \underbrace{ \begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix} }_\text{C} \begin{pmatrix} z_1 \\ z_2 \end{pmatrix} + \underbrace{ \begin{pmatrix} 0 \\ 0 \end{pmatrix} }_\text{D} F \]

В итоге, получим следующую динамическую модель движущегося груза в пространстве состояний:

(7) \[ \begin{cases} \dot z = \begin{pmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{c}{m} \end{pmatrix} z + \begin{pmatrix} 0 \\ \frac{1}{m} \end{pmatrix} F \\ y= \begin{pmatrix} 1 & 0 \end{pmatrix} z \end{cases} \]

Последний штрих, перед тем, как перейти к визуальному моделированию указать начальные условия для системы (7). Напомним, число н.у.=числу переменных состояния=порядку исходного ДУ. Мы рассматриваем уравнение второго порядка, следовательно, необходимо задать два начальных условия для каждой из фазовых переменных: \( z_{1}^{0}=0, z_{2}^{0}=0 \)

Перейдём к построению блок-схемы тележки с демпфером в Xcos

1. Для задания динамической системы в формате (7) используется блок с вкладки «Системы с непрерывным временем». Во внутренних параметрах данного блока нужно в Scilab- формате задания матриц и векторов, записать соответствующие матрицы. Мы не будем прибегать к непосредственной записи матриц в блоке, а зададим их в контексте, чтобы в дальнейшем в параметрах блока CLSS использовать только соответствующие переменные.

2. Откройте на редактирование контекст рабочей области и задайте матрицы и вектора, используемые в системе (7), особое внимание стоит уделить форме задания строки \(C\):

   На этом месте располагается листинг, который не может быть правильно отображен в rss-ленте. Перейдите к оригинальной статье: http://inclab.ru/articles/modelirovanie-dinamicheskih-sistem-v-matrichnom-vide-xcos

   Векторно-матричные элементы системы (7) в контексте Xcos

3. Далее в контексте необходимо задать начальные условия \( z_{1}^{0}=0, z_{2}^{0}=0 \) в виде вектор-строки:

   На этом месте располагается листинг, который не может быть правильно отображен в rss-ленте. Перейдите к оригинальной статье: http://inclab.ru/articles/modelirovanie-dinamicheskih-sistem-v-matrichnom-vide-xcos

   Задание начальных условий в контексте Xcos

4. И указать параметры системы:

   На этом месте располагается листинг, который не может быть правильно отображен в rss-ленте. Перейдите к оригинальной статье: http://inclab.ru/articles/modelirovanie-dinamicheskih-sistem-v-matrichnom-vide-xcos

   Задаём переменные в контексте Xcos

5. После чего, необходимо сохранить контекст и заполнить поля внутренних параметрах блока CLSS , как показано на рис. 91.

   Рисунок 91. Задание внутренних параметров блока CLSS с помощью переменных из контекста

6. Для дальнейшего построения блок-схемы потребуются 4 блока: CLOCK_c, END, CSCOPE и блок , который находится на палитре «Источники сигналов и воздействий». Блоки необходимо связать между собой соединительными линиями, как показано на рис. 92, настроить параметры осциллографа и запустить моделирование на 22с. 

   Рисунок 92. Блок-схема системы (7)

В результате моделирования на экране появится график затухающих синусоидальных колебаний, соответствующий переменной \(z_1\), то есть, координате передвигаемого груза (рис. 93).

Рисунок 93. Траектория выхода (координата груза) системы (7)

Блок STEP_FUNCTION функционирует согласно правилу:

\[ step_f(t)= \begin{cases} s_0, \quad t < t_0 \\ s_f, \quad t > t_0 \\ \end{cases} \]

где \(t_0, s_0,s_f\) - параметры, которые задаются во внутренних параметрах блока STEP_FUNCTION следующим образом:

• \(t_0\)- это параметр Start Time,

• \(s_0\)- это параметр Initial Value,

• \(s_f\)- это параметр Final Value.

В нашем случае, параметры у блока STEP_FUNCTION остались выставленные по умолчанию, поэтому, он на протяжении 1сек. подаёт на выход значение «0», а в последующие моменты времени – значение «1», что прослеживается на графике (рис. 93).

Выводим график скорости груза

После запуска моделирования возникает справедливый вопрос, а почему переменная только одна и как же вывести фазовый портрет системы?

Прежде всего, отметим, что на выход блока CLSS подаётся переменная \(y\),  которая формируется, как выход системы (7). Обратимся к системе (7) и её уравнению выхода

\[ \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = \underbrace{ \begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix} }_\text{C} \begin{pmatrix} z_1 \\ z_2 \end{pmatrix} \]

где не обнуляется только фазовая переменная \(z_1\), соответствующая переменной выхода с координатой \(y_1\) . Становится понятно, что, собственно, хотели получить на выходе \(y\) - то и получили – переменную состояния \(z_1\), которая отвечает за положение груза \(x\). Но мы сами настроили выход таким образом, а значит, его можно изменить.

Если бы нам потребовалось, например, построить график скорости груза, а скорость, -это, как известно – \(\dot x\) , то и в уравнении выхода нужно было бы обращаться к фазовой переменной \(z_2\), отвечающей за скорость. Следовательно, уравнение выхода в системе (7) для случая вывода скорости грузу, преобразуется к виду

\[ \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = \underbrace{ \begin{pmatrix} 0 & 0 \\ 0 & 1 \end{pmatrix} }_\text{C} \begin{pmatrix} z_1 \\ z_2 \end{pmatrix} \]

или сокращённо:

\[ y=\begin{pmatrix} 0 & 1 \end{pmatrix}z \]

Отредактировав вектор в контексте, запустите моделирование, результатом которого будет график, изображённый на рис. 94.

Рисунок 94. График скорости груза системы (7)

Строим траектории фазовых переменных системы в Xcos

Рассмотрим теперь задачу вывода нескольких переменных состояния и построения траектории на фазовой плоскости.

Обратимся к ранее составленным уравнениям выхода. В первом случае матричное уравнение

\[ \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = \underbrace{ \begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix} }_\text{C} \begin{pmatrix} z_1 \\ z_2 \end{pmatrix} \]

подаёт на выход \( y_1 \) фазовую переменную \( z_1 \), потому что только элемент \( c_{11} \) матрицы выхода \( C \) не обнуляется.

Соответственно для вывода фазовой переменной \( z_2 \) справедливо уравнение

\[ \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = \underbrace{ \begin{pmatrix} 0 & 0 \\ 0 & 1 \end{pmatrix} }_\text{C} \begin{pmatrix} z_1 \\ z_2 \end{pmatrix} \]

где ненулевым оказывается элемент \( c_{22} \)

Теперь, если обобщить полученную информацию, можно сделать вывод, что для вывода переменной состояния \( z_k \), в матрице выхода должна стоять «1» на месте \( c_{kk} \). Соответственно, для передачи на выход обеих переменных состояния рассматриваемой двумерной системы (7), матрица \( C \) преобразуется в единичную матрицу размера 2х2, при этом, размерность вектора \( y \) становится равной количеству выводимых переменных, т.е. «2».

Таким образом, линейная динамическая система в пространстве состояний, описывающая движение груза с пружиной и демпфером, подающая на выход обе фазовых переменных, примет вид:

(8) \[ \begin{cases} \dot z = \begin{pmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{c}{m} \end{pmatrix} z + \begin{pmatrix} 0 \\ \frac{1}{m} \end{pmatrix} F \\ y= \begin{pmatrix} 1 & 0\\ 0 & 1 \end{pmatrix} z \end{cases} \]

Для моделирования системы (8), прежде всего, в контексте нужно изменить строку, где задаётся матрица выхода:

После чего необходимо заменить одномерный осциллограф на блок CMSCOPE, размерность входа которого нужно исправить на 2. На рис.95а) приведена блок-схема с векторным осциллографом, а на рис. 95 б) – результат моделирования системы (8).

Рисунок 95а. Блок-схема динамической системы в Xcos

Рисунок 95б. Графики фазовых координат на одной сестеме координат в Xcos

Строим графики динамической системы на разных координатных сетках в Xcos

А что, если в ходе моделирования потребуется построить графики переменных состояния на отдельных системах координат?

В этом случае потребуется воспользоваться блоком , который располагается на палитре «Маршрутизация сигналов». Данный блок разделяет входной поток на отдельные составляющие. В нашем случае на вход блока DEMUX попадает вектор \( y \) условной размерности 2, который на выходе превращается в отдельные вектора фазовых выходных переменных \( y_1 \) и \( y_2 \). Использования блока расщепления DEMUX представлено на рис. 96.

Рисунок 96. Xcos-схема динамической системы с выводом трёх систем координат

Результат моделирования и внутренние параметры блока CMSCOPE представлены на рис. 97а-б).

Рисунок 97а.Настройки внутренних параметров блока CMSCOPE

Рисунок 97б.Исходный сигнал и разделённый на 2 компоненты

Продолжим модернизировать созданную блок-схему и на следующем шаге откажемся от осциллографа, заменив его блоком TOW_c. Использование блока записи в контекст предпочтительнее, так как последний предоставляет больше возможностей для редактирования и отображения графической информации посредством использования контекста.

Блоки многомерного осциллографа CMSCOPE и расщепления можно удалить – они не понадобятся.

Блок-схема системы с внесёнными изменениями показана на рис. 98.

Рисунок 98.Внедрение блока TOW_c блок-схему системы

Напомним, что на вход блока TOW_c подаётся вектор, который в переменную y_var, а потом используется в контексте для построения графиков. Чтобы понять, что за объект формируется в переменной y_var, его можно вывести в консоль с помощью стандартной функции Scilab disp().

Добавьте в контекст строку очистки консоли и вывода переменной:

Запустите моделирование и перейдите в консоль. В командном окне Scilab Вы обнаружите следующее:

Рисунок 99.Отображение объекта y_var в консоли

Итак, рисунок 99 гласит о том, что объект  y_var содержит два атрибута: вектор \( values \), в котором 2 столбца и 220 строк и  вектор \( time \) – временные отсчёты, представляющие собой вектор-столбец с 220 значениями.

Если подробнее, то вектор y_var\(.time\) – это точки в которых вычисляются значения системы, их 220 потому, что моделирование происходит на протяжении 22сек. со значением \( period=0.1 \). Вектор  y_var\(.values\) в первом столбце содержит значения первой фазовой переменной \( z_1 \), поданной на выход системы, т.е. значения координаты \( x \), вычисленные в каждой из 220 моментов времени; а во втором столбце – значения второй фазовой переменной \( z_2 \), которая соответствует производной \( \dot{x} \), то есть скорости груза, вычисленные в тех же 220 точках.

Для построения покоординатных графиков и фазового портрета нам предстоит обращаться к значениям y_var\(.values\) содержащимся в первом и втором столбцах по-отдельности.

Например, для того, чтобы получить все значения первого столбца, соответствующие переменной состояния \(z_1\), необходимо записать: y_var . values(: , 1), соответственно, чтобы получить значения вектора скорости,  нужно использовать запись  y_var . values(: , 2).

С помощью скрипта, записанного в контексте, можно получить одно графическое окно с 4-мя системами координат, как на рис. 100

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

Контекст, реализующий задание матриц системы, представленной в пространстве состояний и строящий графики следующий:

Оригинальный адрес статьи: http://inclab.ru/articles/modelirovanie-dinamicheskih-sistem-v-matrichnom-vide-xcos

]]> Wed, 13 Oct 2021 22:03:59 +0400 http://inclab.ru/articles/matematicheskaya-model-upravleniya-chislennostyu-populyacii-scilab http://inclab.ru/articles/matematicheskaya-model-upravleniya-chislennostyu-populyacii-scilab Обратимся к модели Хищник-Жертва, предложенной Лотки-Волтерра и попытаемся ею поуправлять

Обратимся к рассмотренной в статье модели Хищник-Жертва, предложенной Лотки-Волтерра и попытаемся ею поуправлять, то есть введём управление F в систему, так, что она преобразуется к виду:

(1)\begin{cases} \dot{x}=ax-bxy+F(t)x\\ \dot{y}=dxy-cy\\ \end{cases}

Итак, судя по виду системы (1), управлять мы будем численностью жертв \( x \) в каждый момент времени \( t \). Функция \( F(t) \)в данном случае может быть рассмотрена как индикатор смертности жертвы, то есть значение \( F(t) \leq 0 \) свидетельствует об убыли особей-жертв, значение \( F(t) = 0 \) означает, что жертвы смогли избежать гибели в момент времени .

Рассмотрим в качестве управляющего закона следующий:

(2) \[ F(t) = \begin{cases} sin(\frac{x}{2}), &\quad \text{если} \; x < x_{min}\\ \text{u = const,} &\quad \text{если} \; x > x_{max} \\ \end{cases} \]

Систему (2) можно интерпретировать следующим образом:
при достаточно высокой популяции жертв, их смертность примерно одинакова;
при малом же количестве добычи, вероятность ею полакомится снижается.

Отметим, что в системе без управления присутствует состояние равновесия, где количество жертв равно \( \frac{c}{d} \), поэтому значения \( x_{min}, x_{max} \) выберем на \( \delta% \) меньше и больше стационарного значения соответственно.

Приступим к построению управляемой системы (13) двух популяций.

1. Для начала, к блок-схеме исходной модели :

   Блок-схем модели Хищник-Жертва Xcos

   необходимо добавить:

   • заглушку супер-блока,

   • блок произведения,

   • блок TOWS_c.

   • Следующим шагом нужно провести соединительные линии и отредактировать первый сумматор, как показано на рис. 83.

   Рисунок 83. Внедрение блока управляющего воздействия в блок-схему модели Хищник-Жертва

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

3. Согласно построенной блок-схеме с рис. 83, на вход супер-блока подаётся текущая численность жертв \( x \). Это значение необходимо сравнить со значениями \( x_{min}, x_{max} \) и в зависимости от результата подать на выход супер-блока \( sin(\frac{x}{2}) \) или \( u \), соответственно системе (2).

4. Сравнение текущего значения численности жертв со значениями \( x_{min}, x_{max} \), инициирующими смену управляющего воздействия, осуществим с помощью блоков индикации смены знака  и , которые располагаются на палитре «Обнаружение перехода через нуль» и работают совместно с блоком  с палитры «Маршрутизация сигналов», который осуществляет выбор управляющего воздействия.

5. Чтобы воспользоваться блоками NEGTOPOS_f и POSTONEG_f, необходимо привести неравенства из (2) к виду:

   (3) \[ \begin{cases} x - x_{min} < 0, &\quad \text{(a)}\\ x - x_{max} > 0, &\quad \text{(b)}\\ \end{cases} \]

6. Теперь неравенства (3) представляют из себя разность двух элементов, один из которых динамический \( (x) \), а другой – константный, заданный в контексте (значения \( x_{min}, x_{max} \)).
   Откуда следует, что для сборки управления, нам дополнительно понадобятся:

   • два константных блока CONST_m

   • и два сумматора BIGSOM_f.

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

   Рисунок 84. Промежуточный набор блоков для проверки условий (2)

7. Рассмотрим построение блок-схемы неравенства \( x-x_{min} < 0 \) (3а).
   Данное неравенство выполняется, когда значение левой части становится меньше нуля, то есть переходит на тёмную отрицательную сторону оси координат, будучи до это положительным, тем самым осуществляя движения от «+» к «-».
   Данному событию соответствует блок, обнаруживающий переход чрез нуль POSTONEG_f. Соответствующая реализация первого неравенства на блок-схеме представлена на рис. 85.

   Рисунок 85. Реализация условия неравенства (3а).

   Обратите внимание, что в константном блоке используется значение \( x_{min} < 0 \), которое предварительно задано в контексте и равно \( (1-\delta)\frac{c}{d} \).

8. Перейдём к неравенству \( x-x_{max} > 0 \) (3b).
   Это неравенство выполняется, когда выражение слева превращается из отрицательного в положительное, то есть осуществляется переход через нуль слева направо, за что отвечает блок NEGTOPOS_f.
   Реализация данного неравенства полностью повторяет установку соединительных линий предыдущего случая и требует задания значения \( (1+\delta)\frac{c}{d} \)  в контексте. Блок схема неравенства (3b) представлена на рис. 86.

   Рисунок 86. Реализация условия неравенства (3б).

9. Далее перейдём к реализации выбора нужного закона управления в зависимости от того, какое неравенство из (3) выполняется. Данный выбор осуществляет блок SELECT_m, имеющий два управляющих и два регулярных входа.
   На управляющие входы селектора SELECT_m необходимо подать соответствующие красные выходы блоков POSTONEG_f и NEGTOPOS_f. Заметьте, что здесь важен порядок, так как управляющим входам селектора соответствуют его же регулярные входы. Поэтому выход первого неравенства, реализованного блоком POSTONEG_f,  нужно соединить с левым управляющим входом селектора, а выход блока NEGTOPOS_f – соединить с правым красным входом блока SELECT_m.

10. До полного сбора блока управления осталось только указать функции управления из системы (2), которые будут использованы при выполнении каждого из условий, поданных на управляющие входы блока SELECT_m.
    Для задания управляющих воздействий проделаем следующие действия:

    • на первый регулярный вход селектора подадим функцию \( sin(\frac{x}{2}) \) что соответствует выполнению первого условия (3 а),

    • а на второй черный вход блока SELECT_m - константу  \( u \), заданную в контексте.

    Итоговая блок-схема для выбора управляющего воздействия
    представлена на рис. 87.

    Рисунок 87. Блок-схема выбора закона управления (2), реализованная отдельным супер-блоком

    Ниже приведён скрипт, записанный к контексте рабочей области исходной блок-схемы.

    На этом месте располагается листинг, который не может быть правильно отображен в rss-ленте. Перейдите к оригинальной статье: http://inclab.ru/articles/matematicheskaya-model-upravleniya-chislennostyu-populyacii-scilab

    Задание контекста в Xcos.

Запустите моделирование на 15сек.. с начальными условиями \( x_0=5, y_0=2 \) соответствующих блоков интеграторов. Результат моделирования представлен на рис. 88.

Рисунок 88. Модель Хищник-Жертва с заданным законом управления. Верхняя система координат колебания численности популяций, нижняя закон управления F(t)

Обратите внимание, что популяция жертв (prey) и хищников (predator) стремится к устойчивым положениям равновесия \( x^* = \frac{c}{d}, y^* = \frac{a}{b} \) соответственно, а отклонения от точек стационарности не превышают заданного значения \( \delta \).

В качестве дополнительного задания и для более подробного изучения динамики системы, читателю предлагается вывести фазовый портрет рассматриваемой системы Хищни-Жертва, убедившись, что траектория сходится к точке устойчивости \( (x^*, y^*) \), а стартует из начальной точки \( (x_0, y_0) \); поменять коэффициенты \( a,b,c,d \) системы в контексте и задать различную степень отклонения \( \delta \), проследив, как меняется взаимодействие популяций.

Оригинальный адрес статьи: http://inclab.ru/articles/matematicheskaya-model-upravleniya-chislennostyu-populyacii-scilab

]]> Fri, 04 Jun 2021 15:12:42 +0400 http://inclab.ru/articles/ispolzovanie-super-blokov-v-scilab-xcos http://inclab.ru/articles/ispolzovanie-super-blokov-v-scilab-xcos Рассмотрим, как можно модернизировать созданную блок-схему для осуществления поставленной задачи.

В предыдущем материале мы рассмотрели пример реализации простейшего управляющего элемента в Xcos. Заметим, что частота переключения режимов двухфазного термоконтроллера высока (около 10 сек.), что на практике оказывало бы дополнительную нагрузку на исполнительные механизмы устройства и приводило бы к его быстрой поломке. Поэтому более рациональным было бы указывать не фиксированное значение температуры, а диапазон температур, характерных для комфортного пребывания в помещении.

Рассмотрим, как можно модернизировать созданную блок-схему для осуществления поставленной задачи.

Прежде всего, для большей наглядности созданной схемы, прибегнем к помощи супер-блоков. Чтобы объединить несколько Xcos блоков в один супер-блок нужно:

• выделить нужные блоки с их соединительными линиями (см рис.75 а);

  Рис. 75a. Преобразование блоков в супер-блок/ выделение объединяемых блоков

• кликнуть правой кнопкой мыши по одному из блоков;

• в выпадающем меню выбрать пункт «Selection to superblock».

После чего на месте группы блоков появится новый блок (см. рис..75б ).

Рис. 75б. Преобразование блоков в супер-блок/ результат объединения нескольких блоков

То же самое необходимо проделать для блока управления, предварительно удалив лишние соединительные линии (см. рис. 76 а-б)

Рис. 75а. выделение объединяемых блоков

Рис. 75б. результат объединения нескольких блоков

В результате исходная схема примет удобочитаемый вид, как показано на рис. 77.  

Рисунок 77. Блок-схема замкнутой системы управления с использование супер-блоков

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

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

Рисунок 78. Ошибка, возникающая при создании супер-блоков

Вот оно! Подозрительный треугольник с восклицательным знаком, сигнализирующий о наличии ошибки. Дело в том, что в данных блоках используются переменные, указанные в контексте исходной рабочей области. Контекст же открытого окна, на проверку, оказывается пустым. Следовательно, для устранения данной ошибки, необходимо перенести используемые переменные из контекста исходного окна в окно редактирования супер-блока.

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

После краткого знакомства с пользовательскими супер-блоками, вернёмся к задаче модификации контроллера, регулирующего температуру в заданных пределах. Для моделирования такого контроллера потребуется блок , который располагается на палитре «Системы с разрывами». Данный блок имеет один регулярный вход и один регулярный выход и осуществляет переключение между двумя константами. Блок реле остаётся включенным до тех пор, пока на вход не передано пороговое значение, после чего реле выключается и принимает второе значение до тех пор, пока вновь не будет пройдено пороговое значение.

Из описания блока HYSTHERESIS следует, что целый блок, реализующий включение и отключение термокнтоллера, можно заменить одним блоком реле, как показано на рис. 79.

Рисунок 79. Использование блока реле в качестве управляющего устройства

Внутренние параметры блока HYSTHERESIS представлены на рис. 80

Рисунок 80. Внутренние параметры блока

Согласно заданным параметрам, блок HYSTHERESIS будет работать следующим образом:
по умолчанию блок считается включенным и остаётся таковым до тех пор, пока значение, подаваемое на его вход не превысит delta, при этом на выход блока реле подается значение output when on = 1.
Как только значение, подаваемое на вход блока реле превышает delta, блок выключается и подаёт на выход значение output when off = 0 до тех пор, пока входное значение не упадёт ниже –delta. Далее процесс повторяется.

Иначе на этот процесс можно взглянуть, обратившись к неравенству, которое решалось в предыдущем случае. Если прежде разность температур сравнивалась с нулём, то сейчас ошибка должна попадать в диапазон значений, иными словами, с помощью блока HYSTHERESIS в блок-схеме (см. рис. 81) решается неравенство .

\( |Tfix-H(s)|<\delta \) (*)

Рисунок 81. Блок-схема с управлением релейного типа

Запустите моделирование на 100сек. со следующими параметрами \( delta=3; Tfix=22; K=50; T=30; \tau=5 \), указанными в контексте. Результат моделирования представлен на рис.82.

Рисунок 82. График регуляции температура в пределах от 19 до 25 гр.Ц.

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

Оригинальный адрес статьи: http://inclab.ru/articles/ispolzovanie-super-blokov-v-scilab-xcos

]]> Fri, 04 Jun 2021 15:04:37 +0400 http://inclab.ru/articles/zamknutaya-sistema-upravleniya-scilab-xcos http://inclab.ru/articles/zamknutaya-sistema-upravleniya-scilab-xcos простой вид контроллера индикатор включения\выключения

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

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

В данном материале мы рассмотрим самый простой вид контроллера – индикатор включения\выключения, который ещё носит название двухступенчатого контроллера, так как не имеет промежуточных состояний, то есть принимает всего два значения: включен или выключен.

Итак, представим термоконтроллер, который отслеживает температуру и срабатывает на разницу температур в помещении. В терминах управляемых систем, работа данного устройства происходит следующим образом: в определённые моменты времени на вход контроллера подаётся разница температур между текущим и необходимым к поддержанию значением, называемая ошибкой, а на выход контроллера поступает сигнал срабатывания. Управляемой переменной в данном случае является температура, которая дополнительно измеряется датчиком, и информация передаётся обратно в термоконтролер. Разница между заданным значением температуры и замеренной производительностью отопительных приборов возникает из-за неизбежных помех – утечек тепла, которые влияют на общую температуру помещения. Схема данной замкнутой системы управления представлена на рис.66.

Рисунок 66. Система управления с термодатчиком

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

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

Другой важной характеристикой управляемой динамической системы является её ёмкость. Ёмкость системы можно рассматривать, как сопротивление внешним изменениям. Причём, чем выше ёмкость системы, тем больше времени потребуется, чтобы вносимый вклад управляющего устройства подействовал на объект управления.

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

Описанная система управления с контроллером и объектом управления, обладающая обозначенными особенностями, схематически изображена на рис. 67.

Рисунок 67. Система управления температурой в помещении

Процесс управления температурой в помещении рассматривается, как дифференциально уравнение первого порядка с запаздыванием, передаточная функция которого имеет вид:

\( H(s)=\frac{K}{T\cdot s+1}e^{-\tau s} \)

где \( K \) - коэффициент усиления, \(\tau \) - ёмкость системы, \( s \)- задержка реагирования системы.

Построение блок-схемы системы управления в Xcos

Начнём собирать схему с объекта управления.

1. Отапливаемое помещение в нашем случае, можно рассматривать как передаточную функцию с палитры «Системы с непрерывным временем» с блоком запаздывания TIME_DELAY , располагающимся на той же палитре. Добавьте данные блоки на рабочую область.

2. Далее в контексте задайте значения переменных \( K=18, T=24, \tau=5, Tfix=12 \), чтобы их можно было использовать в дальнейшем.

3. Во внутренних параметрах блока передаточной функции CLR укажите значения Numerator (числитель) = \( K \) и Denominator (знаменатель) = \( T\cdot s+1 \)  согласно формуле (12).

4. Во внутренних параметрах блока задержки TIME_DELAY укажите значение
   Delay = \( \tau \) .

5. Соедините выход блока CLR со входом блока TIME_DELAY. В итоге должна получиться схема, изображённая на рис.68

   Рисунок 68. Реализация объекта управления при помощи Xcos блоков

6. Сбор схемы термоконтроллера начнём с решения неравенства

   \( Tfix-H(s)>0 \) (*)

   Левая часть данного неравенства реализуется сумматором BIGSOM_f, вектор знаков портов которого имеет вид [1;-1]. Положительный порт сумматора нужно соединить с константным блоком, в котором установлено значение желаемой температуры .
   Далее, на порт сумматора с отрицательным множителем, нужно подать фиксируемую датчиком температуру, то есть, - значение с выхода блока TIME_DELAY.  Результат представлен на рис. 69.

   Рисунок 69. Реализация вычисления ошибки Tfix-H(s)

7. Знак ошибки, то есть сравнение с нулём выхода блока BIGSOM_f, будем определять с помощью блока , который можно найти на палитре «Математические операции».

8. Во внутренних параметрах блока RELATIONALOP для параметра Operator необходимо указать значение 4, что соответствует знаку «больше», а значение Use zero crossing =1 (переход через нуль).

9. Далее на входы RELATIONALOP нужно подать сравниваемые выражения: это выход блока BIGSOM_f и константный блок со значением 0, как показано
   на рис. 70.

   Рисунок 70. Формирование неравенства (*)

10. На выход блока сравнения будет подано значение «1», если условие сформированного неравенства выполняется, и «0», если ошибка окажется отрицательной.

11. Осталось реализовать сам двухступенчатый контроллер, который можно интерпретировать как блок переключателя с палитры «Маршрутизация сигналов». На вход блока SWITCH2_m должен подаваться результат сравнения разницы температур с «0», а на выход SWITCH2_m -  значение «0» или «1», в зависимости от знака ошибки.

12. Значения переключателя «0» и «1» реализуем блоками постоянных CONST, и подадим их на первый и третий входы блока SWITCH2_m. На данном этапе блок контроллера должен выглядеть, как показано на рис. 71.

    Рисунок 71. Выходные значения двухступенчатого контроллера

13. Для реализации контроллера осталось соединить выход блока, решающего неравенство RELATIONALOP со свободным регулярным входом блока переключателя (см. рис. 72).

    Рисунок 72. Блок-схема контроллера, принимающего значения «0» и «1» в зависимости от знака разницы температур

14. Напомним, что на средний вход SWITCH2_m подаётся «1», если текущая температура не превышает желаемой температуры и «0», если текущая температура поднялась выше желаемой. Соответственно, нам нужно включать контроллер, кода ошибка больше нуля и выключать его, когда ошибка отрицательна. Реализовать смену положений выключателя можно с помощью внутренних параметров.

15. Во внутренних параметрах блока SWITCH2_m нас интересует параметр pass first input – условие подачи на выход SWITCH2_m его первого входа, т.е «1». Параметр pass first input может принимать следующие значения:

    • значение «0» для проверки условия, что вход \( \geq a \);

    • значение «1» для проверки условия, что вход \( >a \);

    • значение «2» для проверки условия, что вход \( = a \);

    В нашем случае, необходимо поставить «1», что соответствует условию, что значение, подаваемое на средний вход блока SWITCH2_m больше параметра . Параметр  задаётся в следующей строке - для внутреннего параметра threshold и равняется «0».

    Итак, получив на вход контроллера SWITCH2_m значение «1», соответствующее температуре, ниже желаемой, мы сравниваем её с «0» в блоке SWITCH2_m и на выход контроллера SWITCH2_m подаётся «1», что соответствует режиму «вкл». Если же снимаемая температура опускается ниже значения , то на вход блока SWITCH2_m подаётся «0», который сравнивается с «0» его внутренних параметров и переводит контроллер в состояние «выкл», что соответствует выходу блока SWITCH2_m со значением «0».

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

    Рисунок 73. Блок-схема замкнутой системы управления температурой с двухступенчатым контроллером

17. Запустите моделирование на 60сек, удостоверившись, что в блоке задержке стоит корректный размер буфера, а у блока осциллографа правильно настроены параметры осей, размерности входов и буферизации. Результат моделирования представлен на рис. 74.

    1-я система координат: черный график разница температур; зелёный ступенчатый график выход блока-решателя неравенства, иллюстрирующий переход через нуль; красный - график у=0

    2-я система координат: режимы контроллера 1-«вкл», 0 «выкл»

    3-я система координат: красный график желаемая температура , синий график снимаемая датчиком температура.

    Рисунок 74. Результат моделирования замкнутой системы управления

Из рис. 74 видно, что первые 5 минут – время равное задержке, контроллер простаивает и температура остаётся на отметке 0, после чего вычисляется разница температур (1-я система координат), и в работу включается контроллер (2-я система координат), повышающий температуру. Отопительные приборы продолжают работать на обогрев, пока температура в помещении не достигнет значения \( Tfix \), после чего контроллер переходит в состояние «выкл», однако, и при выключенных отопительных элементах, температура помещения растёт некоторое время, из-за инертности система, после чего начинает падать из-за неизбежных теплопотерь (3-я система координат). Падение температуры ниже критической отметки \( Tfix \), обозначающее отрицательность ошибки, вновь инициирует переход контроллера в состояние «вкл» и т.д.

Оригинальный адрес статьи: http://inclab.ru/articles/zamknutaya-sistema-upravleniya-scilab-xcos

]]> Fri, 04 Jun 2021 15:01:15 +0400 http://inclab.ru/articles/postroeniyu-fazovogo-portreta-v-xcos http://inclab.ru/articles/postroeniyu-fazovogo-portreta-v-xcos Два подхода к построению фазового портрета на примере аттрактора Рёсслера

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

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

Аттрактор Рёсслера — это хаотический аттрактор, которым обладает система дифференциальных уравнений Рёсслера вида:

(1)\begin{cases} \dot{x}=-y-z \\ \dot{y}=x+ay \\ \dot{z}=b+z(x-c) \end{cases}

\( a>0, b>0,c>0 \)

При значениях параметров \( a=b=0.2 \) и \( 2.6 \leq c \leq 4.2 \) уравнения Рёсслера обладают устойчивым предельным циклом. При этих значениях параметров период и форма предельного цикла совершают последовательность удвоения периода.

Сразу же за точкой \( c=4.2 \) возникает явление хаотического аттрактора. Чётко определённые линии предельных циклов расплываются и заполняют фазовое пространство бесконечным счетным множеством траекторий, обладающим свойствами фрактала. Именно случай бесконечных самоповторяющихся траекторий мы и замоделируем.

Построим блок-схему системы (1), задав параметры в контексте со значениями \( a=b=0.1, с=14 \).

Для построения трёх уравнений системы (1) нам понадобятся блоки INTEGRAL_m, BIGSOM_f, PRODUCT, CONST и GAINBLK.

Двумерный фазовый портрет в Xcos

В рамках первого подхода к построению фазового портрета, воспользуемся
блоком , который располагается на палитре «Регистрирующие устройства» и осуществляет построение графика зависимости \( y(x) \), где \( x \) отвечает за значения по оси абсцисс, а значения \( y(x) \)откладываются на оси ординат.

Приступим к построению блочной диаграммы Xcos.

1. Для начала, добавьте на рабочую область 3 блока интегратора INTEGRAL_m с нулевыми начальными значениями, 4 блока BIGSOM_f, блок умножения переменных PRODUCT и блоки для задания коэффициентов CONST и GAINBLK.

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

Рисунок 57. Заготовка для создания блок-схемы системы (1)

2. На построении соединительных линий между блоками Xcos для первых двух уравнений системы Рёсслера не будем подобно останавливаться, так как оно представляется легко осуществимым на основе приобретённого читателем опыта. Результат установления связей для переменных \( y, x \)  отображен на рис. 58.

Рисунок 58. Первые два уравнения системы (1)

3. Сбор блок-схемы третьего уравнения системы Рёсслера нужно начать со второго слагаемого, то есть осуществить произведение переменной \( z \) и скобки \( (x-c)\), см. рис. 59.

Рисунок 59. Блок схема части третьего уравнения системы (1)

4. Осталось только подвести нужные соединительные линии на регулярные входы последнего сумматора и направить его выход на соответствующий интегратор, \( z \).

Результатом данных манипуляций будет схема, блок-изображённая на рис. 60.

Рисунок 60. Блок-схема системы Рёсслера трёх диф. уравнений

5. Далее, необходимо добавить блоки для осуществления моделирования CLOCK_c, END, проведя соединительные линии и настроив внутренние параметры блоков для моделирования на протяжении 300сек.

Для вывода фазовых траекторий, добавьте блок CSCOPXY, на регулярные входы которого направьте интересующие нас переменные \( y, x \) для вывода графика \( y(x) \), а на управляющий вход – соединительную линию от индикатора отсчетов CLOCK_c. 

Обратите внимание, что названия входов блока CSCOPXY иллюстрируют построение функции \( y(x) \).

В результате блок-схема, реализующая построение траекторий аттрактора Рёсслера на фазовой плоскости примет вид, такой, как показано на рис. 61.

Рисунок 61. Блок-схема моделирования системы Рёсслера

Запустите моделирование на протяжении 300сек., настройте внутренние параметры блока CSCOPXY так, чтобы странный аттрактор хорошо вписывался бы в координатную сетку, как показано на рис. 62.

Рисунок 62. Аттрактор Рёсслера на фазовой плоскости

Итак, результатом моделирования бифуркаций аттрактора Рёсслера будет фазовая траектория \( y(x) \), иллюстрирующая сценарий перехода к хаосу через каскады бифуркаций удвоения периода Фейгенбаума, субгармонические каскады и гомоклинический каскад бифуркаций.

Построение трёхмерного графика в Xcos

Для большей наглядности результата моделирования, заменим блок CSCOPXY блоком CSCOPXY3D.

Функциональный блок  располагается на палитре «Регистрирующие устройства» и служит он для отображения трёхмерной системы координат, что становится понятно из его названия.

Изменённая часть блок-схемы и результат моделирования аттрактора Рёсслера представлены на рис. 63а,б.

Рисунок 63a.Моделирование 3D системы Рёсслера - добавление блока CSCOPXY3D в блок-схему

Рисунок 63б.Результат использования Xcos блока генерации трёхмерной сетки координат

Построение 3D графика с помощью контекста в Xcos

Рассмотрим ещё один способ построения фазового портрета систем дифференциальных уравнений, теперь уже с использованием контекста и блоков буферизации данных TOWS_c.

Добавьте 3 блока буферизации TOWS_c – по одному для каждой переменной моделируемой системы.

 Во внутренних параметров каждого из блоков TOWS_c укажите число запоминаемых точек = 10000 и задайте ассоциируем имена переменных  x_var, y_var, z_var в соответствии с сигналами, подающимися на регулярные входы  TOWS_c (см. рис. 64).

Рисунок 64. Блоки буферизации, включенные блок-схему системы (1)

Теперь значения переменных \( x,y,z \) для всех временных отсчетов записываются в одноимённые переменные x_var, y_var, z_var. Эти переменные можно использовать в контексте для построения графиков посредством стандартных Scilab – функций, например plot() и param3d().

Для того, чтобы отобразить две системы координат в одном графическом окне, добавьте в контекст следующие строки:

После запуска моделирования, появится одно графическое окно: на первой координатной сетке будут зависимости \( x(t), y(t), z(t) \), а на второй – трёхмерный график аттрактора Рёсслера. как на рис. 65.

Рисунок 65. Результат использования блоков буферизации и контекста для вывода графиков системы Рёсслера (1)

Оригинальный адрес статьи: http://inclab.ru/articles/postroeniyu-fazovogo-portreta-v-xcos

]]> Thu, 03 Jun 2021 16:59:31 +0400 http://inclab.ru/articles/matematicheskaya-model-sir-vzaimodeystviya-treh-populyaciy http://inclab.ru/articles/matematicheskaya-model-sir-vzaimodeystviya-treh-populyaciy Математическая модель SIR взаимодействия трёх популяций, её реализация в среде Xcos

Рассмотрим простейшую модель распространения болезни в обществе. Обозначим через \( s(t) \) - долю особей, потенциально подверженных заболеванию, \( i(t) \) - долю уже заболевших (и потенциально заразных) особей, а через \( r(t) \) - число выздоровевших и, следовательно, приобрётших иммунитет к болезни. В данных обозначениях математическая модель течения болезни в трёх  взаимодействующих популяциях представима в виде:

(1)\begin{cases} \dot{s}=-as(t)i(t) \\ \dot{i}=as(t)i(t)-bi(t) \\ \dot{r}=bi(t) \end{cases}

\( a>0, b>0 \)

Создание блок-схемы, описывающей взаимодействие трёх популяций, как и в предыдущем случае, начнём с задания положительных коэффициентов \( a=1, b=0.3 \) через контекст. Кроме того, зададим начальные значения \( s_0=0.999, i_0=0.001 \), обозначающие долю особей, восприимчивых и не восприимчивых  к болезни соответственно.

Далее добавим на рабочую область три блока интегратора INTEGRAL_m с настроенными внутренними параметрами, один блок сумматора BIGSOM_f и два блока усилителя GAINBLK с параметрами \( a,b \).

В итоге получим заготовку, изображённую на рис. 51.

Рисунок 51. Исходные блоки для создания блок-схемы системы (1)

Далее замоделируем правую часть уравнения \( \dot{s}=-as(t)i(t) \) как произведение двух фазовых переменных, усиленное на величину \( -a \).

В результате получим схему, изображенную на рис. 52

Рисунок 52. Блок-схема первого уравнения системы (1)

Соединительные линии для второго и третьего уравнений проводятся по известным уже принципам умножения фазовых переменных с помощью блока PRODUCT и их последующего усиления через блок GAINBLK.

Интересным в рассматриваемом примере является второе уравнение \( \dot{i}=as(t)i(t)-bi(t) \) рассматриваемой системы (1). Дело в том, что оба слагаемых, стоящих в правой части данного уравнения, входят в состав первого и третьего уравнений с теми же коэффициентами усиления, но противоположными знаками. Поэтому добавлять дополнительные блоки усилителей не нужно, достаточно распараллелить соответствующие соединительные линии блоков и отредактировать знаки слагаемых блока BIGSOM_f , как показано на рис. 53.

Рисунок 53. Блок-схема диф.уравнений системы (1)

Для вывода графического решения рассматриваемой системы трёх взаимодействующих популяций, воспользуемся приёмом, рассмотренным в предыдущей статье. Добавим блоки TOWS_c, CLOCK_c, END, проведя соединительные линии и настроив их внутренние параметры для моделирования на протяжении 20сек., как показано на рис. 54.

Рисунок 54. Xcos модель распространения болезни в обществе.

Далее необходимо установить контекст, как показано на рис. 55.

Рисунок 55. Задание внутренних параметров и контекста SIR-модели

Результаты моделирования представлены на рис. 56. Моделирование проводилось для с шагом дискретизации 0.1.

Рисунок 56. Графическое представление течения болезни, описываемого системой (1), в обществе.

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

Оригинальный адрес статьи: http://inclab.ru/articles/matematicheskaya-model-sir-vzaimodeystviya-treh-populyaciy

]]> Thu, 03 Jun 2021 17:00:26 +0400 http://inclab.ru/articles/ispolzovanie-simvolnyh-parametrov-i-konteksta-v http://inclab.ru/articles/ispolzovanie-simvolnyh-parametrov-i-konteksta-v Использование символьных параметров и контекста в xcos на примере визуального моделирования системы Хищник-Жертва

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

Контекст – это код на языке Scilab, который может содержать как простое декларирование переменных, так и создание полноценных самостоятельных Scilab –функций.

Символьные параметры – это непосредственно сами переменные, заданные в контексте, к которым можно обратиться по имени для использования в функциональных блоках при создании блок-схемы.

Рассмотрим использование контекста и символьных параметров на примере создания блок-схемы системы Хищник-Жертва. Данная биологическая система описывает взаимодействие двух вид�