ЛР5
Весь код построчно

Весь код построчно

Полный код из выполненного ноутбука. Раскрывай нужный блок.

Код берётся из lab5_solved.ipynb при сборке сайта. Поэтому имена переменных и номера совпадают с сохранённым запуском. Подробное объяснение причин находится на тематических страницах.

[1] / И7: from copy import deepcopy

Код и построчный разбор
 1  from copy import deepcopy
 2  import numpy as np
 3  import pandas as pd
 4  import matplotlib.pyplot as plt
 5  import time
 6  import platform
 7  import sklearn
 8  from threadpoolctl import threadpool_limits
 9  
10  thread_limits = threadpool_limits(limits=1)
11  np.random.seed(42)
12  np.set_printoptions(precision=6, suppress=True)
13  plt.rcParams.update({'figure.figsize': (7, 4), 'axes.grid': True})
14  print('Python:', platform.python_version(), '| NumPy:', np.__version__)
15  print('scikit-learn:', sklearn.__version__)
СтрокаЧто происходит
1Подключаем библиотечные инструменты. Импорт не обучает сеть.
2Подключаем библиотечные инструменты. Импорт не обучает сеть.
3Подключаем библиотечные инструменты. Импорт не обучает сеть.
4Подключаем библиотечные инструменты. Импорт не обучает сеть.
5Подключаем библиотечные инструменты. Импорт не обучает сеть.
6Подключаем библиотечные инструменты. Импорт не обучает сеть.
7Подключаем библиотечные инструменты. Импорт не обучает сеть.
8Подключаем библиотечные инструменты. Импорт не обучает сеть.
10Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
15Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[2] / И9: def validate_matrix(matrix):

Код и построчный разбор
 1  def validate_matrix(matrix):
 2      assert isinstance(matrix, list) and len(matrix) > 0, 'Нужен непустой список строк'
 3      assert all(isinstance(row, list) for row in matrix), 'Строки должны быть списками'
 4      assert len(matrix[0]) > 0, 'Строки не должны быть пустыми'
 5      assert all(len(row) == len(matrix[0]) for row in matrix), 'Разная длина строк'
 6  
 7  
 8  def scalar_multiplication(matrix, scalar, copy=True):
 9      validate_matrix(matrix)
10      result = deepcopy(matrix) if copy else matrix
11      for row in result:
12          for j in range(len(row)):
13              row[j] *= scalar
14      if copy:
15          return result
16  
17  
18  def matrix_addition(matrix1, matrix2):
19      validate_matrix(matrix1)
20      validate_matrix(matrix2)
21      assert len(matrix1) == len(matrix2) and len(matrix1[0]) == len(matrix2[0])
22      return [[a + b for a, b in zip(row1, row2)]
23              for row1, row2 in zip(matrix1, matrix2)]
24  
25  
26  def matrix_transposition(matrix):
27      validate_matrix(matrix)
28      return [list(column) for column in zip(*matrix)]
29  
30  
31  def matrix_multiplication(matrix1, matrix2):
32      validate_matrix(matrix1)
33      validate_matrix(matrix2)
34      assert len(matrix1[0]) == len(matrix2), 'Несовместимые размеры'
35      columns = matrix_transposition(matrix2)
36      return [[sum(a * b for a, b in zip(row, column)) for column in columns]
37              for row in matrix1]
СтрокаЧто происходит
1Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
2Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
3Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
4Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
5Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
8Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
9Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
10При copy=True создаём независимые строки. При False меняем исходную матрицу.
11Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
12Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Выбираем ветку вычислений по условию.
15Возвращаем вычисленный результат вызывающему коду: result
18Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
19Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
20Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
21Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
22Возвращаем вычисленный результат вызывающему коду: [[a + b for a, b in zip(row1, row2)]
23Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
26Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
27Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
28Возвращаем вычисленный результат вызывающему коду: [list(column) for column in zip(*matrix)]
31Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
32Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
33Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
34Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
35Делаем столбцы второй матрицы удобными для перебора как строки.
36Возвращаем вычисленный результат вызывающему коду: [[sum(a * b for a, b in zip(row, column)) for column in columns]
37Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.

[3] / И10: def print_matrix(matrix):

Код и построчный разбор
 1  def print_matrix(matrix):
 2      for row in matrix:
 3          print(row)
 4  
 5  
 6  matrix1 = [[1, 2, 3],
 7             [4, 5, 6],
 8             [7, 8, 9]]
 9  
10  matrix2 = [[9, 8, 7],
11             [6, 5, 4],
12             [3, 2, 1]]
13  
14  print("Умножение на скаляр:")
15  print_matrix(scalar_multiplication(matrix1, 2))
16  print()
17  
18  print("Сложение матриц:")
19  print_matrix(matrix_addition(matrix1, matrix2))
20  print()
21  
22  print("Произведение матриц:")
23  print_matrix(matrix_multiplication(matrix1, matrix2))
24  print()
25  
26  print("Транспонирование матрицы:")
27  print_matrix(matrix_transposition(matrix1))
28  print()
СтрокаЧто происходит
1Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
2Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
3Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
8Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
10Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
12Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
14Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
15Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
16Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
18Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
19Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
20Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
22Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
23Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
24Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
26Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
27Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
28Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[4] / И12: matrix1 = np.array([[1, 2, 3],

Код и построчный разбор
 1  matrix1 = np.array([[1, 2, 3],
 2                      [4, 5, 6],
 3                      [7, 8, 9]])
 4  
 5  matrix2 = np.array([[9, 8, 7],
 6                      [6, 5, 4],
 7                      [3, 2, 1]])
 8  
 9  print("Умножение на скаляр:")
10  print_matrix(matrix1 * 2)
11  print()
12  
13  print("Сложение матриц:")
14  print_matrix(matrix1 + matrix2)
15  print()
16  
17  print("Произведение матриц:")
18  print_matrix(matrix1 @ matrix2)
19  print()
20  
21  print("Транспонирование матрицы:")
22  print_matrix(matrix1.T)
23  print()
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
3Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
7Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
9Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
10Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
11Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
13Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
14Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
15Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
17Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
18Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
19Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
21Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
22Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
23Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[5] / И14: from abc import ABC, abstractmethod

Код и построчный разбор
 1  from abc import ABC, abstractmethod
 2  import matplotlib.pyplot as plt
 3  
 4  import torch
 5  import torch.nn as nn
 6  import torch.nn.functional as F
 7  torch.set_num_threads(1)
 8  print("PyTorch:", torch.__version__)
СтрокаЧто происходит
1Подключаем библиотечные инструменты. Импорт не обучает сеть.
2Подключаем библиотечные инструменты. Импорт не обучает сеть.
4Подключаем библиотечные инструменты. Импорт не обучает сеть.
5Подключаем библиотечные инструменты. Импорт не обучает сеть.
6Подключаем библиотечные инструменты. Импорт не обучает сеть.
7Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
8Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[6] / И16: class ActivationFunction(ABC):

Код и построчный разбор
 1  class ActivationFunction(ABC):
 2      @abstractmethod
 3      def __call__(self, x: np.ndarray) -> np.ndarray:
 4          """
 5          Применяет функцию активации к входным значениям.
 6  
 7          Параметры:
 8          - x: numpy.ndarray, входные значения
 9  
10          Возвращает:
11          - activation: numpy.ndarray, значение активации
12          """
13          pass
14  
15      @abstractmethod
16      def grad(self, x: np.ndarray) -> np.ndarray:
17          """
18          Вычисляет градиент активационной функции по отношению к входным значениям.
19  
20          Параметры:
21          - x: numpy.ndarray, входные значения
22  
23          Возвращает:
24          - gradient: numpy.ndarray, градиент активационной функции
25          """
26          pass
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
3Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
4Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
5Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
7Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
8Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
10Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
11Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
12Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
13Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
15Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
16Метод grad возвращает производную по входу функции, для потерь по прогнозам.
17Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
18Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
20Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
21Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
23Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
24Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
25Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
26Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.

[7] / И20: class Identity(ActivationFunction):

Код и построчный разбор
 1  class Identity(ActivationFunction):
 2      def __call__(self, x):
 3          return np.asarray(x, dtype=float)
 4  
 5      def grad(self, x):
 6          return np.ones_like(x, dtype=float)
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Преобразуем вход в числовой массив. Identity сохраняет сами значения.
5Метод grad возвращает производную по входу функции, для потерь по прогнозам.
6Создаём массив единиц той же формы: производная Identity везде 1.

[8] / И21: x_range = np.linspace(-3, 3, 1000)

Код и построчный разбор
 1  x_range = np.linspace(-3, 3, 1000)
 2  
 3  identity = Identity()
 4  values = identity(x_range)
 5  gradient = identity.grad(x_range)
 6  
 7  plt.figure(figsize=(7, 4))
 8  plt.plot(x_range, values, label='Identity', c='b')
 9  plt.plot(x_range, gradient, label='Identity Gradient', linestyle='--', c='r')
10  plt.ylabel('Значение / производная')
11  plt.xlabel('Вход')
12  plt.legend()
13  plt.grid(True)
14  plt.title('Активация и производная: Identity')
15  plt.show()
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
15Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[9] / И25: class Sigmoid(ActivationFunction):

Код и построчный разбор
 1  class Sigmoid(ActivationFunction):
 2      def __call__(self, x):
 3          x = np.asarray(x, dtype=float)
 4          small_exp = np.exp(-np.abs(x))
 5          return np.where(x >= 0, 1 / (1 + small_exp), small_exp / (1 + small_exp))
 6  
 7      def grad(self, x):
 8          probabilities = self(x)
 9          return probabilities * (1 - probabilities)
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Приводим вход к массиву вещественных чисел, чтобы формула работала сразу над всеми элементами.
4Считаем только экспоненту неположительного числа. Так большое положительное x не вызывает переполнение.
5Выбираем две равносильные формы сигмоиды для положительных и отрицательных входов. На выходе вероятности от 0 до 1.
7Метод grad возвращает производную по входу функции, для потерь по прогнозам.
8Вызываем прямую формулу текущей активации. self(x) означает вызвать __call__ этого объекта.
9Производная сигмоиды: вероятность умножаем на единицу минус вероятность. В нуле получаем 0.25.

[10] / И26: x_range = np.linspace(-5, 5, 1000)

Код и построчный разбор
 1  x_range = np.linspace(-5, 5, 1000)
 2  
 3  sigmoid = Sigmoid()
 4  values = sigmoid(x_range)
 5  gradient = sigmoid.grad(x_range)
 6  
 7  plt.figure(figsize=(7, 4))
 8  plt.plot(x_range, values, label='Sigmoid', c='b')
 9  plt.plot(x_range, gradient, label='Sigmoid Gradient', linestyle='--', c='r')
10  plt.ylabel('Значение / производная')
11  plt.xlabel('Вход')
12  plt.legend()
13  plt.grid(True)
14  plt.title('Активация и производная: Sigmoid')
15  plt.show()
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
15Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[11] / И28: input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])

Код и построчный разбор
 1  input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])
 2  
 3  custom_output = Sigmoid()(input)
 4  torch_output = F.sigmoid(torch.tensor(input)).numpy()
 5  
 6  print("Custom Sigmoid Output:")
 7  print(custom_output)
 8  print()
 9  print("PyTorch Sigmoid Output:")
