Глубокое обучение: Автоматическое дифференцирование. Теория и реализация. С нуля, на Python19.01.2025 11:01

В результате этой операции получается новая переменная-операнд, которую мы назвали z. Переменная a является операндом 1, а переменная b является операндом 2. Операция суммы применяется к операнду 1, а не к операнду 2, то есть значение b прибавляется к значению a, а не наоборот.

Для вычисления производной для операндов a и b понадобится знать значение производной операнда z:

В результате получается переменная-операнд z. a — операнд 1, b — операнд 2. Для вычисления производной для каждого из операндов a и b понадобится знать значение производной z:

Эта операция отлична от операции сложения. Здесь происходит последовательное суммирование всех элементов на входе. Затем создается новый операнд с полученным значением. Для каждого элемента вектора a производная относительно z будет одинаковой, поэтому нужно просто скопировать (expand — расширить, развернуть) производную по z n раз:

z и x — векторы, W — матрица. Рассмотрим матрицу с двумя строками и двумя столбцами и вектор x с двумя элементами:

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

В случае с матрицами, операндами будут сами матрицы и мы работаем с матричными операциями, а не с операциями над числами. Поэтому нам нужно находить производную для вектора x и матрицы W через матричные операции:

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

Не знаю как перевести на русский, может быть «экспанирование». Эта операция копирует значение исходного операнда несколько раз. Можно считать эту операцию противоположной для операции суммы. Так как для суммы происходит превращение массива чисел в одно число. А эта операция копирует значение исходного операнда несколько раз, до необходимого размера массива. В результате получается новый операнд, значение которого представляет собой массив из нескольких значений данного операнда:

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

Пусть значения весов таковы: = 0.1, = 0.2, = 0.3, = 0.4, = 0.5, = 0.6. На вход подаем значения = 0.8, = 0.9. Целевое выходное значение t=1.

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

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

= (1) — вектор из единицы, в качестве индекса можно также записать .

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

= = = = =

Здесь мы применили производную для операции произведения, которая описана выше, для операндов и , в результате получился вектор (-0.34). Для операнда получается то же самое, только для вычисления производной используется не , а . В этом примере эти операнды являются разными объектами, так как мы применяем операцию умножения, которая действует для двух операндов, а не операцию возведения в степень, которая действует для одного операнда.

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

= = = =

= = = =

Потом они складываются по правилу суммы:

= = =

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

Далее идет , это операнд участвовал в создании h.

В создании Z1 участвовала матрица весов W1 и вектор признаков x. Находим производные для них по формуле вычисления производной матрицы.

class Tensor:
    def __init__(self, data, creators=None, operation_name=""):
        self.data = data
        self.creators = creators
        self.operation_name = operation_name
        self.grad = None

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

При совершении любой операции создается новый операнд, мы его создаем и возвращаем.

def __add__(self, other):
    return Tensor(
        data=add_matrixes(self.data, other.data),
        creators=[self, other],
        operation_name="__add__"
    )

Матрицы записывается как двумерный список — списоки чисел внутри списка. Создаем новый тензор и передаем в него новую матрицу — результат операции сложения и тензоры, которые участвовали в операции, и название операции. self и other — это тензоры-создатели, в параметр creators передается список из двух ссылок на объекты-тензоры.

def sum(self, dim=0, copies_num=None):
    if dim == 0:
        copies_num = len(self.data)  # суммируем элементы колонки для каждой колонки

    elif dim == 1:
        copies_num = len(self.data[0])  # суммируем элементы строки для каждой строки

    return Tensor(
        data=sum_matrix(self.data, dim),
        creators=[self],
        operation_name="sum_" + str(dim) + '_' + str(copies_num)
    )

Здесь создается новый тензор, в параметр data передается сумма всех чисел операнда-создателя по определенной оси массива. Создателем является только один операнд — сам тензор self. Указываем в названии операции количество элементов в оси исходной матрицы, если ось массива, по которой производится суммация, равна 0, то len (self.data), если 1, то len (self.data[0]). Потом это число будет использовано для операции развертывания. Также нужно указать ось (измерение) массива, по которой будет производиться сумма.

Здесь выполняется операция произведения матриц операндов self и other.

def dot(self, other):
    return Tensor(
        data=matrix_by_matrix(self.data, other.data),
        creators=[self, other],
        operation_name="dot"
    )

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

def expand(self, dim, copies_num, item=None):
    if dim == 0:
        item = self.data[0]

    if dim == 1:
        item = slice_column(self.data, idx=0)

    return Tensor(
        data=expand_item(item, dim, copies_num),
        creators=[self],
        operation_name="expand_" + str(dim)
    )

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

