vault backup: 2026-05-07 15:32:13

.obsidian/plugins/omnisearch/data.json

@@ -1,5 +1,5 @@
 {
-  "useCache": false,
+  "useCache": true,
   "hideExcluded": false,
   "recencyBoost": "0",
   "downrankedFoldersFilters": [],

.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,
+    "width": 261.5
-    "collapsed": true
   },
   "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",

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)$
+Обучение сети с учителем сводится к настройке весов так, чтобы выход $Y$ был близок к целевому ответу $D$. Для многослойных сетей основной алгоритм вычисления градиентов - [[Обратное распространение ошибки]].
+
+Если в качестве функции активации используется сигмоида, её производная выражается через уже вычисленное значение функции:
+
+$$
+y'=y(1-y)
+$$
+
+Это удобно для обратного прохода: при вычислении локальной ошибки нейрона не нужно заново считать сложную производную активации.

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{\partial E}{\partial w_{li}^{(2)}} &=
-\frac{dE}{dy_{l}}
+\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)}
+$$
+
 ## Связанные заметки
 
 - [[Обратное распространение ошибки]]
 - [[Нейронные сети]]
+- [[Линейные модели]]

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]]
+![[Pasted image 20260417105833.png|540]]
+
+## Связанные заметки
+
+- [[Обратное распространение ошибки - вывод]]
+- [[Нейронные сети]]
+- [[Линейные модели]]