<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE article PUBLIC "-//NLM/DTD JATS (Z39.96) Journal Publishing DTD v1.2 20120330//EN" "http://jats.nlm.nih.gov/publishing/1.2/JATS-journalpublishing1.dtd">
    <!--<?xml-stylesheet type="text/xsl" href="article.xsl">-->
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:ns0="http://www.w3.org/1999/xlink" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" article-type="research-article" dtd-version="1.2" xml:lang="en">
	<front>
		<journal-meta>
			<journal-id journal-id-type="issn">2303-9868</journal-id>
			<journal-id journal-id-type="eissn">2227-6017</journal-id>
			<journal-title-group>
				<journal-title>Международный научно-исследовательский журнал</journal-title>
			</journal-title-group>
			<issn pub-type="epub">2303-9868</issn>
			<publisher>
				<publisher-name>ООО Цифра</publisher-name>
			</publisher>
		</journal-meta>
		<article-meta>
			<article-id pub-id-type="doi">10.60797/IRJ.2026.165.60</article-id>
			<article-categories>
				<subj-group>
					<subject>Brief communication</subject>
				</subj-group>
			</article-categories>
			<title-group>
				<article-title>Интеллектуальная система управления микро-ГЭС на основе нечёткой нейросетевой модели</article-title>
			</title-group>
			<contrib-group>
				<contrib contrib-type="author" corresp="yes">
					<name>
						<surname>Зубарев</surname>
						<given-names>Михаил Андреевич</given-names>
					</name>
					<email>annelina90@mail.ru</email>
					<xref ref-type="aff" rid="aff-1">1</xref>
				</contrib>
			</contrib-group>
			<aff id="aff-1">
				<label>1</label>
				<institution>Санкт-Петербургский государственный университет аэрокосмического приборостроения</institution>
			</aff>
			<pub-date publication-format="electronic" date-type="pub" iso-8601-date="2026-03-17">
				<day>17</day>
				<month>03</month>
				<year>2026</year>
			</pub-date>
			<pub-date pub-type="collection">
				<year>2026</year>
			</pub-date>
			<volume>9</volume>
			<issue>165</issue>
			<fpage>1</fpage>
			<lpage>9</lpage>
			<history>
				<date date-type="received" iso-8601-date="2025-12-27">
					<day>27</day>
					<month>12</month>
					<year>2025</year>
				</date>
				<date date-type="accepted" iso-8601-date="2026-03-10">
					<day>10</day>
					<month>03</month>
					<year>2026</year>
				</date>
			</history>
			<permissions>
				<copyright-statement>Copyright: &amp;#x00A9; 2022 The Author(s)</copyright-statement>
				<copyright-year>2022</copyright-year>
				<license license-type="open-access" xlink:href="http://creativecommons.org/licenses/by/4.0/">
					<license-p>
						This is an open-access article distributed under the terms of the Creative Commons Attribution 4.0 International License (CC-BY 4.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited. See 
						<uri xlink:href="http://creativecommons.org/licenses/by/4.0/">http://creativecommons.org/licenses/by/4.0/</uri>
					</license-p>
					.
				</license>
			</permissions>
			<self-uri xlink:href="https://research-journal.org/archive/3-165-2026-march/10.60797/IRJ.2026.165.60"/>
			<abstract>
				<p>Цель исследования заключается в разработке интеллектуальной системы управления микро-ГЭС на основе адаптивной нечёткой нейросетевой модели ANFIS для обеспечения автономной эксплуатации объектов малой гидроэнергетики без постоянного операторского контроля. Задача исследования состояла в проектировании трёхуровневой edge-cloud архитектуры с распределением вычислительных задач между локальным контроллером Raspberry Pi Zero 2W и удалённым сервером AMD Ryzen 7 2700, разработке ANFIS-модели с 52 нечёткими правилами (генерация субтрактивной кластеризацией) для обработки входного вектора из 22 параметров от распределённой сенсорной сети, реализации гибридного алгоритма онлайн-адаптации и внедрении четырёх сценариев автономного управления (прогнозирование паводка, защита от загрязнений, сезонная адаптация, управление энергобалансом). Гипотеза исследования заключалась в том, что адаптивная нечёткая нейросетевая модель на основе метода Sugeno обеспечивает вычислительно-эффективное управление в реальном времени (инференс &lt;50 мс) с автоматической адаптацией к долгосрочным трендам гидрологического режима, что позволяет заменить постоянный операторский контроль на автономное интеллектуальное управление. В качестве методологии выбрано начальное обучение на масштабированных данных крупных ГЭС (18 млн записей, нормализация через критерии Фруда и Рейнольдса), гибридный алгоритм обучения (LSE через SVD-разложение для консеквентов, градиентный спуск с Ridge регуляризацией для антецедентов) и онлайн-адаптация с ежесуточным переобучением на накопленных данных. В результате исследования установлено, что система обеспечивает инференс 50 мс на Raspberry Pi Zero 2W (загрузка CPU 0.2%, энергопотребление 2.5 Вт), начальное обучение за 2.5 часа достигает RMSE = 0.042 и R² = 0.91, за 6 месяцев онлайн-адаптации метрики улучшаются в 2.3 раза (RMSE 0.042→0.018, R² 0.91→0.97), энергопотери снижаются с 8% до 3% (~410 кВт·ч/год), ложные срабатывания защиты уменьшаются на 83% (с 12 до 2 событий/месяц). Выявлена критическая зависимость эффективности системы от механизма онлайн-адаптации, обеспечивающего автоматическое формирование базы знаний о специфике конкретного водотока и прогнозирование нештатных ситуаций (паводок за 3–7 дней, превентивное снижение расхода с 0.93 до 0.60 м³/с) при устойчивости к отказам датчиков (деградация RMSE с 0.018 до 0.025 при потере 1–2 сенсоров).</p>
			</abstract>
			<kwd-group>
				<kwd>ANFIS</kwd>
				<kwd> нечёткая нейросетевая модель</kwd>
				<kwd> микро-ГЭС</kwd>
				<kwd> edge-cloud архитектура</kwd>
				<kwd> онлайн-адаптация</kwd>
				<kwd> модель Sugeno</kwd>
			</kwd-group>
		</article-meta>
	</front>
	<body>
		<sec>
			<title>HTML-content</title>
			<p>1. Введение</p>
			<p>Есть большая выборка нештатных ситуаций, возникающая по причине сбоя отлаженных алгоритмов, отсутствия возможности предсказания и необходимости постоянного присутствия оператора, который будет корректировать параметры. Чем больше заранее прописано правил и условий их наступления, тем будет меньше ситуаций, когда необходимо удалённое вмешательство. Но при этом на малых объектах возобновляемой энергетики, где экономия идёт на многих узлах, остаётся необходимость в удалённом контроле </p>
			<p>[1]</p>
			<p>Для решения проблемы возможно подключение дополнительного управляющего узла в систему на основе современных одноплатных компьютеров и развёртывания на них более продвинутой логики и контроля за узлами, сбора диагностических данных работы и параметров с внешних датчиков, а также подключение их к сети для дистанционного мониторинга диспетчером или обученной нейросетевой моделью </p>
			<p>[2]</p>
			<p>Контроль всех процессов со стороны удалённого оператора и предотвращения ситуаций, когда управляющий алгоритм не смог штатно отработать, является стандартной практикой для крупных гидроэлектростанций, где оплата труда сотрудника кратно меньше доходу от продажи электроэнергии. Для малых электростанций на возобновляемых источниках энергии (ВИЭ) такой сценарий экономически не целесообразен, поэтому необходимо рассматривать ввод в систему нейросетевого узла. Нужно уточнить, что оптимальным будет вариант нечёткой нейросетевой модели, так как за счёт принципа работы он будет эффективно решать нештатные сценарии ввиду способности к мышлению обобщёнными понятиями и построению вывода в условиях неполной и неопределённой информации. Модель Sugeno обеспечивает вычислительную эффективность при сохранении высокой точности управления, что критически важно для автономных микро-ГЭС с ограниченными вычислительными ресурсами. Благодаря линейной зависимости выходных функций от входных переменных система способна осуществлять плавную интерполяцию между различными режимами работы гидроагрегата, адаптируясь к изменяющимся условиям водотока и электрической нагрузки. Интеграция с адаптивными алгоритмами обучения позволяет системе самостоятельно корректировать параметры управления на основе накопленного опыта эксплуатации, минимизируя риски аварийных ситуаций без участия человека </p>
			<p>[3][4]</p>
			<p>Целью данного исследования стала разработка интеллектуальной системы управления микро-ГЭС на основе адаптивной нечёткой нейросетевой модели ANFIS, которая позволит обойтись без постоянного присутствия оператора на объекте </p>
			<p>[1]</p>
			<p>2. Техническая реализация системы</p>
			<p>Для работы системы потребовалось организовать три уровня работы с данными.</p>
			<fig id="F1">
				<label>Figure 1</label>
				<caption>
					<p>Структурная схема аппаратно-программного комплекса микро-ГЭС</p>
				</caption>
				<alt-text>Структурная схема аппаратно-программного комплекса микро-ГЭС</alt-text>
				<graphic ns0:href="/media/images/2026-03-15/8e2c5aac-2679-4b7e-a207-34f8950c4f94.png"/>
			</fig>
			<p>[5]</p>
			<p>Второй узел собирает и буферизует поступающие данные. Здесь установлен модифицированный Wi-Fi роутер TL-WR703N с распаянной внешней антенной 5 dBi. Прошивка OpenWRT обеспечивает гибкость настройки. Роутер принимает JSON-пакеты от датчиков и складывает их в базу SQLite. Каждые 32 секунды накопленные данные выгружаются и передаются дальше на Raspberry Pi Zero 2W по тому же Wi-Fi на частоте 2.4 ГГц.</p>
			<p>Третий узел объединяет локальную и удалённую обработку. Raspberry Pi Zero 2W содержит базовые алгоритмы управления для типовых ситуаций. Когда возникает что-то нестандартное, требующее анализа долгосрочных трендов и нечёткой логики, данные уходят на удалённый сервер через USB LTE-модем. Пакеты отправляются параллельно на оба узла обработки, чтобы не терять время.</p>
			<p>На микро-ГЭС установлено два исполнительных механизма. Первый из них представляет собой металлическую заслонку на входе водозаборного канала. Её положение меняется от 0% (полностью открыта) до 100% (полностью закрыта). Второй механизм это сороудерживающая решётка клиновидной формы, напоминающая латинскую букву V. Решётка работает только в двух положениях: полностью поднята или полностью опущена. Поднимать её имеет смысл только когда есть риск попадания мусора в турбину, потому что в поднятом состоянии она частично тормозит поток </p>
			<p>[6]</p>
			<p>Вся система мониторинга построена так, чтобы обеспечить отказоустойчивость и свести к минимуму задержки при принятии решений. Датчики опрашиваются каждые 1–2 секунды, что достаточно для отслеживания быстрых изменений в потоке. Буферизация на роутере TL-WR703N страхует от кратковременных обрывов связи и гарантирует целостность данных.</p>
			<p>В Raspberry Pi Zero 2W заложена база типовых алгоритмов, покрывающих большинство штатных режимов. Сюда входят регулирование заслонки при колебаниях уровня воды, автоматическое снижение нагрузки при падении скорости потока, защита от перегрузки при резком увеличении расхода, подъём решётки при угрозе засорения турбины. Все эти сценарии реализованы на классических ПИД-регуляторах и пороговой логике.</p>
			<p>Удалённый сервер берёт на себя более сложные задачи. Именно там работает нечёткая нейросетевая модель, которая анализирует долгосрочные тренды, прогнозирует нештатные ситуации и принимает решения в условиях неполной информации. Используется модель Sugeno первого порядка, где выходная функция каждого правила представляет собой линейную комбинацию входных переменных. Такой подход обеспечивает вычислительную эффективность при достаточной точности аппроксимации.</p>
			<p>3. Структура нечёткой нейросетевой модели</p>
			<p>Входной вектор для модели формируется из JSON-пакетов, которые поступают на Raspberry Pi Zero 2W через роутер TL-WR703N каждые 32 секунды. За час набирается 112.5 пакетов, за сутки около 2700, что составляет примерно 765 КБ данных.</p>
			<fig id="F2">
				<label>Figure 2</label>
				<caption>
					<p>Функциональная схема нечёткой нейросетевой модели ANFIS для управления микро-ГЭС</p>
				</caption>
				<alt-text>Функциональная схема нечёткой нейросетевой модели ANFIS для управления микро-ГЭС</alt-text>
				<graphic ns0:href="/media/images/2026-03-15/eb3ad645-58d0-400d-a86f-740b7628d6ab.png"/>
			</fig>
			<p>Для контроля атмосферных условий служит датчик BME280. Он выдаёт температуру воздуха с точностью ±0.5°C, относительную влажность RH с погрешностью ±3%, атмосферное давление P с точностью ±1 гПа. Толщину снежного покрова определяет отдельный дальномер VL53L1X, направленный вертикально вниз на контрольную площадку.</p>
			<p>Состояние гидроагрегата отслеживает модуль MPU6050. Он измеряет ускорения по трём осям ωxωyωz</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>A</mml:mi>
						<mml:mrow>
							<mml:mi>v</mml:mi>
							<mml:mi>i</mml:mi>
							<mml:mi>b</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msqrt>
						<mml:mrow>
							<mml:msubsup>
								<mml:mi>a</mml:mi>
								<mml:mi>x</mml:mi>
								<mml:mn>2</mml:mn>
							</mml:msubsup>
							<mml:mo>+</mml:mo>
							<mml:msubsup>
								<mml:mi>a</mml:mi>
								<mml:mi>y</mml:mi>
								<mml:mn>2</mml:mn>
							</mml:msubsup>
							<mml:mo>+</mml:mo>
							<mml:msubsup>
								<mml:mi>a</mml:mi>
								<mml:mi>z</mml:mi>
								<mml:mn>2</mml:mn>
							</mml:msubsup>
						</mml:mrow>
					</mml:msqrt>
				</mml:mrow>
			</mml:math>
			<p>Гибридный инвертор передаёт уровень заряда аккумулятора SOC с точностью ±1%, напряжения [LATEX_FORMULA]U_{in}[/LATEX_FORMULA] и [LATEX_FORMULA]U_{out}[/LATEX_FORMULA] с погрешностью ±0.5%, токи [LATEX_FORMULA]I_{in}[/LATEX_FORMULA] и [LATEX_FORMULA]I_{out}[/LATEX_FORMULA] с точностью ±1%, частоты [LATEX_FORMULA]f_{in}[/LATEX_FORMULA] и [LATEX_FORMULA]f_{out}[/LATEX_FORMULA] с погрешностью ±0.1 Гц.</p>
			<p>Солнечная панель мощностью 2-3 Вт служит не только для питания датчиков, но и как индикатор освещённости. По её выходной мощности </p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>P</mml:mi>
						<mml:mrow>
							<mml:mi>s</mml:mi>
							<mml:mi>o</mml:mi>
							<mml:mi>l</mml:mi>
							<mml:mi>a</mml:mi>
							<mml:mi>r</mml:mi>
						</mml:mrow>
					</mml:msub>
				</mml:mrow>
			</mml:math>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>D</mml:mi>
						<mml:mi>l</mml:mi>
					</mml:msub>
				</mml:mrow>
			</mml:math>
			<p>Помимо мгновенных значений, модель использует производные признаки. Скорости изменения уровня воды </p>
			<p>Перед подачей в сеть все данные нормализуются по формуле:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>x</mml:mi>
						<mml:mrow>
							<mml:mtext>norm</mml:mtext>
						</mml:mrow>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mi>x</mml:mi>
						<mml:mo>−</mml:mo>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mrow>
								<mml:mtext>min </mml:mtext>
							</mml:mrow>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mo>/</mml:mo>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mrow>
								<mml:mtext>max </mml:mtext>
							</mml:mrow>
						</mml:msub>
						<mml:mo>−</mml:mo>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mrow>
								<mml:mtext>min </mml:mtext>
							</mml:mrow>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
				</mml:mrow>
			</mml:math>
			<p>Если какой-то датчик не передал значение, пропуск заполняется линейной интерполяцией или берётся последнее достоверное значение с флагом недостоверности.</p>
			<p>Архитектура реализована как ANFIS (Adaptive Neuro-Fuzzy Inference System). Это пятислойная сеть прямого распространения, где адаптивными являются узлы первого и четвёртого слоёв.</p>
			<p>В первом слое происходит фаззификация. Каждый узел вычисляет степень принадлежности входного значения к нечёткому множеству. Для плавно меняющихся величин вроде температуры воды, скорости потока и уровня применяются гауссовы функции принадлежности:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>μ</mml:mi>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>x</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo>=</mml:mo>
					<mml:mi>exp</mml:mi>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mo>−</mml:mo>
						<mml:mo stretchy="false">(</mml:mo>
						<mml:mi>x</mml:mi>
						<mml:mo>−</mml:mo>
						<mml:mi>c</mml:mi>
						<mml:msup>
							<mml:mo stretchy="false">)</mml:mo>
							<mml:mn>2</mml:mn>
						</mml:msup>
						<mml:mo>/</mml:mo>
						<mml:mn>2</mml:mn>
						<mml:msup>
							<mml:mi>σ</mml:mi>
							<mml:mn>2</mml:mn>
						</mml:msup>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
				</mml:mrow>
			</mml:math>
			<p>Параметры c (центр) и σ (ширина) являются адаптивными и подстраиваются в процессе обучения. Для дискретных состояний типа уровня заряда или частоты используются трапецеидальные функции:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>μ</mml:mi>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>x</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo>=</mml:mo>
					<mml:mo>max</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mn>0</mml:mn>
					<mml:mo>,</mml:mo>
					<mml:mo>min</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>x</mml:mi>
					<mml:mo>−</mml:mo>
					<mml:mi>a</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo>/</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>b</mml:mi>
					<mml:mo>−</mml:mo>
					<mml:mi>a</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo>,</mml:mo>
					<mml:mn>1</mml:mn>
					<mml:mo>,</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>d</mml:mi>
					<mml:mo>−</mml:mo>
					<mml:mi>x</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo>/</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>d</mml:mi>
					<mml:mo>−</mml:mo>
					<mml:mi>c</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo stretchy="false">)</mml:mo>
				</mml:mrow>
			</mml:math>
			<p>с параметрами (a, b, c, d). Всего в модели 88 функций принадлежности, по 4 терма на каждую из 22 входных переменных.</p>
			<p>Второй слой формирует предпосылки правил. Степень выполнения каждого правила вычисляется как произведение степеней принадлежности по всем входам:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>ω</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msubsup>
						<mml:mo>∏</mml:mo>
						<mml:mrow>
							<mml:mi>j</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mrow>
							<mml:mn>22</mml:mn>
						</mml:mrow>
					</mml:msubsup>
					<mml:msub>
						<mml:mi>μ</mml:mi>
						<mml:mrow>
							<mml:mi>A</mml:mi>
							<mml:mi>i</mml:mi>
							<mml:mi>j</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mi>j</mml:mi>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
				</mml:mrow>
			</mml:math>
			<p>Алгебраическое произведение выбрано как T-норма, потому что оно обеспечивает дифференцируемость, необходимую для градиентного обучения.</p>
			<p>Третий слой нормализует веса правил:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msub>
						<mml:mover>
							<mml:mrow>
								<mml:mi>w</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="true">¯</mml:mo>
						</mml:mover>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msub>
						<mml:mi>w</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>/</mml:mo>
					<mml:munderover>
						<mml:mo>∑</mml:mo>
						<mml:mrow>
							<mml:mi>k</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mi>N</mml:mi>
					</mml:munderover>
					<mml:mi>w</mml:mi>
					<mml:mi>k</mml:mi>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>где N означает общее количество правил в базе.</p>
			<p>Четвёртый слой вычисляет взвешенные заключения. Выход каждого правила представляет собой линейную комбинацию входов, умноженную на нормализованный вес:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msubsup>
						<mml:mi>O</mml:mi>
						<mml:mi>i</mml:mi>
						<mml:mn>4</mml:mn>
					</mml:msubsup>
					<mml:mo>=</mml:mo>
					<mml:msub>
						<mml:mover>
							<mml:mrow>
								<mml:mi>w</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="true">¯</mml:mo>
						</mml:mover>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:msub>
						<mml:mi>f</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msub>
						<mml:mover>
							<mml:mrow>
								<mml:mi>w</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="true">¯</mml:mo>
						</mml:mover>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:msub>
							<mml:mi>p</mml:mi>
							<mml:mi>i</mml:mi>
						</mml:msub>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mn>1</mml:mn>
						</mml:msub>
						<mml:mo>+</mml:mo>
						<mml:msub>
							<mml:mi>q</mml:mi>
							<mml:mi>i</mml:mi>
						</mml:msub>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mn>2</mml:mn>
						</mml:msub>
						<mml:mo>+</mml:mo>
						<mml:mi>…</mml:mi>
						<mml:mo>+</mml:mo>
						<mml:msub>
							<mml:mi>r</mml:mi>
							<mml:mi>i</mml:mi>
						</mml:msub>
						<mml:msub>
							<mml:mi>x</mml:mi>
							<mml:mrow>
								<mml:mn>22</mml:mn>
							</mml:mrow>
						</mml:msub>
						<mml:mo>+</mml:mo>
						<mml:msub>
							<mml:mi>s</mml:mi>
							<mml:mi>i</mml:mi>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Коэффициенты (p, q, ..., s) называются консеквентными параметрами. При 52 правилах и 23 коэффициентах на каждое правило (22 входа плюс свободный член) получается 1196 консеквентных параметров.</p>
			<p>Пятый слой суммирует выходы всех правил:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mi>y</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:msubsup>
						<mml:mo>∑</mml:mo>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mi>N</mml:mi>
					</mml:msubsup>
					<mml:msub>
						<mml:mover>
							<mml:mrow>
								<mml:mi>ω</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="true">¯</mml:mo>
						</mml:mover>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:msub>
						<mml:mi>f</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>На выходе модель выдаёт вектор из трёх компонент: положение заслонки </p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>P</mml:mi>
						<mml:mrow>
							<mml:mi>g</mml:mi>
							<mml:mi>a</mml:mi>
							<mml:mi>t</mml:mi>
							<mml:mi>e</mml:mi>
						</mml:mrow>
					</mml:msub>
				</mml:mrow>
			</mml:math>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>C</mml:mi>
						<mml:mrow>
							<mml:mi>g</mml:mi>
							<mml:mi>r</mml:mi>
							<mml:mi>i</mml:mi>
							<mml:mi>d</mml:mi>
						</mml:mrow>
					</mml:msub>
				</mml:mrow>
			</mml:math>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mi>E</mml:mi>
						<mml:mrow>
							<mml:mi>p</mml:mi>
							<mml:mi>r</mml:mi>
							<mml:mi>e</mml:mi>
							<mml:mi>d</mml:mi>
						</mml:mrow>
					</mml:msub>
				</mml:mrow>
			</mml:math>
			<p>База правил генерируется методом субтрактивной кластеризации. Суть алгоритма в следующем. Для каждой точки обучающей выборки </p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msub>
						<mml:mi>P</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msubsup>
						<mml:mo>∑</mml:mo>
						<mml:mrow>
							<mml:mi>j</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mi>M</mml:mi>
					</mml:msubsup>
					<mml:mi>exp</mml:mi>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mo>−</mml:mo>
						<mml:msup>
							<mml:mrow>
								<mml:mo stretchy="true" fence="true" form="prefix">‖</mml:mo>
								<mml:msub>
									<mml:mi>x</mml:mi>
									<mml:mi>i</mml:mi>
								</mml:msub>
								<mml:mo>−</mml:mo>
								<mml:msub>
									<mml:mi>x</mml:mi>
									<mml:mi>j</mml:mi>
								</mml:msub>
								<mml:mo stretchy="true" fence="true" form="postfix">‖</mml:mo>
							</mml:mrow>
							<mml:mn>2</mml:mn>
						</mml:msup>
						<mml:mo>/</mml:mo>
						<mml:msup>
							<mml:mrow>
								<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
								<mml:msub>
									<mml:mi>r</mml:mi>
									<mml:mi>a</mml:mi>
								</mml:msub>
								<mml:mo>/</mml:mo>
								<mml:mn>2</mml:mn>
								<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
							</mml:mrow>
							<mml:mn>2</mml:mn>
						</mml:msup>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>где M это размер выборки, а ra = Missing Mark : sub0.5 задаёт радиус влияния. Точка с максимальным потенциалом становится центром первого кластера c1Missing Mark : sub. После этого потенциалы пересчитываются:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msub>
						<mml:mi>P</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>←</mml:mo>
					<mml:msub>
						<mml:mi>P</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>−</mml:mo>
					<mml:msub>
						<mml:mi>P</mml:mi>
						<mml:mrow>
							<mml:mi>c</mml:mi>
							<mml:mi>i</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mi>exp</mml:mi>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mo>−</mml:mo>
						<mml:msup>
							<mml:mrow>
								<mml:mo stretchy="true" fence="true" form="prefix">‖</mml:mo>
								<mml:msub>
									<mml:mi>x</mml:mi>
									<mml:mi>j</mml:mi>
								</mml:msub>
								<mml:mo>−</mml:mo>
								<mml:msub>
									<mml:mi>c</mml:mi>
									<mml:mn>1</mml:mn>
								</mml:msub>
								<mml:mo stretchy="true" fence="true" form="postfix">‖</mml:mo>
							</mml:mrow>
							<mml:mn>2</mml:mn>
						</mml:msup>
						<mml:mo>/</mml:mo>
						<mml:msup>
							<mml:mrow>
								<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
								<mml:msub>
									<mml:mi>r</mml:mi>
									<mml:mi>b</mml:mi>
								</mml:msub>
								<mml:mo>/</mml:mo>
								<mml:mn>2</mml:mn>
								<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
							</mml:mrow>
							<mml:mn>2</mml:mn>
						</mml:msup>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mo>,</mml:mo>
					<mml:mi>·</mml:mi>
					<mml:msub>
						<mml:mi>r</mml:mi>
						<mml:mi>b</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:mn>1.5</mml:mn>
					<mml:msub>
						<mml:mi>r</mml:mi>
						<mml:mi>a</mml:mi>
					</mml:msub>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Процедура повторяется, пока максимальный потенциал не упадёт ниже 15% от начального значения. На данных микро-ГЭС алгоритм выделил 52 кластера, что дало 52 правила. Это позволяет плотно покрыть входное пространство, избежав комбинаторного взрыва (при grid partitioning c 5 термами на переменную получилось бы 5^10 ≈ 10^7 правил).</p>
			<p>Центры кластеров служат начальными значениями для параметров гауссовых функций принадлежности. Ширина [LATEX_FORMULA]$\sigma_{i j}=r_a / \sqrt{2}$[/LATEX_FORMULA] </p>
			<p>База правил хранится в JSON-формате:</p>
			<p>Поле activation_count накапливает статистику срабатываний для последующей оптимизации базы.</p>
			<p>На Raspberry Pi Zero 2W (ARM Cortex-A53 с 4 ядрами по 1 ГГц, 512 МБ RAM) полный цикл обработки занимает 58 мс. Из них 3 мс уходит на парсинг JSON, 5 мс на запись в SQLite, 50 мс на инференс ANFIS через 52 правила. При периоде опроса 32 секунды загрузка процессора составляет 0.2%, потребление около 2.5 Вт. Параметры модели (88 центров, 88 ширин, 1196 консеквентов) занимают 2.3 МБ оперативной памяти </p>
			<p>[7]</p>
			<p>4. Обучение и адаптация модели</p>
			<p>Для обучения применяется гибридный алгоритм, сочетающий метод наименьших квадратов (LSE) для консеквентных параметров и градиентный спуск для параметров антецедентов (центров и ширин функций принадлежности). Каждая эпоха состоит из двух проходов: прямого (forward pass) и обратного (backward pass).</p>
			<fig id="F3">
				<label>Figure 3</label>
				<caption>
					<p>Блок-схема онлайн-адаптации нечёткой нейросетевой модели ANFIS в архитектуре edge-cloud</p>
				</caption>
				<alt-text>Блок-схема онлайн-адаптации нечёткой нейросетевой модели ANFIS в архитектуре edge-cloud</alt-text>
				<graphic ns0:href="/media/images/2026-03-15/1e026106-0304-4109-aa6a-22e1833cdc97.png"/>
			</fig>
			<mml:math display="inline">
				<mml:mrow>
					<mml:msub>
						<mml:mover>
							<mml:mrow>
								<mml:mi>w</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="true">¯</mml:mo>
						</mml:mover>
						<mml:mi>i</mml:mi>
					</mml:msub>
				</mml:mrow>
			</mml:math>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msup>
						<mml:mi>A</mml:mi>
						<mml:mrow>
							<mml:mo stretchy="false">(</mml:mo>
							<mml:mi>k</mml:mi>
							<mml:mo stretchy="false">)</mml:mo>
						</mml:mrow>
					</mml:msup>
					<mml:mo>=</mml:mo>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">[</mml:mo>
						<mml:msup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msup>
						<mml:msubsup>
							<mml:mi>x</mml:mi>
							<mml:mn>1</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>,</mml:mo>
						<mml:msup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msup>
						<mml:msubsup>
							<mml:mi>x</mml:mi>
							<mml:mn>2</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>,</mml:mo>
						<mml:mi>…</mml:mi>
						<mml:mo>,</mml:mo>
						<mml:msup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msup>
						<mml:mo>,</mml:mo>
						<mml:mi>…</mml:mi>
						<mml:mo>,</mml:mo>
						<mml:msubsup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mn>22</mml:mn>
							</mml:mrow>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:msubsup>
							<mml:mi>x</mml:mi>
							<mml:mn>1</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>,</mml:mo>
						<mml:mi>…</mml:mi>
						<mml:mo>,</mml:mo>
						<mml:msubsup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mn>52</mml:mn>
							</mml:mrow>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo stretchy="true" fence="true" form="postfix">]</mml:mo>
					</mml:mrow>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Вектор консеквентных параметров θ имеет размерность 1196, вектор целевых значений B содержит M элементов. Система Aθ = B решается через псевдообратную матрицу:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msup>
						<mml:mi>θ</mml:mi>
						<mml:mo>*</mml:mo>
					</mml:msup>
					<mml:mo>=</mml:mo>
					<mml:msup>
						<mml:mrow>
							<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
							<mml:msup>
								<mml:mi>A</mml:mi>
								<mml:mi>T</mml:mi>
							</mml:msup>
							<mml:mi>A</mml:mi>
							<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
						</mml:mrow>
						<mml:mrow>
							<mml:mo stretchy="false">(</mml:mo>
							<mml:mo>−</mml:mo>
							<mml:mn>1</mml:mn>
							<mml:mo stretchy="false">)</mml:mo>
						</mml:mrow>
					</mml:msup>
					<mml:msup>
						<mml:mi>A</mml:mi>
						<mml:mi>T</mml:mi>
					</mml:msup>
					<mml:mi>B</mml:mi>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>При большом размере выборки используется SVD-разложение или метод сопряжённых градиентов. Чтобы избежать переобучения, добавляется Ridge-регуляризация:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msup>
						<mml:mi>θ</mml:mi>
						<mml:mo>*</mml:mo>
					</mml:msup>
					<mml:mo>=</mml:mo>
					<mml:msup>
						<mml:mrow>
							<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
							<mml:msup>
								<mml:mi>A</mml:mi>
								<mml:mi>T</mml:mi>
							</mml:msup>
							<mml:mi>A</mml:mi>
							<mml:mo>+</mml:mo>
							<mml:mi>λ</mml:mi>
							<mml:mi>I</mml:mi>
							<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
						</mml:mrow>
						<mml:mrow>
							<mml:mo>−</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
					</mml:msup>
					<mml:msup>
						<mml:mi>A</mml:mi>
						<mml:mi>T</mml:mi>
					</mml:msup>
					<mml:mi>B</mml:mi>
					<mml:mo>,</mml:mo>
					<mml:mi>·</mml:mi>
					<mml:mi>λ</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:mn>0.01</mml:mn>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>На обратном проходе сеть с найденными консеквентами выдаёт предсказания </p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msup>
						<mml:mover>
							<mml:mrow>
								<mml:mi>y</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="false">^</mml:mo>
						</mml:mover>
						<mml:mrow>
							<mml:mo stretchy="false">(</mml:mo>
							<mml:mi>k</mml:mi>
							<mml:mo stretchy="false">)</mml:mo>
						</mml:mrow>
					</mml:msup>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mi>E</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:mn>1</mml:mn>
					<mml:mo>/</mml:mo>
					<mml:mn>2</mml:mn>
					<mml:msubsup>
						<mml:mo>∑</mml:mo>
						<mml:mrow>
							<mml:mi>k</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mi>M</mml:mi>
					</mml:msubsup>
					<mml:msup>
						<mml:mrow>
							<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
							<mml:msup>
								<mml:mi>y</mml:mi>
								<mml:mi>k</mml:mi>
							</mml:msup>
							<mml:mo>−</mml:mo>
							<mml:msup>
								<mml:mover>
									<mml:mrow>
										<mml:mi>y</mml:mi>
									</mml:mrow>
									<mml:mo stretchy="false">^</mml:mo>
								</mml:mover>
								<mml:mi>k</mml:mi>
							</mml:msup>
							<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
						</mml:mrow>
						<mml:mn>2</mml:mn>
					</mml:msup>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Градиенты по параметрам антецедентов вычисляются через правило цепочки (chain rule) методом обратного распространения:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mo>∂</mml:mo>
					<mml:mi>E</mml:mi>
					<mml:mo>/</mml:mo>
					<mml:mo>∂</mml:mo>
					<mml:msub>
						<mml:mi>c</mml:mi>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mi>j</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msubsup>
						<mml:mo>∑</mml:mo>
						<mml:mrow>
							<mml:mi>k</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mi>M</mml:mi>
					</mml:msubsup>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:mi>E</mml:mi>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>y</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="false">^</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msup>
						<mml:mo>*</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>y</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="false">^</mml:mo>
							</mml:mover>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msup>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msubsup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mn>1</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>*</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msubsup>
							<mml:mover>
								<mml:mrow>
									<mml:mi>ω</mml:mi>
								</mml:mrow>
								<mml:mo stretchy="true">¯</mml:mo>
							</mml:mover>
							<mml:mn>1</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msubsup>
							<mml:mi>ω</mml:mi>
							<mml:mn>1</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>*</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msubsup>
							<mml:mi>ω</mml:mi>
							<mml:mn>1</mml:mn>
							<mml:mrow>
								<mml:mo stretchy="false">(</mml:mo>
								<mml:mi>k</mml:mi>
								<mml:mo stretchy="false">)</mml:mo>
							</mml:mrow>
						</mml:msubsup>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msub>
							<mml:mi>μ</mml:mi>
							<mml:mrow>
								<mml:mi>i</mml:mi>
								<mml:mi>j</mml:mi>
							</mml:mrow>
						</mml:msub>
						<mml:mo>*</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msub>
							<mml:mi>μ</mml:mi>
							<mml:mrow>
								<mml:mi>i</mml:mi>
								<mml:mi>j</mml:mi>
							</mml:mrow>
						</mml:msub>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msub>
							<mml:mi>c</mml:mi>
							<mml:mrow>
								<mml:mi>i</mml:mi>
								<mml:mi>j</mml:mi>
							</mml:mrow>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Для гауссовой функции принадлежности частные производные имеют вид:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mo>∂</mml:mo>
					<mml:mi>μ</mml:mi>
					<mml:mo>/</mml:mo>
					<mml:mo>∂</mml:mo>
					<mml:mi>c</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:mi>μ</mml:mi>
					<mml:mo>*</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>x</mml:mi>
					<mml:mo>−</mml:mo>
					<mml:mi>c</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mo>/</mml:mo>
					<mml:msup>
						<mml:mi>σ</mml:mi>
						<mml:mn>2</mml:mn>
					</mml:msup>
					<mml:mo>,</mml:mo>
					<mml:mi>·</mml:mi>
					<mml:mo>∂</mml:mo>
					<mml:mi>μ</mml:mi>
					<mml:mo>/</mml:mo>
					<mml:mo>∂</mml:mo>
					<mml:mi>σ</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:mi>μ</mml:mi>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mi>x</mml:mi>
					<mml:mo>−</mml:mo>
					<mml:mi>c</mml:mi>
					<mml:msup>
						<mml:mo stretchy="false">)</mml:mo>
						<mml:mn>2</mml:mn>
					</mml:msup>
					<mml:mo>/</mml:mo>
					<mml:msup>
						<mml:mi>σ</mml:mi>
						<mml:mn>3</mml:mn>
					</mml:msup>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Параметры обновляются по правилу:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msub>
						<mml:mi>c</mml:mi>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mo>,</mml:mo>
							<mml:mi>j</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mo>←</mml:mo>
					<mml:msub>
						<mml:mi>c</mml:mi>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mi>j</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mo>−</mml:mo>
					<mml:mi>η</mml:mi>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:mi>E</mml:mi>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msub>
							<mml:mi>c</mml:mi>
							<mml:mrow>
								<mml:mi>i</mml:mi>
								<mml:mi>j</mml:mi>
							</mml:mrow>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mo>,</mml:mo>
					<mml:mi>·</mml:mi>
					<mml:msub>
						<mml:mi>σ</mml:mi>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mo>,</mml:mo>
							<mml:mi>j</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mo>←</mml:mo>
					<mml:msub>
						<mml:mi>σ</mml:mi>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mi>j</mml:mi>
						</mml:mrow>
					</mml:msub>
					<mml:mo>−</mml:mo>
					<mml:mi>η</mml:mi>
					<mml:mrow>
						<mml:mo stretchy="true" fence="true" form="prefix">(</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:mi>E</mml:mi>
						<mml:mo>/</mml:mo>
						<mml:mo>∂</mml:mo>
						<mml:msub>
							<mml:mi>σ</mml:mi>
							<mml:mrow>
								<mml:mi>i</mml:mi>
								<mml:mi>j</mml:mi>
							</mml:mrow>
						</mml:msub>
						<mml:mo stretchy="true" fence="true" form="postfix">)</mml:mo>
					</mml:mrow>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Скорость обучения η = 0.01 уменьшается по формуле adaptive decay:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msub>
						<mml:mi>η</mml:mi>
						<mml:mi>t</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msub>
						<mml:mi>η</mml:mi>
						<mml:mn>0</mml:mn>
					</mml:msub>
					<mml:mo>/</mml:mo>
					<mml:mo stretchy="false">(</mml:mo>
					<mml:mn>1</mml:mn>
					<mml:mo>+</mml:mo>
					<mml:mn>0.001</mml:mn>
					<mml:mo>*</mml:mo>
					<mml:mi>t</mml:mi>
					<mml:mo stretchy="false">)</mml:mo>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Начальное обучение проводилось на данных крупных ГЭС (Саяно-Шушенская, Красноярская) за период 2015-2024 годов. Исходная выборка содержала 18 млн записей с шагом 5 минут, которые были агрегированы до 1 млн точек путём усреднения. Поскольку параметры крупных станций (расход порядка 103 Missing Mark : supм3Missing Mark : sup/с, мощность 100 МВт) отличаются от микро-ГЭС (расход 0.93 Missing Mark : supм3Missing Mark : sup/с, мощность 10.75 кВт), применялось масштабирование через коэффициенты подобия. Критерий Фруда: </p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mi>F</mml:mi>
					<mml:mi>r</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:mi>V</mml:mi>
					<mml:mo>/</mml:mo>
					<mml:msqrt>
						<mml:mrow>
							<mml:mi>g</mml:mi>
							<mml:mi>H</mml:mi>
						</mml:mrow>
					</mml:msqrt>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mi>R</mml:mi>
					<mml:mi>e</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:mi>V</mml:mi>
					<mml:mi>D</mml:mi>
					<mml:mo>/</mml:mo>
					<mml:mi>v</mml:mi>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Обучение проводилось на сервере с процессором AMD Ryzen 7 2700 и 32 ГБ оперативной памяти. При использовании 16 вычислительных потоков 200 эпох заняли 2.5 часа. Финальная ошибка RMSE составила 0.042 для нормализованных выходов. После обучения модель развёртывается на Raspberry Pi Zero 2W, где выполняется только инференс (прямой проход) без дообучения. Задержка предсказания не превышает 50 мс.</p>
			<p>Онлайн-адаптация реализована по схеме edge-cloud. Каждые 32 секунды система получает новую пару (xnewMissing Mark : sub, ynewMissing Mark : sub) и вычисляет ошибку предсказания e = yrealMissing Mark : sub – ypredMissing Mark : sub. Если модуль ошибки превышает порог τ = 0.1, запись сохраняется в локальную базу SQLite. Раз в сутки накопленные 2700 записей (примерно 765 КБ) передаются на удалённый сервер через LTE-модем. Сервер выполняет глубокое переобучение гибридным алгоритмом (50 эпох, около 7 минут на Ryzen 7 2700). Обновлённые параметры (2.3 МБ) возвращаются на Raspberry Pi, где загружаются без прерывания работы через сигнал SIGUSR1. Переключение указателей в памяти занимает менее 10 мс.</p>
			<p>Для критических ситуаций предусмотрена локальная микро-адаптация. Если какое-то правило активировалось (</p>
			<code>[LATEX_FORMULA]$\bar{w}_i&amp;gt;0.01$[/LATEX_FORMULA]</code>
			<p>Предусмотрен механизм автоматического расширения базы правил. Если максимальная степень активации всех правил падает ниже 0.05, значит текущая ситуация не покрывается имеющейся базой. В этом случае создаётся новое правило с центром в точке текущих входов. Обратная операция, отсев неактивных правил, выполняется каждые 1000 циклов.</p>
			<p>За 6 месяцев онлайн-адаптации метрики существенно улучшились. Ошибка RMSE снизилась с 0.042 до 0.018 (в 2.3 раза), коэффициент детерминации R2Missing Mark : sup вырос с 0.91 до 0.97.</p>
			<p>5. Основные результаты</p>
			<p>На Raspberry Pi Zero 2W (ARM Cortex-A53, 1 ГГц) инференс ANFIS занимает 50 мс. Загрузка процессора при периоде опроса 32 секунды составляет 0.2%. Потребление всего узла обработки около 2.5 Вт. Модель с 52 правилами (88 центров + 88 ширин + 1196 консеквентов) занимает 2.3 МБ памяти. Полный цикл обработки от получения JSON до выдачи команды укладывается в 58 мс </p>
			<p>[8]</p>
			<p>Обучение на 1 млн записей (200 эпох) на сервере AMD Ryzen 7 2700 заняло 2.5 часа. Достигнутые метрики: </p>
			<p>RMSE = 0.042[9]</p>
			<p>В процессе эксплуатации система постоянно совершенствовалась. Ошибка RMSE упала с 0.042 до 0.018 (улучшение в 2.3 раза). Коэффициент R2Missing Mark : sup вырос с 0.91 до 0.97. Энергопотери от неоптимальных режимов снизились с 8% до 3%, что при средней выработке 8.75 кВт даёт экономию около 410 кВт·ч в год. Количество ложных срабатываний защиты сократилось с 12 до 2 в месяц (на 83%).</p>
			<p>При выходе из строя 1-2 датчиков из 22 точность модели снижается умеренно: RMSE возрастает с 0.018 до 0.025. Для сравнения, классические ПИД-регуляторы полностью теряют работоспособность при потере критического датчика.</p>
			<p>6. Обсуждение</p>
			<p>Прогнозирование весеннего паводка. Всю зиму система накапливает данные о толщине снежного покрова SdMissing Mark : sub (дальномер VL53L1X делает замеры каждые 32 секунды, затем вычисляются суточные максимумы). Одновременно отслеживается динамика температуры воздуха TaMissing Mark : sub и длительность светового дня DlMissing Mark : sub. Если зима была холодной и снежной (SdMissing Mark : sub &gt; 500 мм держится более 90 дней, средняя TaMissing Mark : sub &lt; -10 °C), а затем наступает резкое потепление (скорость роста температуры TaMissing Mark : sub &gt; 3 °C в сутки, устойчивая TaMissing Mark : sub &gt; 5 °C), модель прогнозирует интенсивное таяние снега и высокую паводковую нагрузку.</p>
			<p>Соответствующее нечёткое правило формулируется так: ЕСЛИ SdMissing Mark : sub «очень высокая» И TaMissing Mark : sub «быстрый рост» И DlMissing Mark : sub «увеличивается», ТО вероятность паводка «высокая». Консеквент [0.8, 0.15, −0.3, ..., 25.3] транслируется в рекомендацию прикрыть заслонку до 40% за 5 дней до ожидаемого пика.</p>
			<p>Получив прогноз, система за 3–7 дней до паводка проверяет работоспособность электропривода заслонки. Для этого выполняется тестовое перемещение 0% → 100% → 40% за 2 минуты с контролем тока двигателя. Затем заслонка постепенно прикрывается, снижая расход воды через турбину с 0.93 м3Missing Mark : sup/с до 0.6 м3Missing Mark : sup/с (на 35%). Мощность при этом падает с 10.8 кВт до 7.0 кВт.</p>
			<p>Такая превентивная стратегия защищает гидроагрегат от перегрузки. Номинальная мощность турбины 10.75 кВт при расходе 0.93 м³/с. Если мощность превысит 13.4 кВт (125% номинала), обмотки генератора перегреются выше 85°C, что типично для синхронных генераторов мощностью 11–12 кВА. Снижение расхода на 35% создаёт запас безопасности на случай пикового паводка, когда скорость потока кратковременно может достигать 2-2.5 м/с. Заодно предотвращается гидравлический удар при резком изменении уровня.</p>
			<p>Защита от механических загрязнений. Когда скорость потока VfMissing Mark : sub превышает 2.6 м/с (порог должен держаться в 5 последовательных циклах, то есть 160 секунд) и одновременно уровень воды растёт быстрее 50 мм/час, модель интерпретирует ситуацию как начало паводка с высокой вероятностью переноса мусора.</p>
			<p>Нечёткое правило: ЕСЛИ Vf Missing Mark : sub «очень высока» И H «быстро растёт», ТО риск засора «высокий». Выход CgridMissing Mark : sub = 1 означает команду на подъём сороудерживающей решётки. Актуатор поднимает решётку на 1200 мм за 20 секунд, перекрывая путь веткам толще 50 мм, пластиковым бутылкам и водорослям.</p>
			<p>Поднятая решётка частично тормозит поток. Скорость в канале падает с 2.6 до 2.1 м/с (примерно на 20%), выработка снижается с 11.8 кВт до 8.8 кВт (на 25%, расход с 1.10 до 0.90 м³/с). Однако это оправдано, поскольку ремонт повреждённой турбины обойдётся значительно дороже.</p>
			<p>Через час система повторно оценивает обстановку. Если скорость упала ниже 2.3 м/с, а рост уровня замедлился до 20 мм/час, решётка автоматически опускается.</p>
			<p>Сезонная адаптация. Гидрологический режим реки существенно меняется в течение года. В таблице 1 приведены характерные параметры для четырёх сезонов.</p>
			<table-wrap id="T1">
				<label>Table 1</label>
				<caption>
					<p>Сезонные режимы эксплуатации микро-ГЭС</p>
				</caption>
				<table>
					<tr>
						<td>Сезон</td>
						<td>, м/с</td>
						<td>, м/с</td>
						<td>, °C</td>
						<td>Q, </td>
						<td>P, кВт</td>
						<td>, %</td>
						<td>КПД, %</td>
						<td>Особенности</td>
					</tr>
					<tr>
						<td>Весенний паводок (март-апрель)</td>
						<td>1,3-1,5</td>
						<td>2,2-2,8</td>
						<td>4-8</td>
						<td>0,85-1,15</td>
						<td>9,5-12,5</td>
						<td>75-90</td>
						<td>82-88</td>
						<td>Риск перегрузки, подъём решётки при V &gt; 2,6 м/с</td>
					</tr>
					<tr>
						<td>Летняя межень (июль-август)</td>
						<td>0,65-0,85</td>
						<td>1,0-1,5</td>
						<td>18-22</td>
						<td>0,30-0,55</td>
						<td>2,5-5,5</td>
						<td>40-55</td>
						<td>68-78</td>
						<td>Минимальная выработка, низкий КПД</td>
					</tr>
					<tr>
						<td>Осенние дожди (октябрь-ноябрь)</td>
						<td>1,1-1,3</td>
						<td>1,8-2,3</td>
						<td>8-12</td>
						<td>0,65-0,90</td>
						<td>7,0-10,0</td>
						<td>60-75</td>
						<td>80-86</td>
						<td>Засорение решётки листвой (подъём каждые 6 ч)</td>
					</tr>
					<tr>
						<td>Зимний ледостав (декабрь-февраль)</td>
						<td>0,8-1,0</td>
						<td>1,2-1,6</td>
						<td>0-2</td>
						<td>0,45-0,65</td>
						<td>4,5-7,0</td>
						<td>50-65</td>
						<td>75-82</td>
						<td>Риск льдообразования</td>
					</tr>
				</table>
			</table-wrap>
			<p>Обозначения: </p>
			<p>VрекаVканалPgate</p>
			<p>Система переключается между сезонными режимами, анализируя температуру воды </p>
			<p>Tw</p>
			<p>Модель Sugeno с линейными заключениями:</p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:msub>
						<mml:mi>f</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mo>=</mml:mo>
					<mml:msub>
						<mml:mi>p</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:msub>
						<mml:mi>x</mml:mi>
						<mml:mn>1</mml:mn>
					</mml:msub>
					<mml:mo>+</mml:mo>
					<mml:msub>
						<mml:mi>q</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:msub>
						<mml:mi>x</mml:mi>
						<mml:mn>2</mml:mn>
					</mml:msub>
					<mml:mo>+</mml:mo>
					<mml:mi>…</mml:mi>
					<mml:mo>+</mml:mo>
					<mml:msub>
						<mml:mi>r</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:msub>
						<mml:mi>x</mml:mi>
						<mml:mrow>
							<mml:mn>22</mml:mn>
						</mml:mrow>
					</mml:msub>
					<mml:mo>+</mml:mo>
					<mml:msub>
						<mml:mi>s</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Позволяет вычислять выход как взвешенное среднее без процедуры дефаззификации </p>
			<mml:math display="inline">
				<mml:mrow>
					<mml:mi>$</mml:mi>
					<mml:mi>y</mml:mi>
					<mml:mo>=</mml:mo>
					<mml:msubsup>
						<mml:mo>∑</mml:mo>
						<mml:mrow>
							<mml:mi>i</mml:mi>
							<mml:mo>=</mml:mo>
							<mml:mn>1</mml:mn>
						</mml:mrow>
						<mml:mrow>
							<mml:mn>52</mml:mn>
						</mml:mrow>
					</mml:msubsup>
					<mml:msub>
						<mml:mover>
							<mml:mrow>
								<mml:mi>ω</mml:mi>
							</mml:mrow>
							<mml:mo stretchy="true">¯</mml:mo>
						</mml:mover>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:msub>
						<mml:mi>f</mml:mi>
						<mml:mi>i</mml:mi>
					</mml:msub>
					<mml:mi>$</mml:mi>
				</mml:mrow>
			</mml:math>
			<p>Гибридный алгоритм обучения (LSE для консеквентов, градиентный спуск для антецедентов) обеспечивает быструю сходимость. Начальное обучение на 1 млн записей занимает 2.5 часа на AMD Ryzen 7 2700, достигая RMSE = 0.042, R2Missing Mark : sup = 0.91.</p>
			<p>Онлайн-адаптация приносит ощутимые результаты. За полгода RMSE падает с 0.042 до 0.018 (в 2.3 раза), R2Missing Mark : sup растёт с 0.91 до 0.97. Энергопотери от неоптимальных режимов сокращаются с 8% до 3%, что при выработке 8.75 кВт экономит около 410 кВт*ч в год. Ложные срабатывания защиты уменьшаются с 12 до 2 в месяц (на 83%).</p>
			<p>Модель терпима к отказам датчиков. Потеря 1–2 сенсоров из 22 увеличивает RMSE с 0.018 до 0.025, но не приводит к полному отказу, как это произошло бы с классическим ПИД-регулятором.</p>
			<p>База из 52 правил полностью инспектируема. Оператор видит, какие условия привели к конкретному решению. Это соответствует требованиям стандарта IEC 61508 для систем безопасности </p>
			<p>[9][10]</p>
			<p>7. Заключение</p>
			<p>Разработанная система управления микро‑ГЭС на основе нечёткой нейросетевой модели ANFIS обеспечивает автономную работу объекта без постоянного присутствия оператора за счёт трёхуровневой edge‑cloud архитектуры. Локальный контроллер Raspberry Pi Zero 2W выполняет инференс в реальном времени при низкой загрузке вычислительных ресурсов, в то время как удалённый сервер AMD Ryzen 7 2700 берёт на себя вычислительно затратные процедуры начального обучения и регулярного переобучения модели. Входной вектор из 22 параметров формируется распределённой сенсорной сетью, включающей шесть узлов ESP32 с гидрологическими, атмосферными и вибрационными датчиками, а также гибридный инвертор, что позволяет учитывать как состояние водотока, так и энергетический режим системы.</p>
			<p>В ходе эксплуатации реализованы четыре сценария автономного управления: прогнозирование весеннего паводка с заблаговременным снижением расхода через турбину, защита от механических загрязнений путём автоматического подъёма сороудерживающей решётки, сезонная адаптация к изменению гидрологического режима и управление энергобалансом с учётом состояния аккумуляторного блока. Эти сценарии опираются на интерпретируемую базу из 52 нечётких правил, генерируемых методом субтрактивной кластеризации, что обеспечивает возможность экспертного контроля и последующей корректировки базы знаний.</p>
			<p>Гибридный алгоритм онлайн‑адаптации сочетает централизованное переобучение на сервере с локальной микро‑адаптацией на edge‑устройстве, позволяя системе накапливать эксплуатационный опыт и улучшать качество управления без остановки работы. Показано, что такое сочетание даёт заметный эффект в виде уменьшения энергетических потерь, сокращения числа ложных срабатываний защитных механизмов и повышения устойчивости к деградации измерительной подсистемы. Полученные результаты подтверждают применимость предложенной архитектуры для интеллектуального управления автономными энергообъектами малой мощности и создают предпосылки для её масштабирования на распределённые сети микро‑ГЭС.</p>
		</sec>
		<sec sec-type="supplementary-material">
			<title>Additional File</title>
			<p>The additional file for this article can be found as follows:</p>
			<supplementary-material xmlns:xlink="http://www.w3.org/1999/xlink" id="S1" xlink:href="https://doi.org/10.5334/cpsy.78.s1">
				<!--[<inline-supplementary-material xlink:title="local_file" xlink:href="https://research-journal.org/media/articles/23056.docx">23056.docx</inline-supplementary-material>]-->
				<!--[<inline-supplementary-material xlink:title="local_file" xlink:href="https://research-journal.org/media/articles/23056.pdf">23056.pdf</inline-supplementary-material>]-->
				<label>Online Supplementary Material</label>
				<caption>
					<p>
						Further description of analytic pipeline and patient demographic information. DOI:
						<italic>
							<uri>https://doi.org/10.60797/IRJ.2026.165.60</uri>
						</italic>
					</p>
				</caption>
			</supplementary-material>
		</sec>
	</body>
	<back>
		<ack>
			<title>Acknowledgements</title>
			<p/>
		</ack>
		<sec>
			<title>Competing Interests</title>
			<p/>
		</sec>
		<ref-list>
			<ref id="B1">
				<label>1</label>
				<mixed-citation publication-type="confproc">Лукутин Б.В. Автономное электроснабжение от микрогидроэлектростанций: монография / Б.В. Лукутин, С.Г. Обухов, Е.Б. Шандарова. — Томск: Изд-во ТПУ, 2001. — 104 с.</mixed-citation>
			</ref>
			<ref id="B2">
				<label>2</label>
				<mixed-citation publication-type="confproc">Интегрированные модели и мягкие вычисления в искусственном интеллекте: сборник научных трудов X-й Международной научно-технической конференции (ИММВ-2021, Коломна, 17-20 мая 2021 г.): в 2 т. — Смоленск: Универсум, 2021. — Т. 1. — 449 с.</mixed-citation>
			</ref>
			<ref id="B3">
				<label>3</label>
				<mixed-citation publication-type="confproc">Djurasevic S. Optimization of control algorithm in small hydropower plant / S. Djurasevic, U. Pesovic // Proceedings of the International Scientific Conference &quot;UNITECH 2019&quot;. — Gabrovo, Bulgaria, 2019. — November 15-16. — P. 354–357.</mixed-citation>
			</ref>
			<ref id="B4">
				<label>4</label>
				<mixed-citation publication-type="confproc">Asanov M.S. Algorithm for calculation and selection of micro hydropower plant taking into account hydrological parameters of small watercourses mountain rivers of Central Asia / M.S. Asanov, M.Kh. Safaraliev, T.Zh. Zhabudaev [et al.] // International Journal of Hydrogen Energy. — 2021. — Article in press. — DOI: 10.1016/j.ijhydene.2021.08.160.</mixed-citation>
			</ref>
			<ref id="B5">
				<label>5</label>
				<mixed-citation publication-type="confproc">Жороев А.М. Система стабилизации частоты автономной микроГЭС без регулятора расхода воды / А.М. Жороев, З.Ш. Айдарбеков, М.Д. Манасов. — Ош: Ошский государственный университет, 2011. — 7 с.</mixed-citation>
			</ref>
			<ref id="B6">
				<label>6</label>
				<mixed-citation publication-type="confproc">Wati E.K. IoT-Based Water Level Monitoring System of Situ Rawa Besar / E.K. Wati, H.H. Santoso, A. Laksono // Majority Science Journal (MSJ). — 2024. — Vol. 2, № 1. — P. 219–231. — DOI: 10.61942/msj.v2i1.89.</mixed-citation>
			</ref>
			<ref id="B7">
				<label>7</label>
				<mixed-citation publication-type="confproc">Viaña J. Explainable fuzzy cluster-based regression algorithm with gradient descent learning / J. Viaña, S. Ralescu, A. Ralescu [et al.] // Complex Engineering Systems. — 2022. — Vol. 2, № 8. — DOI: 10.20517/ces.2022.14.</mixed-citation>
			</ref>
			<ref id="B8">
				<label>8</label>
				<mixed-citation publication-type="confproc">Гунер М.В. Разработка гибридной интеллектуальной системы с нечётко-нейросетевыми компонентами для оценки профессиональной компетентности студентов / М.В. Гунер, О.И. Пятковский // Известия АлтГУ. — 2013. — № 1-1 (77). — С. 154–159. — URL: https://cyberleninka.ru/article/n/razrabotka-gibridnoy-intellektualnoy-sistemy-s-nechyotko-neyrosetevymi-komponentami-dlya-otsenki-professionalnoy-kompetentnosti (дата обращения: 14.11.2025).</mixed-citation>
			</ref>
			<ref id="B9">
				<label>9</label>
				<mixed-citation publication-type="confproc">Yadav M. Advanced soft computing techniques in modeling noise pollution health impacts / M. Yadav, B. Tandel, M.M. Ahammed // Current Trends and Advances in Computer-Aided Intelligent Environmental Data Engineering / ed. by G. Marques, J.O. Ighalo. — Amsterdam: Academic Press, 2022. — P. 337–352. — (Intelligent Data-Centric Systems). — ISBN 978-0-323-85597-6. — DOI: 10.1016/B978-0-323-85597-6.00015-9.</mixed-citation>
			</ref>
			<ref id="B10">
				<label>10</label>
				<mixed-citation publication-type="confproc">Understanding ANFIS: The Powerful Hybrid of Neural Networks and Fuzzy Logic [Understanding ANFIS: The Powerful Hybrid of Neural Networks and Fuzzy Logic] // Sandgarden. — URL: https://www.sandgarden.com/learn/anfis-adaptive-neuro-fuzzy-interface-system (accessed: 17.11.2025).</mixed-citation>
			</ref>
		</ref-list>
	</back>
	<fundings/>
</article>