10  print(torch_output)
11  
12  assert np.allclose(custom_output, torch_output)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
7Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
8Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
9Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
12Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[12] / И32: class ReLU(ActivationFunction):

Код и построчный разбор
 1  class ReLU(ActivationFunction):
 2      def __call__(self, x):
 3          return np.maximum(x, 0)
 4  
 5      def grad(self, x):
 6          return (np.asarray(x) > 0).astype(float)
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Каждый отрицательный элемент заменяем нулём. Положительные сохраняются.
5Метод grad возвращает производную по входу функции, для потерь по прогнозам.
6Получаем 1 на положительной стороне и 0 на отрицательной и в нуле. В нуле это принятое соглашение.

[13] / И33: x_range = np.linspace(-3, 3, 1000)

Код и построчный разбор
 1  x_range = np.linspace(-3, 3, 1000)
 2  
 3  relu = ReLU()
 4  values = relu(x_range)
 5  gradient = relu.grad(x_range)
 6  
 7  plt.figure(figsize=(7, 4))
 8  plt.plot(x_range, values, label='ReLU', c='b')
 9  plt.plot(x_range, gradient, label='ReLU Gradient', linestyle='--', c='r')
10  plt.ylabel('Значение / производная')
11  plt.xlabel('Вход')
12  plt.legend()
13  plt.grid(True)
14  plt.title('Активация и производная: ReLU')
15  plt.show()
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
15Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[14] / И35: input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])

Код и построчный разбор
 1  input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])
 2  
 3  custom_output = ReLU()(input)
 4  torch_output = F.relu(torch.tensor(input)).numpy()
 5  
 6  print("Custom ReLU Output:")
 7  print(custom_output)
 8  print()
 9  print("PyTorch ReLU Output:")
10  print(torch_output)
11  
12  assert np.allclose(custom_output, torch_output)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
7Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
8Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
9Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
12Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[15] / И39: class LeakyReLU(ActivationFunction):

Код и построчный разбор
 1  class LeakyReLU(ActivationFunction):
 2      def __init__(self, alpha=0.01):
 3          self.alpha = alpha
 4  
 5      def __call__(self, x):
 6          x = np.asarray(x, dtype=float)
 7          return np.where(x > 0, x, self.alpha * x)
 8  
 9      def grad(self, x):
10          return np.where(np.asarray(x) > 0, 1.0, self.alpha)
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Сохраняем коэффициент отрицательной ветки. Он задан вручную и в этой работе не обучается.
5Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
6Приводим вход к массиву вещественных чисел, чтобы формула работала сразу над всеми элементами.
7Положительные элементы сохраняем; отрицательные умножаем на alpha. Это LeakyReLU.
9Метод grad возвращает производную по входу функции, для потерь по прогнозам.
10Производная равна 1 справа и alpha слева. В нуле используем alpha как соглашение.

[16] / И40: x_range = np.linspace(-5, 5, 1000)

Код и построчный разбор
 1  x_range = np.linspace(-5, 5, 1000)
 2  
 3  leaky_relu = LeakyReLU(0.1)
 4  values = leaky_relu(x_range)
 5  gradient = leaky_relu.grad(x_range)
 6  
 7  plt.figure(figsize=(7, 4))
 8  plt.plot(x_range, values, label='Leaky ReLU', c='b')
 9  plt.plot(x_range, gradient, label='Leaky ReLU Gradient', linestyle='--', c='r')