def backward(self, grad=None):
    if grad is None:
        grad = Tensor(data=ones(shape=self.shape()))

    if self.grad is None:
        self.grad = Tensor(grad.data)

    else:
        self.grad += grad

Формула для сложения:

if self.operation_name == "__add__":
    self.creators[0].backward(Tensor(self.grad.data))  # new Tensor
    self.creators[1].backward(Tensor(self.grad.data))  # new Tensor

В этой формуле операнд a — self, b — other. Для операндов self и other, ссылки на которые хранятся в self.creators[0] и self.creators[1] мы передаем значение производной, которое представляет собой просто текущее значение производной self.grad.data для текущего узла self. Создаем новый тензор и передаем в него значение производной.

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

Операция умножения:

if self.operation_name == "__mul__":
    self_grad = grad * self.creators[1]  # new Tensor
    self.creators[0].backward(self_grad)
    other_grad = grad * self.creators[0]  # new Tensor
    self.creators[1].backward(other_grad)

Когда мы вычисляли вручную, то я сказал, мы сразу сложим производные для , здесь она будет передаваться несколько раз и складываться. В этом месте будет происходить два вызова метода и все производные будут вычислять 2 раза по веткам графа для  и , а затем складываться self.grad += grad.

Формула для операции суммы:

elif self.operation_name.startswith("sum"):
    dim, copies_num = self.operation_name.split('_')[1:]
    dim, copies_num = int(dim), int(copies_num)
    new_grad = grad.expand(dim, copies_num)  # new Tensor
    self.creators[0].backward(new_grad)

Поскольку все элементы вектора были превращены в одно число, то нам нужно развернуть это число обратно — сделать вектор из копий значений производной. Создаем новый тензор со значением производной, развертываем — делаем указанное количество копий, указанное в строке self.operation_name[3:] и указываем ось массива, и вызываем обратное распространение у тензора-создателя self, передаем в качестве градиента только что созданный градиент.

Формула для производной сигмоиды:

Обратное распространение через операцию сигмоиды:

elif self.operation_name == "sigmoid":
    ones_tensor = Tensor(data=ones(shape=self.shape()))
    new_grad = grad * self * (ones_tensor - self)  # new Tensor
    self.creators[0].backward(new_grad)

x0 = Tensor(data=[[0.8, 0.9]])
x = x0.transpose()

w1 = Tensor(data=[[0.1, 0.3], [0.2, 0.4]])

w2 = Tensor(data=[[0.5, 0.6]])

t = Tensor(data=[[1]])

z1 = w1.dot(x)
print("z1 =", z1)

h = z1.sigmoid()
print("h =", h)

z2 = w2.dot(h)
print("z2 =", z2)

y = z2.sigmoid()
print("y =", y)

y1 = (y - t)
print("y1 =", y1)
y2 = (y - t)
print("y2 =", y2)
error = (y1 * y2).sum() #/ y.shape()[0]
print("error =", error)

print("=========================")

error.backward()
print("x0.grad =", x0.grad)
print("x.grad =", x.grad)
print("w1.grad =", w1.grad)
print("z1.grad =", z1.grad)
print("h.grad =", h.grad)
print("w2.grad =", w2.grad)
print("z2.grad =", z2.grad)
print("y.grad =", y.grad)
print("t.grad =", t.grad)
print("y1.grad =", y1.grad)
print("y2.grad =", y2.grad)
print("error.grad =", error.grad)

output:
z1 = [[0.35000000000000003], [0.52]]
h = [[0.5866175789173301], [0.6271477663131956]]
z2 = [[0.6695974492465824]]
y = [[0.661413015495447]]
y1 = [[-0.33858698450455305]]
y2 = [[-0.33858698450455305]]
error = [[0.11464114607588645]]
=========================
x0.grad = [[-0.006094049283464489, -0.014026838608202242]]
x.grad = [[-0.006094049283464489], [-0.014026838608202242]]
w1.grad = [[-0.014709920330186114, -0.016548660371459377],
[-0.017021236968764897, -0.01914889158986051]]
z1.grad = [[-0.01838740041273264], [-0.02127654621095612]]
h.grad = [[-0.07582514612590609], [-0.0909901753510873]]
w2.grad = [[-0.08896072728286361, -0.09510714204646732]]
z2.grad = [[-0.15165029225181217]]
y.grad = [[-0.6771739690091061]]
t.grad = [[0.6771739690091061]]
y1.grad = [[-0.33858698450455305]]
y2.grad = [[-0.33858698450455305]]
error.grad = [[1]]