From 6295e1669f5de6e8e458a419098cdd58e9e7791a Mon Sep 17 00:00:00 2001 From: Dmitry Date: Thu, 7 May 2026 15:32:13 +0300 Subject: [PATCH] vault backup: 2026-05-07 15:32:13 --- .obsidian/plugins/omnisearch/data.json | 2 +- .obsidian/workspace.json | 15 +- .../11 Machine Learning/Нейронные сети.md | 14 +- ...Обратное распространение ошибки - вывод.md | 59 +++++-- .../Обратное распространение ошибки.md | 145 +++++++++++++++--- 5 files changed, 190 insertions(+), 45 deletions(-) diff --git a/.obsidian/plugins/omnisearch/data.json b/.obsidian/plugins/omnisearch/data.json index ac5267d..10cc509 100644 --- a/.obsidian/plugins/omnisearch/data.json +++ b/.obsidian/plugins/omnisearch/data.json @@ -1,5 +1,5 @@ { - "useCache": false, + "useCache": true, "hideExcluded": false, "recencyBoost": "0", "downrankedFoldersFilters": [], diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index 3cd76c3..1f52dbf 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -13,13 +13,13 @@ "state": { "type": "markdown", "state": { - "file": "01 Library/11 Machine Learning/Обратное распространение ошибки.md", + "file": "01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md", "mode": "preview", "source": false, "backlinks": false }, "icon": "lucide-file", - "title": "Обратное распространение ошибки" + "title": "Обратное распространение ошибки - вывод" } } ] @@ -170,13 +170,13 @@ "state": { "type": "outline", "state": { - "file": "00 Inbox/Git.md", + "file": "01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md", "followCursor": false, "showSearch": false, "searchQuery": "" }, "icon": "lucide-list", - "title": "Outline of Git" + "title": "Outline of Обратное распространение ошибки - вывод" } }, { @@ -226,8 +226,7 @@ } ], "direction": "horizontal", - "width": 261.5, - "collapsed": true + "width": 261.5 }, "left-ribbon": { "hiddenItems": { @@ -248,6 +247,8 @@ }, "active": "cb9f1037ae0492db", "lastOpenFiles": [ + "01 Library/11 Machine Learning/Обратное распространение ошибки.md", + "01 Library/11 Machine Learning/Нейронные сети.md", "01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md", "00 Inbox/Hello.md", "00 Inbox/Обратное распространение ошибки - вывод.md", @@ -272,8 +273,6 @@ "00 Inbox/Git.md", "00 Inbox/Archive/Шаблонизатор Helm.md", "00 Inbox/Archive/УИР.md", - "00 Inbox/Archive/Основные команды git.md", - "00 Inbox/Archive/Обратное распространение ошибки - вывод.md", "00 Inbox/Archive", "01 Library/03 Math/Теория нечетких множеств/Теория нечетких множеств.md.tmp.254945.1777751883191", "01 Library/02 DevOps/Ansible/Ansible - основы.md.tmp.254945.1777751876503", diff --git a/01 Library/11 Machine Learning/Нейронные сети.md b/01 Library/11 Machine Learning/Нейронные сети.md index 832b6b6..a24f880 100644 --- a/01 Library/11 Machine Learning/Нейронные сети.md +++ b/01 Library/11 Machine Learning/Нейронные сети.md @@ -3,7 +3,7 @@ status: processing type: concept tags: [] created: 2025-12-17 -updated: 2026-04-13 +updated: 2026-05-07 title: Нейронные сети - ДВ --- @@ -100,6 +100,14 @@ $X^{p} \to D^{p}$ Перспептрон решает задачу линейной разделимости: Разбиение гиперпространства гиперплоскостями. -# Алгоритм обратного распространения ошибки +## Обучение нейронных сетей -$y` = y*(1-y)$ \ No newline at end of file +Обучение сети с учителем сводится к настройке весов так, чтобы выход $Y$ был близок к целевому ответу $D$. Для многослойных сетей основной алгоритм вычисления градиентов - [[Обратное распространение ошибки]]. + +Если в качестве функции активации используется сигмоида, её производная выражается через уже вычисленное значение функции: + +$$ +y'=y(1-y) +$$ + +Это удобно для обратного прохода: при вычислении локальной ошибки нейрона не нужно заново считать сложную производную активации. diff --git a/01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md b/01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md index 35fe103..ecfb51f 100644 --- a/01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md +++ b/01 Library/11 Machine Learning/Обратное распространение ошибки - вывод.md @@ -1,5 +1,5 @@ --- -status: seed +status: stable type: concept tags: - machine-learning @@ -12,7 +12,9 @@ title: Обратное распространение ошибки - вывод # Обратное распространение ошибки - вывод -Эта заметка фиксирует математический вывод градиента для алгоритма [[Обратное распространение ошибки]]. Общий контекст нейронных сетей находится в [[Нейронные сети]]. +Эта заметка фиксирует математический вывод градиентов для алгоритма [[Обратное распространение ошибки]]. Общий контекст нейронных сетей находится в [[Нейронные сети]]. + +Рассматривается сеть с одним скрытым слоем. Bias для краткости не записан: его градиент считается так же, как градиент веса при входе, равном $1$. ## Обозначения @@ -25,7 +27,8 @@ title: Обратное распространение ошибки - вывод > $S_{l}^{(2)}$ — взвешенная сумма на входе нейрона $l$ во втором слое > $y_{l}$ — выход нейрона $l$ второго слоя > $d_{l}$ — истинное значение -> $F$ — функция активации +> $F$ — функция активации +> $\delta$ — локальная ошибка нейрона ## Прямой проход @@ -33,6 +36,7 @@ $$ \begin{align*} S_{i}^{(1)} &= \sum\limits_{j=1}^{n}w_{ij}^{(1)}x_{j} \\ u_{i} &= F(S_{i}^{(1)}) \\ +S_l^{(2)} &= \sum\limits_{i=1}^{k}w_{li}^{(2)}u_i \\ y_{l} &= F(S_{l}^{(2)}) \\ E &= \frac{1}{2}\sum\limits_{l=1}^{m}(y_{l}-d_{l})^{2} \end{align*} @@ -44,33 +48,33 @@ $$ $$ \begin{align*} -\frac{dE}{dw_{li}^{(2)}} &= -\frac{dE}{dy_{l}} +\frac{\partial E}{\partial w_{li}^{(2)}} &= +\frac{\partial E}{\partial y_{l}} \cdot -\frac{dy_{l}}{dS_{l}^{(2)}} +\frac{\partial y_{l}}{\partial S_{l}^{(2)}} \cdot -\frac{dS_{l}^{(2)}}{dw_{li}^{(2)}} +\frac{\partial S_{l}^{(2)}}{\partial w_{li}^{(2)}} \end{align*} $$ Компоненты производной: $$ -\frac{dE}{dy_l}=y_l-d_l +\frac{\partial E}{\partial y_l}=y_l-d_l $$ $$ -\frac{dy_l}{dS_l^{(2)}}=F'(S_l^{(2)}) +\frac{\partial y_l}{\partial S_l^{(2)}}=F'(S_l^{(2)}) $$ $$ -\frac{dS_l^{(2)}}{dw_{li}^{(2)}}=u_i +\frac{\partial S_l^{(2)}}{\partial w_{li}^{(2)}}=u_i $$ Итог: $$ -\frac{dE}{dw_{li}^{(2)}}=(y_l-d_l)F'(S_l^{(2)})u_i +\frac{\partial E}{\partial w_{li}^{(2)}}=(y_l-d_l)F'(S_l^{(2)})u_i $$ Введём локальную ошибку выходного нейрона: @@ -82,7 +86,7 @@ $$ Тогда: $$ -\frac{dE}{dw_{li}^{(2)}}=\delta_l^{(2)}u_i +\frac{\partial E}{\partial w_{li}^{(2)}}=\delta_l^{(2)}u_i $$ ## Обратный проход для скрытого слоя @@ -130,7 +134,7 @@ $$ Так как: $$ -S_l^{(2)}=\sum w_{li}^{(2)}u_i +S_l^{(2)}=\sum\limits_{i=1}^{k}w_{li}^{(2)}u_i $$ То: @@ -154,7 +158,7 @@ $$ Так как: $$ -S_i^{(1)}=\sum w_{ij}^{(1)}x_j +S_i^{(1)}=\sum\limits_{j=1}^{n}w_{ij}^{(1)}x_j $$ То: @@ -210,7 +214,34 @@ $$ Ошибка выходного слоя $\delta_l^{(2)}$ проходит назад через вес $w_{li}^{(2)}$, суммируется по всем выходным нейронам и умножается на крутизну активации скрытого слоя. Так получается локальная ошибка $\delta_i^{(1)}$ для каждого скрытого нейрона. +## Итоговые формулы + +Для слоя $r$ общий шаблон такой: + +$$ +\frac{\partial E}{\partial w_{ij}^{(r)}}=\delta_i^{(r)}a_j^{(r-1)} +$$ + +где $a_j^{(r-1)}$ - выход предыдущего слоя. Для первого слоя $a_j^{(0)}=x_j$, для второго слоя $a_i^{(1)}=u_i$. + +Для выходного слоя: + +$$ +\delta_l^{(2)}=(y_l-d_l)F'(S_l^{(2)}) +$$ + +Для скрытого слоя: + +$$ +\delta_i^{(1)} += +F'(S_i^{(1)}) +\sum\limits_{l=1}^{m} +\delta_l^{(2)}w_{li}^{(2)} +$$ + ## Связанные заметки - [[Обратное распространение ошибки]] - [[Нейронные сети]] +- [[Линейные модели]] diff --git a/01 Library/11 Machine Learning/Обратное распространение ошибки.md b/01 Library/11 Machine Learning/Обратное распространение ошибки.md index 58e8c05..5d90660 100644 --- a/01 Library/11 Machine Learning/Обратное распространение ошибки.md +++ b/01 Library/11 Machine Learning/Обратное распространение ошибки.md @@ -1,40 +1,147 @@ --- -status: seed +status: stable type: concept -tags: [] +tags: + - machine-learning + - neural-networks + - backpropagation + - gradient-descent created: 2025-12-17 -updated: 2026-04-21 +updated: 2026-05-07 title: Обратное распространение ошибки --- # Обратное распространение ошибки -## Функция активации -$$u_{i} = \left(\sum\limits_{i=0}^{n} w^{1}_{ij}*x_{j}\right)$$ +**Обратное распространение ошибки** (*backpropagation*) - алгоритм вычисления градиентов функции ошибки по весам многослойной [[Нейронные сети|нейронной сети]]. После вычисления градиентов веса обновляются методом градиентного спуска. -$$y_{l}=f\left(\sum\limits_{i=1}^{k}w_{li}^{2}u_{i}\right)$$ +Главная идея: сначала сеть делает прямой проход и получает предсказание, затем ошибка распространяется от выходного слоя назад к предыдущим слоям. Для каждого веса считается, насколько изменение этого веса повлияло на итоговую ошибку. -$$y_{l}=f\left(\sum\limits_{i=0}^{k}w_{li}^{2} f\left(\sum\limits^{N}_{j=1}w_{ij}^{(1)}x_{j}\right)\right),\ l=\overline{1,m}$$ +## Где используется -## Алгоритм обратного распространения ошибки +Backpropagation нужен при обучении сетей с учителем: -- Итеративный градиентный алгоритм обучения, который используется с целью минимизации среднеквадратичного отклонения текущих от требуемых выходов многослойных нейронных сетей с последовательными связями. -- На каждом шаге алгоритма на вход сети поочередно подаются все обучающие примеры, реальные выходные значения сети сравниваются с требуемыми значениями, и вычисляется ошибка. -- Значение ошибки, а также градиента поверхности ошибок используется для корректировки весов, после чего все действия повторяются. -- Процесс обучения прекращается либо когда пройдено определенное количество шагов обучения, либо когда ошибка достигнет некоторого определенного малого уровня. +$$ +X^{(p)} \rightarrow Y^{(p)} \approx D^{(p)} +$$ -Минимизация ошибки происходит методом градиентного спуска (итеративный метод приближения к точке минимума функции) +где: +- $X^{(p)}$ - входной объект; +- $Y^{(p)}$ - выход сети; +- $D^{(p)}$ - целевой ответ; +- $p$ - номер обучающего примера. -$$w_{ij}(t+1)=w_{ij}(t)-\alpha*\frac{\delta E(k)}{\delta w_{ij}(t)},$$$$i=\overline{1,n},\ j=\overline{1,p}$$ +Алгоритм применим к многослойным сетям, если функции активации дифференцируемы или хотя бы имеют используемую на практике производную почти всюду. -Здесь $w_{ij}$ - весовой коэффициент синаптической связи, соединяющий $i$-ый нейрон слоя $n-1$ с $j$-ым нейроном слоя $n$. +## Прямой проход -$\alpha$ - коэффициент скорости обучения ($0 < \alpha < 1$) +Для сети с одним скрытым слоем: -$E$ - среднеквадратичная ошибка сети для одного из $p$ образов, определяемая по формуле: +$$ +S_i^{(1)}=\sum\limits_{j=1}^{n}w_{ij}^{(1)}x_j +$$ -$$E=\frac{1}{2}\sum\limits_{l=1}^{m}(y_{l}-d_{l})^{2}$$ +$$ +u_i=F(S_i^{(1)}) +$$ + +$$ +S_l^{(2)}=\sum\limits_{i=1}^{k}w_{li}^{(2)}u_i +$$ + +$$ +y_l=F(S_l^{(2)}) +$$ + +В развёрнутом виде: + +$$ +y_l= +F\left( +\sum\limits_{i=1}^{k} +w_{li}^{(2)} +F\left( +\sum\limits_{j=1}^{n} +w_{ij}^{(1)}x_j +\right) +\right), +\quad l=\overline{1,m} +$$ + +## Функция ошибки + +Для одного обучающего примера часто используют квадратичную ошибку: + +$$ +E=\frac{1}{2}\sum\limits_{l=1}^{m}(y_l-d_l)^2 +$$ + +Коэффициент $\frac{1}{2}$ нужен только для удобства производной: при дифференцировании квадрат даёт множитель $2$, который сокращается. + +## Обновление весов + +Минимизация ошибки происходит через градиентный спуск: + +$$ +w_{ij}(t+1)=w_{ij}(t)-\alpha\frac{\partial E}{\partial w_{ij}(t)} +$$ + +где: +- $w_{ij}$ - вес связи; +- $t$ - номер шага обучения; +- $\alpha$ - скорость обучения (*learning rate*); +- $\frac{\partial E}{\partial w_{ij}}$ - производная ошибки по весу. + +Если производная положительная, увеличение веса увеличивает ошибку, поэтому вес уменьшается. Если производная отрицательная, вес увеличивается. + +## Алгоритм + +1. Подать входной вектор $X$ на вход сети. +2. Выполнить прямой проход и получить выходы всех слоёв. +3. Посчитать ошибку $E$ между предсказанием $Y$ и целевым ответом $D$. +4. Посчитать ошибку выходного слоя $\delta^{(2)}$. +5. Распространить ошибку назад и посчитать ошибки скрытых слоёв $\delta^{(1)}$. +6. Найти градиенты по весам. +7. Обновить веса в направлении антиградиента. +8. Повторять до выполнения условия остановки: лимит эпох, малая ошибка, малая норма градиента или отсутствие улучшения. + +## Локальная ошибка слоя + +Для выходного слоя: + +$$ +\delta_l^{(2)}=(y_l-d_l)F'(S_l^{(2)}) +$$ + +Для скрытого слоя: + +$$ +\delta_i^{(1)} += +F'(S_i^{(1)}) +\sum\limits_{l=1}^{m} +\delta_l^{(2)}w_{li}^{(2)} +$$ + +То есть ошибка скрытого нейрона - это сумма ошибок следующего слоя, взвешенная связями с этим слоем, умноженная на производную активации скрытого нейрона. + +## Интуиция + +Backpropagation - это не отдельный способ оптимизации, а эффективный способ вычислить градиенты. Оптимизацию делает градиентный спуск или его модификации: SGD, Momentum, Adam и т.д. + +Смысл $\delta$: +- на выходном слое $\delta$ показывает, насколько нейрон ошибся с учётом производной активации; +- на скрытом слое прямого целевого ответа нет, поэтому ошибка собирается из всех нейронов следующего слоя; +- градиент веса получается как локальная ошибка нейрона, в который входит вес, умноженная на вход этого веса. + +## Иллюстрации ![[Pasted image 20260417105754.png|536]] -![[Pasted image 20260417105833.png|540]] \ No newline at end of file +![[Pasted image 20260417105833.png|540]] + +## Связанные заметки + +- [[Обратное распространение ошибки - вывод]] +- [[Нейронные сети]] +- [[Линейные модели]]