10  plt.ylabel('Значение / производная')
11  plt.xlabel('Вход')
12  plt.legend()
13  plt.grid(True)
14  plt.title('Активация и производная: LeakyReLU')
15  plt.show()
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
15Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[17] / И42: input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])

Код и построчный разбор
 1  input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])
 2  
 3  custom_output = LeakyReLU(alpha=0.01)(input)
 4  torch_output = F.leaky_relu(torch.tensor(input)).numpy()
 5  
 6  print("Custom LeakyReLU Output:")
 7  print(custom_output)
 8  print()
 9  print("PyTorch LeakyReLU Output:")
10  print(torch_output)
11  
12  assert np.allclose(custom_output, torch_output)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
7Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
8Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
9Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
12Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[18] / И46: class ELU(ActivationFunction):

Код и построчный разбор
 1  class ELU(ActivationFunction):
 2      def __init__(self, alpha=0.01):
 3          self.alpha = alpha
 4  
 5      def __call__(self, x):
 6          x = np.asarray(x, dtype=float)
 7          return np.where(x > 0, x, self.alpha * np.expm1(np.minimum(x, 0)))
 8  
 9      def grad(self, x):
10          return np.where(np.asarray(x) > 0, 1.0,
11                          self.alpha * np.exp(np.minimum(x, 0)))
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Сохраняем коэффициент отрицательной ветки. Он задан вручную и в этой работе не обучается.
5Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
6Приводим вход к массиву вещественных чисел, чтобы формула работала сразу над всеми элементами.
7ELU справа сохраняет x, слева считает alpha*(exp(x)-1). minimum предотвращает лишнюю большую экспоненту.
9Метод grad возвращает производную по входу функции, для потерь по прогнозам.
10Для положительных входов производная ELU равна 1, иначе используем выражение следующей строки.
11На отрицательной стороне производная ELU равна alpha*exp(x).

[19] / И47: x_range = np.linspace(-5, 5, 1000)

Код и построчный разбор
 1  x_range = np.linspace(-5, 5, 1000)
 2  
 3  elu = ELU(1)
 4  values = elu(x_range)
 5  gradient = elu.grad(x_range)
 6  
 7  plt.figure(figsize=(7, 4))
 8  plt.plot(x_range, values, label='ELU', c='b')
 9  plt.plot(x_range, gradient, label='ELU Gradient', linestyle='--', c='r')
10  plt.ylabel('Значение / производная')
11  plt.xlabel('Вход')
12  plt.legend()
13  plt.grid(True)
14  plt.title('Активация и производная: ELU')
15  plt.show()
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
15Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[20] / И49: input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])

Код и построчный разбор
 1  input = np.array([-2, 8, -5, 0.2, 0.1, 3, 7])
 2  
 3  custom_output = ELU(alpha=1)(input)
 4  torch_output = F.elu(torch.tensor(input)).numpy()
 5  
 6  print("Custom ELU Output:")
 7  print(custom_output)
 8  print()
 9  print("PyTorch ELU Output:")
10  print(torch_output)
11  
12  assert np.allclose(custom_output, torch_output)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
7Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
8Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
9Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
12Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[21] / И53: class Softmax(ActivationFunction):

Код и построчный разбор
 1  class Softmax(ActivationFunction):
 2      def __call__(self, x):
 3          x = np.asarray(x, dtype=float)
 4          shifted = x - np.max(x, axis=-1, keepdims=True)
 5          exponents = np.exp(shifted)
 6          return exponents / exponents.sum(axis=-1, keepdims=True)
 7  
 8      def grad(self, x):
 9          probabilities = self(x)
10          identity = np.eye(probabilities.shape[-1])
11          return (probabilities[..., :, None] * identity
12                  - probabilities[..., :, None] * probabilities[..., None, :])
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Приводим вход к массиву вещественных чисел, чтобы формула работала сразу над всеми элементами.
4Из каждой строки вычитаем её максимум. Отношения экспонент не меняются, переполнение предотвращается.
5Вычисляем экспоненты сдвинутых логитов. Все значения положительны или численно близки к нулю.
6Каждую экспоненту делим на сумму в той же строке. Все вероятности строки дают 1.
8Метод grad возвращает производную по входу функции, для потерь по прогнозам.
9Вызываем прямую формулу текущей активации. self(x) означает вызвать __call__ этого объекта.
10Создаём единичную матрицу: единицы на диагонали, остальные элементы нулевые. Она представляет символ Кронекера.
11Первая часть Якобиана: диагональная матрица вероятностей.
12Вычитаем внешнее произведение вектора на себя. Получаем и диагональные, и перекрёстные производные.

[22] / И54: z_range = np.array([[0.5, 1.25, 0.25, 2.2, 0.05, 0.495]])

Код и построчный разбор
 1  z_range = np.array([[0.5, 1.25, 0.25, 2.2, 0.05, 0.495]])
 2  softmax = Softmax()
 3  softmax_values = softmax(z_range)
 4  softmax_gradient = softmax.grad(z_range)
 5  fig, axes = plt.subplots(1, 2, figsize=(11, 4))
 6  axes[0].bar(range(6), softmax_values[0], label='Вероятность')
 7  axes[0].set(xlabel='Номер класса', ylabel='Вероятность', title='Softmax: сумма равна 1')
 8  axes[0].legend()
 9  image = axes[1].imshow(softmax_gradient[0], cmap='coolwarm')
10  axes[1].set(xlabel='Вход j', ylabel='Выход i', title='Якобиан: влияние входа на выход')
11  fig.colorbar(image, ax=axes[1], label='Производная')
12  plt.tight_layout()
13  plt.show()
14  print('Сумма вероятностей:', softmax_values.sum())
15  print('Размер Якобиана:', softmax_gradient.shape)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
14Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
15Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[23] / И56: input = np.array([[1.0, 2.0, 3.0],

Код и построчный разбор
 1  input = np.array([[1.0, 2.0, 3.0],
 2                    [2.0, 7.0, 4.0],
 3                    [2.0, 2.0, 2.0]])
 4  
 5  custom_output = Softmax()(input)
 6  torch_output = F.softmax(torch.tensor(input), dim=-1).numpy()
 7  
 8  print("Custom Softmax Output:")
 9  print(custom_output)
10  print()
11  print("PyTorch Softmax Output:")
12  print(torch_output)
13  
14  assert np.allclose(custom_output, torch_output)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
3Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
9Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
11Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
12Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
14Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[24] / И60: class LossFunction(ABC):

Код и построчный разбор
 1  class LossFunction(ABC):
 2      @abstractmethod
 3      def __call__(self, targets: np.ndarray, outputs: np.ndarray) -> float:
 4          """
 5          Вычисляет функцию потерь между целевыми значениями и предсказанными значениями.
 6  
 7          Параметры:
 8          - targets: numpy.ndarray, массив целевых значений
 9          - outputs: numpy.ndarray, массив предсказанных значений
10  
11          Возвращает:
12          - loss: float, значение функции потерь
13          """
14          pass
15  
16      @abstractmethod
17      def grad(self, targets: np.ndarray, outputs: np.ndarray) -> np.ndarray:
18          """
19          Вычисляет градиент функции потерь по отношению к предсказанным значениям.
20  
21          Параметры:
22          - targets: numpy.ndarray, массив целевых значений
23          - outputs: numpy.ndarray, массив предсказанных значений
24  
25          Возвращает:
26          - gradient: numpy.ndarray, градиент функции потерь
27          """
28          pass
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
3Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
4Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
5Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
7Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
8Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
9Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
11Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
12Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
13Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
14Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
16Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
17Метод grad возвращает производную по входу функции, для потерь по прогнозам.
18Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
19Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
21Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
22Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
23Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
25Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
26Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
27Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
28Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.

[25] / И64: class MeanSquaredError(LossFunction):

Код и построчный разбор
 1  class MeanSquaredError(LossFunction):
 2      def __call__(self, targets, outputs):
 3          return np.mean((outputs - targets) ** 2)
 4  
 5      def grad(self, targets, outputs):
 6          return 2 * (outputs - targets) / outputs.size
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Из прогнозов вычитаем ответы, возводим ошибки в квадрат и усредняем.
5Метод grad возвращает производную по входу функции, для потерь по прогнозам.
6Градиент MSE: удвоенная ошибка, делённая на число всех выходных элементов. Усреднение делается только здесь.

[26] / И66: targets = np.array([3.5, 2.0, 7.1, 5.2, 4.6])

Код и построчный разбор
 1  targets = np.array([3.5, 2.0, 7.1, 5.2, 4.6])
 2  predictions = np.array([3.0, 1.8, 6.8, 5.5, 4.0])
 3  
 4  # Custom implementation
 5  custom_loss = MeanSquaredError()
 6  custom_loss_value = custom_loss(targets, predictions)
 7  custom_loss_grad = custom_loss.grad(targets, predictions)
 8  
 9  # PyTorch implementation
10  targets_torch = torch.tensor(targets, dtype=torch.float32, requires_grad=True)
11  predictions_torch = torch.tensor(predictions, dtype=torch.float32, requires_grad=True)
12  torch_loss_function = nn.MSELoss()
13  torch_loss_value = torch_loss_function(predictions_torch, targets_torch)
14  torch_loss_value.backward()
15  torch_loss_value = torch_loss_value.item()
16  torch_loss_grad = predictions_torch.grad.numpy()
17  
18  # Compare results
19  print("Custom Loss Value:", custom_loss_value)
20  print("PyTorch Loss Value:", torch_loss_value)
21  print("Custom Loss Gradient:", custom_loss_grad)
22  print("PyTorch Loss Gradient:", torch_loss_grad)
23  
24  assert np.isclose(custom_loss_value, torch_loss_value) and np.allclose(custom_loss_grad, torch_loss_grad)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Комментарий: Custom implementation
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Комментарий: PyTorch implementation
10Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Комментарий: Compare results
19Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
20Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
21Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
22Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
24Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[27] / И70: class BinaryCrossEntropy(LossFunction):

Код и построчный разбор
 1  class BinaryCrossEntropy(LossFunction):
 2      def __call__(self, targets, outputs):
 3          probabilities = np.clip(outputs, 1e-12, 1 - 1e-12)
 4          return -np.mean(targets * np.log(probabilities)
 5                          + (1 - targets) * np.log1p(-probabilities))
 6  
 7      def grad(self, targets, outputs):
 8          probabilities = np.clip(outputs, 1e-12, 1 - 1e-12)
 9          return ((probabilities - targets)
10                  / (probabilities * (1 - probabilities) * outputs.size))
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Отодвигаем вероятности от точных 0 и 1, чтобы не брать логарифм нуля и не делить на ноль.
4Начало BCE: при метке 1 учитываем логарифм вероятности положительного класса.
5При метке 0 учитываем log(1-p). Внешние минус и mean превращают сумму в средний штраф.
7Метод grad возвращает производную по входу функции, для потерь по прогнозам.
8Отодвигаем вероятности от точных 0 и 1, чтобы не брать логарифм нуля и не делить на ноль.
9Числитель производной BCE: предсказанная вероятность минус правильный ответ.
10Делим на p*(1-p) и количество элементов. Это производная по вероятности, ещё до переноса через Sigmoid.

[28] / И72: targets = np.array([0, 1, 1, 0, 1])

Код и построчный разбор
 1  targets = np.array([0, 1, 1, 0, 1])
 2  logits = np.array([0.3, 0.7, 0.8, 0.2, 0.6])
 3  
 4  # Custom implementation
 5  custom_loss = BinaryCrossEntropy()
 6  custom_loss_value = custom_loss(targets, logits)
 7  custom_loss_grad = custom_loss.grad(targets, logits)
 8  
 9  # PyTorch implementation
10  targets_torch = torch.tensor(targets, dtype=torch.float32)
11  logits_torch = torch.tensor(logits, dtype=torch.float32, requires_grad=True)
12  torch_loss_function = nn.BCELoss()
13  torch_loss_value = torch_loss_function(logits_torch, targets_torch)
14  torch_loss_value.backward()
15  torch_loss_value = torch_loss_value.item()
16  torch_loss_grad = logits_torch.grad.numpy()
17  
18  # Compare results
19  print("Custom Loss Value:", custom_loss_value)
20  print("PyTorch Loss Value:", torch_loss_value)
21  print("Custom Loss Gradient:", custom_loss_grad)
22  print("PyTorch Loss Gradient:", torch_loss_grad)
23  
24  assert np.isclose(custom_loss_value, torch_loss_value) and np.allclose(custom_loss_grad, torch_loss_grad)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Комментарий: Custom implementation
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Комментарий: PyTorch implementation
10Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Комментарий: Compare results
19Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
20Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
21Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
22Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
24Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[29] / И75: class CrossEntropy(LossFunction):

Код и построчный разбор
 1  class CrossEntropy(LossFunction):
 2      def __init__(self, use_softmax=False):
 3          self.use_softmax = use_softmax
 4          self.softmax = Softmax()
 5  
 6      def __call__(self, targets, outputs):
 7          if self.use_softmax:
 8              shifted = outputs - outputs.max(axis=-1, keepdims=True)
 9              log_probabilities = shifted - np.log(np.exp(shifted).sum(axis=-1, keepdims=True))
10          else:
11              log_probabilities = np.log(np.clip(outputs, 1e-12, 1))
12          return -np.mean(np.sum(targets * log_probabilities, axis=-1))
13  
14      def grad(self, targets, outputs):
15          if self.use_softmax:
16              return (self.softmax(outputs) - targets) / outputs.shape[0]
17          return -targets / np.clip(outputs, 1e-12, 1) / outputs.shape[0]
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Запоминаем режим: True принимает логиты, False принимает вероятности.
4Создаём экземпляр нашей реализации Softmax для вычисления вероятностей.
6Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
7Если поданы логиты, включаем Softmax внутрь функции потерь.
8В каждой строке вычитаем максимальный логит для устойчивости экспоненты.
9Сразу считаем log-softmax: логит минус логарифм суммы экспонент. Не берём логарифм уже округлившегося до нуля p.
10Выбираем ветку вычислений по условию.
11В режиме готовых вероятностей просто берём их защищённый логарифм.
12One-hot оставляет логарифм правильного класса. Усредняем отрицательные логарифмы по объектам.
14Метод grad возвращает производную по входу функции, для потерь по прогнозам.
15Если поданы логиты, включаем Softmax внутрь функции потерь.
16Градиент объединённой Softmax + CrossEntropy по логитам. Размер батча учитывается один раз.
17Другой режим: вход уже вероятности. Производная по ним равна -y/(N*p), а не (p-y)/N.

[30] / И77: targets = np.array([2, 0, 1, 4, 3])

Код и построчный разбор
 1  targets = np.array([2, 0, 1, 4, 3])
 2  targets_one_hot = np.eye(5)[targets]
 3  
 4  logits = np.array([[0.42194493, 0.11111515, 0.2331985,  0.1709079,  0.06283352],
 5                     [0.50811597, 0.380799  , 0.58517274, 0.44421673, 0.12969366],
 6                     [0.01138442, 0.12280621, 0.87035961, 0.74922558, 0.8304247 ],
 7                     [0.87531709, 0.34677379, 0.06201914, 0.52324805, 0.75431726],
 8                     [0.49000835, 0.98996684, 0.69016974, 0.70180657, 0.23664727]])
 9  
10  # Custom implementation
11  custom_loss = CrossEntropy(use_softmax=True)
12  custom_loss_value = custom_loss(targets_one_hot, logits)
13  custom_loss_grad = custom_loss.grad(targets_one_hot, logits)
14  
15  # PyTorch implementation
16  targets_torch = torch.tensor(targets)
17  logits_torch = torch.tensor(logits, dtype=torch.float32, requires_grad=True)
18  torch_loss_function = nn.CrossEntropyLoss()
19  torch_loss_value = torch_loss_function(logits_torch, targets_torch)
20  torch_loss_value.backward()
21  torch_loss_value = torch_loss_value.item()
22  torch_loss_grad = logits_torch.grad.numpy()
23  
24  # Comparison
25  print("Custom Loss Value:", custom_loss_value)
26  print("PyTorch Loss Value:", torch_loss_value)
27  print("Custom Loss Gradient:\n", custom_loss_grad)
28  print("PyTorch Loss Gradient:\n", torch_loss_grad)
29  
30  assert np.isclose(custom_loss_value, torch_loss_value) and np.allclose(custom_loss_grad, torch_loss_grad)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
6Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
7Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
8Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
10Комментарий: Custom implementation
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
15Комментарий: PyTorch implementation
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
17Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
19Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
20Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
21Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
22Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
24Комментарий: Comparison
25Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
26Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
27Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
28Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
30Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.

[31] / И82: class Layer:

Код и построчный разбор
 1  class Layer:
 2      def __init__(self, input_size, output_size, activation=None, random_seed=17):
 3          self.activation = Identity() if activation is None else activation
 4          rng = np.random.default_rng(random_seed)
 5          scale = np.sqrt(2 / input_size) if isinstance(self.activation, ReLU) else np.sqrt(1 / input_size)
 6          self.weights = rng.normal(0, scale, size=(input_size, output_size))
 7          self.bias = np.zeros((1, output_size))
 8  
 9      def forward(self, inputs):
10          self.inputs = inputs
11          self.linear_output = inputs @ self.weights + self.bias
12          return self.activation(self.linear_output)
13  
14      def backward(self, grad_outputs, learning_rate=0.01):
15          if isinstance(self.activation, Softmax):
16              probabilities = self.activation(self.linear_output)
17              grad_linear = probabilities * (grad_outputs - np.sum(
18                  grad_outputs * probabilities, axis=-1, keepdims=True))
19          else:
20              grad_linear = grad_outputs * self.activation.grad(self.linear_output)
21          grad_inputs = grad_linear @ self.weights.T
22          grad_weights = self.inputs.T @ grad_linear
23          grad_bias = grad_linear.sum(axis=0, keepdims=True)
24          # Градиент входов уже вычислен со старыми весами.
25          self.weights -= learning_rate * grad_weights
26          self.bias -= learning_rate * grad_bias
27          return grad_inputs
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Сохраняем выбранную активацию. Если её не передали, слой остаётся линейным.
4Создаём локальный генератор: одинаковый seed даёт те же начальные веса.
5Для ReLU используем масштаб Хе. Для других активаций умеренный масштаб 1/sqrt(числа входов).
6Создаём случайные веса. У каждого входа есть вес для каждого выходного нейрона.
7Создаём один сдвиг на выходной нейрон. Одинаковый вектор прибавится ко всем объектам.
9Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
10Запоминаем вход для обратного прохода: он понадобится в формуле градиента весов.
11Взвешиваем входы и добавляем сдвиг. Это ещё не результат активации.
12Применяем нелинейное преобразование и передаём результат следующему слою.
14Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
15Softmax связывает выходы. Для него нужна специальная ветка, простое поэлементное умножение неверно.
16Повторно получаем вероятности Softmax по сохранённым логитам этого слоя.
17Начало сокращённого произведения на Якобиан: p умножается на входной градиент с поправкой.
18Поправка есть сумма g*p по классам каждой строки. В итоге p*(g-sum(g*p)), с учётом связей классов.
19Выбираем ветку вычислений по условию.
20Обычная активация: умножаем пришедший градиент на локальную производную по правилу цепочки.
21Вычисляем градиент для предыдущего слоя. Здесь ещё используются старые веса.
22Суммируем вклад объектов в градиенты весов одним матричным умножением.
23Суммируем градиенты по объектам: каждый сдвиг использовался во всех строках.
24Комментарий: Градиент входов уже вычислен со старыми весами.
25Шаг обучения: двигаем веса против направления роста ошибки.
26Так же обновляем сдвиги.
27Возвращаем сигнал ошибки предыдущему слою.

[32] / И83: class NeuralNetwork:

Код и построчный разбор
 1  class NeuralNetwork:
 2      def __init__(self, layers, loss):
 3          self.layers = layers
 4          self.loss = loss
 5  
 6      def forward(self, X):
 7          outputs = X
 8          for layer in self.layers:
 9              outputs = layer.forward(outputs)
10          return outputs
11  
12      def backward(self, outputs, targets, learning_rate=0.01):
13          gradient = self.loss.grad(targets, outputs)
14          for layer in reversed(self.layers):
15              gradient = layer.backward(gradient, learning_rate)
16  
17      def train(self, X, y, epochs=1000, learning_rate=0.01):
18          loss_history = []
19          for epoch in range(epochs):
20              outputs = self.forward(X)
21              loss_history.append(float(self.loss(y, outputs)))
22              self.backward(outputs, y, learning_rate)
23          return np.array(loss_history)
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Сохраняем слои в порядке от входа к выходу.
4Сохраняем объект функции потерь, выбранный под задачу.
6Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
7Первый вход всей сети: исходная матрица объектов и признаков.
8Проходим слои от входа к выходу. Следующий слой зависит от предыдущего, поэтому нужен цикл.
9Выход текущего слоя становится входом следующего.
10После обхода слоёв возвращаем окончательный ответ сети.
12Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
13Начинаем обратный проход с производной потери по ответу сети.
14Идём от последнего слоя к первому, потому что ошибка приходит с выхода.
15Слой обновляет свои параметры и возвращает градиент для предыдущего слоя.
17Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
18Пустой список для одного значения потери на каждую эпоху.
19Эпоха здесь означает один прямой и обратный проход по всей обучающей выборке.
20Сеть делает прогнозы с текущими весами.
21Записываем ошибку до обновления. Потом по истории строится график обучения.
22Переносим ошибку назад и меняем параметры всех слоёв.
23Возвращаем историю ошибок, а обученные веса остаются внутри объекта сети.

[33] / И86: from sklearn.datasets import make_regression

Код и построчный разбор
 1  from sklearn.datasets import make_regression
 2  from sklearn.model_selection import train_test_split
 3  
 4  
 5  X, y = make_regression(n_samples=1000, n_features=5, noise=0.1, random_state=42)
 6  y = y.reshape(-1, 1)
 7  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 8  
 9  layers = [
10      Layer(5, 10, activation=Identity()),
11      Layer(10, 1, activation=Identity())
12  ]
13  model = NeuralNetwork(layers, loss=MeanSquaredError())
14  
15  losses = model.train(X_train, y_train, epochs=5000, learning_rate=0.001)
16  y_pred = model.forward(X_test)
17  
18  print("MSE:", MeanSquaredError()(y_test, y_pred))
19  plt.plot(losses, label='Обучение')
20  plt.xlabel('Эпоха'); plt.ylabel('Потеря'); plt.title('Обучение сети'); plt.legend()
21  plt.show()
22  
23  plt.figure(figsize=(8, 5))
24  plt.title('Регрессия: ответы и прогнозы')
25  plt.scatter(range(len(y_test)), y=y_test, label='Правильные ответы')
26  plt.scatter(range(len(y_test)), y=y_pred, marker='x', label='Прогнозы')
27  plt.legend(loc='best');
28  plt.xlabel('Объект теста'); plt.ylabel('Целевая величина'); plt.show()
СтрокаЧто происходит
1Подключаем библиотечные инструменты. Импорт не обучает сеть.
2Подключаем библиотечные инструменты. Импорт не обучает сеть.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
19Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
20Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
21Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
23Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
24Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
25Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
26Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
27Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
28Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[34] / И88: from sklearn.datasets import make_circles

Код и построчный разбор
 1  from sklearn.datasets import make_circles
 2  from sklearn.metrics import accuracy_score
 3  
 4  
 5  n_samples = 1000
 6  X, y = make_circles(n_samples,
 7                      noise=0.03,
 8                      random_state=42)
 9  y = y.reshape(-1, 1)
10  
11  plt.scatter(x=X[:, 0], y=X[:, 1], c=y, cmap=plt.cm.RdYlBu);
12  plt.xlabel('Признак 1'); plt.ylabel('Признак 2'); plt.title('Учебные данные'); plt.colorbar(label='Класс'); plt.show()
СтрокаЧто происходит
1Подключаем библиотечные инструменты. Импорт не обучает сеть.
2Подключаем библиотечные инструменты. Импорт не обучает сеть.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[35] / И89: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Код и построчный разбор
 1  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 2  len(X_train), len(X_test), len(y_train), len(y_test)
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.

[36] / И91: layers = [

Код и построчный разбор
 1  layers = [
 2      Layer(2, 5, activation=Identity()),
 3      Layer(5, 1, activation=Sigmoid())
 4  ]
 5  model = NeuralNetwork(layers, loss=BinaryCrossEntropy())
 6  
 7  losses = model.train(X_train, y_train, epochs=10000, learning_rate=0.1)
 8  y_pred = model.forward(X_test)
 9  
10  print("Accuracy:", accuracy_score(y_test, y_pred.round()))
11  plt.plot(losses, label='Обучение')
12  plt.xlabel('Эпоха'); plt.ylabel('Потеря'); plt.title('Обучение сети'); plt.legend();
13  circle_linear_accuracy = accuracy_score(y_test, y_pred.round())
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.

[37] / И92: layers = [

Код и построчный разбор
 1  layers = [
 2      Layer(2, 5, activation=ReLU()),
 3      Layer(5, 1, activation=Sigmoid())
 4  ]
 5  model = NeuralNetwork(layers, loss=BinaryCrossEntropy())
 6  
 7  losses = model.train(X_train, y_train, epochs=10000, learning_rate=0.1)
 8  y_pred = model.forward(X_test)
 9  
10  print("Accuracy:", accuracy_score(y_test, y_pred.round()))
11  plt.plot(losses, label='Обучение')
12  plt.xlabel('Эпоха'); plt.ylabel('Потеря'); plt.title('Обучение сети'); plt.legend();
13  circle_relu_accuracy = accuracy_score(y_test, y_pred.round())
СтрокаЧто происходит
1Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
11Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
12Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.

[38] / И94: from sklearn.datasets import make_blobs

Код и построчный разбор
 1  from sklearn.datasets import make_blobs
 2  
 3  
 4  X, y = make_blobs(n_samples=1000,
 5      n_features=2,
 6      centers=4,
 7      cluster_std=1.5,
 8      random_state=42
 9  )
10  
11  X_train, X_test, y_train, y_test = train_test_split(X, y,
12      test_size=0.2, random_state=42)
13  
14  plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlBu);
15  plt.xlabel('Признак 1'); plt.ylabel('Признак 2'); plt.title('Учебные данные'); plt.colorbar(label='Класс'); plt.show()
СтрокаЧто происходит
1Подключаем библиотечные инструменты. Импорт не обучает сеть.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
15Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[39] / И95: from sklearn.preprocessing import StandardScaler

Код и построчный разбор
 1  from sklearn.preprocessing import StandardScaler
 2  from sklearn.metrics import f1_score, ConfusionMatrixDisplay
 3  
 4  blob_scaler = StandardScaler().fit(X_train)
 5  X_train_scaled = blob_scaler.transform(X_train)
 6  X_test_scaled = blob_scaler.transform(X_test)
 7  blob_model = NeuralNetwork([
 8      Layer(2, 16, ReLU(), random_seed=17),
 9      Layer(16, 4, Identity(), random_seed=18)
10  ], CrossEntropy(use_softmax=True))
11  blob_losses = blob_model.train(X_train_scaled, np.eye(4)[y_train],
12                                 epochs=2000, learning_rate=0.1)
13  blob_predictions = blob_model.forward(X_test_scaled).argmax(axis=1)
14  blob_accuracy = accuracy_score(y_test, blob_predictions)
15  print(f'Accuracy: {blob_accuracy:.4f}')
16  print(f'Macro-F1: {f1_score(y_test, blob_predictions, average="macro"):.4f}')
17  assert blob_accuracy > 0.90
18  plt.plot(blob_losses, label='Обучение')
19  plt.xlabel('Эпоха'); plt.ylabel('Cross-entropy'); plt.title('Четыре класса: обучение')
20  plt.legend(); plt.show()
21  ConfusionMatrixDisplay.from_predictions(y_test, blob_predictions)
22  plt.title('Четыре класса: ошибки на тесте'); plt.xlabel('Предсказанный класс'); plt.ylabel('Истинный класс')
23  plt.show()
СтрокаЧто происходит
1Подключаем библиотечные инструменты. Импорт не обучает сеть.
2Подключаем библиотечные инструменты. Импорт не обучает сеть.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
15Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
16Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
17Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
18Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
19Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
20Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
21Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
22Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
23Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[40]: # Проверки формул и обратного прохода

Код и построчный разбор
 1  # Проверки формул и обратного прохода
 2  original_matrix = [[1, 2, 3], [4, 5, 6]]
 3  assert scalar_multiplication(original_matrix, 2) == [[2, 4, 6], [8, 10, 12]]
 4  assert original_matrix == [[1, 2, 3], [4, 5, 6]]
 5  changed = deepcopy(original_matrix)
 6  assert scalar_multiplication(changed, 2, copy=False) is None
 7  assert changed == [[2, 4, 6], [8, 10, 12]]
 8  assert matrix_multiplication(original_matrix, [[1], [2], [3]]) == [[14], [32]]
 9  assert matrix_transposition(original_matrix) == np.array(original_matrix).T.tolist()
10  assert matrix_addition(original_matrix, original_matrix) == (2 * np.array(original_matrix)).tolist()
11  
12  test_x = np.array([[-2.0, -0.3, 0.2], [0.7, 1.2, 3.0]])
13  for activation, reference in [(Identity(), lambda x: x), (Sigmoid(), torch.sigmoid),
14                                 (ReLU(), F.relu), (LeakyReLU(), F.leaky_relu), (ELU(1), F.elu)]:
15      tensor = torch.tensor(test_x, requires_grad=True)
16      expected = reference(tensor)
17      expected.sum().backward()
18      np.testing.assert_allclose(activation(test_x), expected.detach().numpy(), atol=1e-12)
19      np.testing.assert_allclose(activation.grad(test_x), tensor.grad.numpy(), atol=1e-12)
20  np.testing.assert_allclose(Softmax().grad(np.array([[0., 0.]])), [[[.25, -.25], [-.25, .25]]])
21  tensor = torch.tensor(test_x[0], requires_grad=True)
22  jacobian = torch.autograd.functional.jacobian(lambda x: F.softmax(x, dim=-1), tensor)
23  np.testing.assert_allclose(Softmax().grad(test_x[0]), jacobian.numpy(), atol=1e-12)
24  assert Sigmoid()(np.array([-1000., 1000.])).tolist() == [0., 1.]
25  np.testing.assert_allclose(Softmax()(np.array([[1000., 1000.]])), [[.5, .5]])
26  
27  probabilities = np.array([[.2, .3, .5], [.7, .2, .1]])
28  targets_check = np.eye(3)[[2, 0]]
29  probability_tensor = torch.tensor(probabilities, requires_grad=True)
30  torch_loss = -(torch.tensor(targets_check) * probability_tensor.log()).sum(dim=1).mean()
31  torch_loss.backward()
32  np.testing.assert_allclose(CrossEntropy()(targets_check, probabilities), torch_loss.item())
33  np.testing.assert_allclose(CrossEntropy().grad(targets_check, probabilities), probability_tensor.grad.numpy())
34  
35  for activation in [Identity(), Sigmoid(), ReLU(), LeakyReLU(), ELU(1), Softmax()]:
36      test_layer = Layer(3, 2, activation, random_seed=23)
37      inputs_check = test_x.copy()
38      upstream = np.array([[.3, -.2], [.4, .7]])
39      weights_before = test_layer.weights.copy()
40      bias_before = test_layer.bias.copy()
41      tensor_x = torch.tensor(inputs_check, requires_grad=True)
42      tensor_w = torch.tensor(weights_before, requires_grad=True)
43      tensor_b = torch.tensor(bias_before, requires_grad=True)
44      linear = tensor_x @ tensor_w + tensor_b
45      references = {Identity: lambda x:x, Sigmoid:torch.sigmoid, ReLU:F.relu,
46                    LeakyReLU:F.leaky_relu, ELU:F.elu, Softmax:lambda x:F.softmax(x, dim=-1)}
47      (references[type(activation)](linear) * torch.tensor(upstream)).sum().backward()
48      test_layer.forward(inputs_check)
49      grad_input = test_layer.backward(upstream, learning_rate=.1)
50      np.testing.assert_allclose(grad_input, tensor_x.grad.numpy(), atol=1e-12)
51      np.testing.assert_allclose(test_layer.weights, weights_before - .1 * tensor_w.grad.numpy(), atol=1e-12)
52      np.testing.assert_allclose(test_layer.bias, bias_before - .1 * tensor_b.grad.numpy(), atol=1e-12)
53  
54  check_network = NeuralNetwork([Layer(3, 4, Sigmoid(), 31), Layer(4, 2, Identity(), 32)], MeanSquaredError())
55  check_targets = np.array([[.2, .8], [.7, .1]])
56  epsilon = 1e-6
57  numeric_gradient = np.zeros_like(check_network.layers[0].weights)
58  for index in np.ndindex(numeric_gradient.shape):
59      weights = check_network.layers[0].weights
60      old_value = weights[index]
61      weights[index] = old_value + epsilon
62      plus = check_network.loss(check_targets, check_network.forward(test_x))
63      weights[index] = old_value - epsilon
64      minus = check_network.loss(check_targets, check_network.forward(test_x))
65      weights[index] = old_value
66      numeric_gradient[index] = (plus - minus) / (2 * epsilon)
67  before = check_network.layers[0].weights.copy()
68  check_network.backward(check_network.forward(test_x), check_targets, learning_rate=.1)
69  analytic_gradient = (before - check_network.layers[0].weights) / .1
70  np.testing.assert_allclose(analytic_gradient, numeric_gradient, rtol=1e-6, atol=1e-8)
71  print('Матрицы, активации, потери, градиенты слоёв и всей сети: проверки пройдены.')
72  print('Максимальная ошибка численного градиента:', np.max(np.abs(analytic_gradient - numeric_gradient)))
СтрокаЧто происходит
1Комментарий: Проверки формул и обратного прохода
2Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
3Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
4Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
7Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
8Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
9Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
10Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
14Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
17Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
18Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
19Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
20Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
21Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
22Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
23Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
24Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
25Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
27Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
28Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
29Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
30Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
31Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
32Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
33Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
35Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
36Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
37Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
38Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
39Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
40Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
41Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
42Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
43Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
44Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
45Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
46Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
47Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
48Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
49Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
50Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
51Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
52Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
54Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
55Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
56Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
57Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
58Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
59Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
60Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
61Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
62Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
63Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
64Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
65Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
66Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
67Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
68Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
69Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
70Численно сверяем наш ответ с независимым ожидаемым значением, учитывая малую погрешность.
71Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
72Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[41]: # Digits: данные и разбиение

Код и построчный разбор
 1  # Digits: данные и разбиение
 2  from sklearn.datasets import load_digits
 3  from sklearn.metrics import log_loss
 4  from sklearn.dummy import DummyClassifier
 5  
 6  digits = load_digits()
 7  digit_X = digits.data.astype(float) / 16.0
 8  digit_y = digits.target
 9  assert np.isfinite(digit_X).all()
10  assert digit_X.min() >= 0 and digit_X.max() <= 1
11  print('Объекты и признаки:', digit_X.shape)
12  print('Пропусков:', np.isnan(digit_X).sum())
13  print('Дубликатов изображений:', len(digit_X) - len(np.unique(digit_X, axis=0)))
14  print('Объектов по классам:', np.bincount(digit_y))
15  digit_trainval_X, digit_test_X, digit_trainval_y, digit_test_y = train_test_split(
16      digit_X, digit_y, test_size=.2, stratify=digit_y, random_state=42)
17  digit_train_X, digit_val_X, digit_train_y, digit_val_y = train_test_split(
18      digit_trainval_X, digit_trainval_y, test_size=.25, stratify=digit_trainval_y, random_state=42)
19  print('Train / validation / test:', len(digit_train_y), len(digit_val_y), len(digit_test_y))
20  fig, axes = plt.subplots(2, 5, figsize=(9, 4))
21  for label, ax in enumerate(axes.flat):
22      example = np.flatnonzero(digit_train_y == label)[0]
23      ax.imshow(digit_train_X[example].reshape(8, 8), cmap='gray_r', vmin=0, vmax=1)
24      ax.set(title=f'Цифра {label}', xlabel='Столбец', ylabel='Строка')
25  fig.suptitle('Примеры из обучающей выборки'); plt.tight_layout(); plt.show()
СтрокаЧто происходит
1Комментарий: Digits: данные и разбиение
2Подключаем библиотечные инструменты. Импорт не обучает сеть.
3Подключаем библиотечные инструменты. Импорт не обучает сеть.
4Подключаем библиотечные инструменты. Импорт не обучает сеть.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
764 яркости каждого изображения переводим в известный диапазон от 0 до 1.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
10Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
11Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
12Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
13Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
14Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
17Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
19Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
20Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
21Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
22Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
23Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
24Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
25Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[42]: # Выбор настроек только по validation

Код и построчный разбор
 1  # Выбор настроек только по validation
 2  def make_digit_network(hidden_size, seed=17):
 3      return NeuralNetwork([
 4          Layer(64, hidden_size, ReLU(), random_seed=seed),
 5          Layer(hidden_size, 10, Identity(), random_seed=seed + 1)
 6      ], CrossEntropy(use_softmax=True))
 7  
 8  search_results = []
 9  digit_epochs = 500
10  for hidden_size in [32, 64]:
11      for learning_rate in [.1, .3]:
12          candidate = make_digit_network(hidden_size)
13          start = time.perf_counter()
14          candidate.train(digit_train_X, np.eye(10)[digit_train_y],
15                          epochs=digit_epochs, learning_rate=learning_rate)
16          val_pred = candidate.forward(digit_val_X).argmax(axis=1)
17          search_results.append(dict(hidden_size=hidden_size, learning_rate=learning_rate,
18                                     val_f1=f1_score(digit_val_y, val_pred, average='macro'),
19                                     seconds=time.perf_counter() - start))
20  search_table = pd.DataFrame(search_results)
21  best_params = search_table.sort_values(['val_f1', 'hidden_size', 'learning_rate'],
22                                        ascending=[False, True, True]).iloc[0]
23  display(search_table.round(4))
24  print('Выбрано:', int(best_params.hidden_size), 'нейронов; шаг', best_params.learning_rate)
СтрокаЧто происходит
1Комментарий: Выбор настроек только по validation
2Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
3Возвращаем вычисленный результат вызывающему коду: NeuralNetwork([
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
8Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
9Фиксируем число полных проходов. В этом поиске оно не подбирается.
10Пробуем два размера скрытого слоя, это гиперпараметр.
11Для каждого размера пробуем два шага обучения. Всего четыре кандидата.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
17Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
19Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
20Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
21Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
22Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
23Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
24Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.

[43]: # Финальная сеть использует именно лучшие настройки

Код и построчный разбор
 1  # Финальная сеть использует именно лучшие настройки
 2  final_model = make_digit_network(int(best_params.hidden_size))
 3  final_start = time.perf_counter()
 4  digit_losses = final_model.train(digit_trainval_X, np.eye(10)[digit_trainval_y],
 5                                   epochs=digit_epochs, learning_rate=float(best_params.learning_rate))
 6  final_seconds = time.perf_counter() - final_start
 7  digit_probabilities = Softmax()(final_model.forward(digit_test_X))
 8  digit_predictions = digit_probabilities.argmax(axis=1)
 9  dummy = DummyClassifier(strategy='prior').fit(digit_trainval_X, digit_trainval_y)
10  dummy_probabilities = dummy.predict_proba(digit_test_X)
11  results = pd.DataFrame([
12      dict(model='Своя сеть', accuracy=accuracy_score(digit_test_y, digit_predictions),
13           macro_f1=f1_score(digit_test_y, digit_predictions, average='macro'),
14           log_loss=log_loss(digit_test_y, digit_probabilities)),
15      dict(model='Частотный baseline', accuracy=accuracy_score(digit_test_y, dummy.predict(digit_test_X)),
16           macro_f1=f1_score(digit_test_y, dummy.predict(digit_test_X), average='macro'),
17           log_loss=log_loss(digit_test_y, dummy_probabilities))
18  ])
19  display(results.round(4))
20  print(f'Обучение финальной сети: {final_seconds:.2f} с')
21  print('Параметров сети:', sum(layer.weights.size + layer.bias.size for layer in final_model.layers))
22  assert final_model.layers[0].weights.shape[1] == int(best_params.hidden_size)
23  plt.plot(digit_losses, label='Train + validation, финальное обучение')
24  plt.xlabel('Эпоха'); plt.ylabel('Cross-entropy'); plt.title('Digits: обучение выбранной сети')
25  plt.legend(); plt.show()
26  ConfusionMatrixDisplay.from_predictions(digit_test_y, digit_predictions, cmap='Blues')
27  plt.title('Digits: ошибки финальной сети на тесте')
28  plt.xlabel('Предсказанная цифра'); plt.ylabel('Истинная цифра'); plt.show()
СтрокаЧто происходит
1Комментарий: Финальная сеть использует именно лучшие настройки
2Создаём итоговую сеть с выбранной на валидации шириной. Именно эта строка связывает подбор и итог.
3Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
4Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
7Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
8Для каждого объекта берём номер класса с наибольшей вероятностью.
9Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
11Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
12Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
13Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
14Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
15Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
16Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
17Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
18Продолжение выражения из предыдущей строки: читай его вместе с открывающей скобкой.
19Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
20Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
21Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
22Проверяем обязательное условие. При нарушении выполнение останавливается с ошибкой.
23Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
24Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
25Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
26Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
27Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
28Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.

[44]: # Ошибки выбранной модели, без повторного подбора по тесту

Код и построчный разбор
 1  # Ошибки выбранной модели, без повторного подбора по тесту
 2  mistakes = np.flatnonzero(digit_predictions != digit_test_y)
 3  print('Ошибок на тесте:', len(mistakes), 'из', len(digit_test_y))
 4  if len(mistakes):
 5      fig, axes = plt.subplots(1, min(5, len(mistakes)), figsize=(10, 3), squeeze=False)
 6      for ax, index in zip(axes.flat, mistakes[:5]):
 7          ax.imshow(digit_test_X[index].reshape(8, 8), cmap='gray_r', vmin=0, vmax=1)
 8          ax.set(title=f'Ответ {digit_test_y[index]}, прогноз {digit_predictions[index]}',
 9                 xlabel='Столбец', ylabel='Строка')
10      fig.suptitle('Первые ошибки в порядке тестовой выборки'); plt.tight_layout(); plt.show()
11  print(f'Итог: accuracy = {results.iloc[0].accuracy:.4f}, macro-F1 = {results.iloc[0].macro_f1:.4f}.')
СтрокаЧто происходит
1Комментарий: Ошибки выбранной модели, без повторного подбора по тесту
2Находим индексы ошибок уже выбранной сети. После этого настройки не меняем.
3Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.
4Выбираем ветку вычислений по условию.
5Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
6Перебираем элементы или эксперименты. Это управляющий цикл, а не замена векторной формулы градиента.
7Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
8Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
9Вычисляем правую часть и сохраняем результат под именем слева. Смотри назначение блока и размеры его входов выше.
10Настраиваем график или показываем его. Эта строка не обучает модель и не меняет метрики.
11Показываем полученный результат. Расчёт выполнен в переменных, а не вписан вручную.