Справочное руководство PyTorch torch.nn

PyTorchtorch.nnмодуль — это основной модуль для построения и обучения нейронных сетей. Он предоставляет богатый набор классов и функций для определения и работы с нейронными сетями.

Ниже приведеныtorch.nnНекоторые ключевые компоненты модуля и их функции:

1. Класс nn.Module：

nn.Moduleявляется базовым классом для всех пользовательских моделей нейронных сетей. Обычно пользователи наследуют свои классы моделей от этого класса и определяют в них структуру слоёв сети и функцию прямого прохода.

2. Предопределённые слои (модули)：

Включает различные типы компонентов слоёв, такие как свёрточные слои (nn.Conv1d, nn.Conv2d, nn.Conv3d), полносвязные слои (nn.Linear), функции активации (nn.ReLU, nn.Sigmoid, nn.Tanh), и т. д.

3. Классы-контейнеры：

nn.Sequential: позволяют объединять несколько слоёв последовательно, чтобы сформировать простую линейно составленную сеть.
nn.ModuleListиnn.ModuleDict: могут динамически хранить подмодули и обращаться к ним, поддерживая коллекции модулей переменной длины или именованные коллекции.

4. Функции потерь：

torch.nnСодержит ряд функций потерь для измерения различия между предсказаниями модели и истинными метками, таких как потеря среднеквадратичной ошибки (nn.MSELoss), потеря кросс-энтропии (nn.CrossEntropyLoss), и т. д.

5. Функциональный интерфейс：

nn.functional(обычно сокращается какF), содержит множество функций, которые могут напрямую работать с тензорами. Они реализуют ту же функциональность, что и объекты слоёв, но не имеют возможности сохранять и обновлять параметры. Например, вы можете использоватьF.relu()для непосредственного выполнения операций ReLU, илиF.conv2d()для выполнения операций свёртки.

6. Методы инициализации：

torch.nn.initПредоставляет некоторые часто используемые стратегии инициализации весов, такие как инициализация Xavier (nn.init.xavier_uniform_()) и инициализация Kaiming (nn.init.kaiming_uniform_()), которые имеют решающее значение для успешного обучения нейронных сетей.

7. Слои Transformer：

PyTorch предоставляет полный набор компонентов архитектуры Transformer, включаяnn.Transformer, nn.TransformerEncoder, nn.TransformerDecoderа также механизмы вниманияnn.MultiheadAttentionи т. д.

8. Слои нормализации：

Включают пакетную нормализацию (BatchNorm), слойную нормализацию (LayerNorm), групповую нормализацию (GroupNorm), нормализацию экземпляра (InstanceNorm), и RMSNorm, и т. д.

Справочное руководство по модулю torch.nn PyTorch

Контейнеры нейронных сетей

Класс/Функция	Описание
`torch.nn.Module`	Базовый класс для всех модулей нейронной сети.
`torch.nn.Sequential(*args)`	Последовательно объединяет несколько модулей.
`torch.nn.ModuleList(modules)`	Хранит подмодули в списке.
`torch.nn.ModuleDict(modules)`	Хранит подмодули в словаре.
`torch.nn.ParameterList(parameters)`	Хранит параметры в списке.
`torch.nn.ParameterDict(parameters)`	Хранит параметры в словаре.
`torch.nn.Parameter(data)`	Создаёт обучаемый тензор параметров.
`torch.nn.Buffer(data)`	Создаёт постоянный буфер (необучаемый параметр).
`torch.nn.Identity(args, *kwargs)`	Слой тождественного преобразования, вход непосредственно передаётся на выход.

Глобальные хуки

Функция	Описание
`register_module_forward_pre_hook(hook)`	Регистрирует предварительный хук прямого прохода.
`register_module_forward_hook(hook)`	Регистрирует хук прямого прохода.
`register_module_backward_hook(hook)`	Регистрирует хук обратного распространения.
`register_module_full_backward_pre_hook(hook)`	Регистрирует полный предварительный хук обратного распространения.
`register_module_full_backward_hook(hook)`	Регистрирует полный хук обратного распространения.

Линейные слои

Класс/Функция	Описание
`torch.nn.Linear(in_features, out_features, bias)`	Полносвязный слой (линейное преобразование).
`torch.nn.Bilinear(in1_features, in2_features, out_features, bias)`	Билинейный слой.
`torch.nn.LazyLinear(out_features, bias)`	Линейный слой с отложенной инициализацией; автоматически определяет входную размерность во время первого прямого прохода.

Свёрточные слои

Класс/Функция	Описание
`torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	1D-свёрточный слой, обычно используется для текста и аудио.
`torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	2D-свёрточный слой, обычно используется для изображений.
`torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	3D-свёрточный слой, обычно используется для видео и объёмных данных.
`torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	1D-транспонированная свёртка (деконволюция), используется для апсемплинга.
`torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	2D-транспонированная свёртка (деконволюция), используется для апсемплинга.
`torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	3D транспонированная свёртка (деконволюция), используемая для апсемплинга.
`torch.nn.Unfold(kernel_size, dilation, padding, stride)`	Разворачивает входной тензор в блоки скользящего окна.
`torch.nn.Fold(output_size, kernel_size, dilation, padding, stride)`	Объединяет развёрнутые блоки обратно в тензор.

Слои пулинга

Класс/Функция	Описание
`torch.nn.MaxPool1d(kernel_size, stride, padding, dilation, return_indices)`	1D слой максимального пулинга.
`torch.nn.MaxPool2d(kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	2D слой максимального пулинга.
`torch.nn.MaxPool3d(kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	3D слой максимального пулинга.
`torch.nn.MaxUnpool1d(kernel_size, stride, padding)`	1D слой обратного максимального пулинга.
`torch.nn.MaxUnpool2d(kernel_size, stride, padding)`	2D слой обратного максимального пулинга.
`torch.nn.MaxUnpool3d(kernel_size, stride, padding)`	3D слой обратного максимального пулинга.
`torch.nn.AvgPool1d(kernel_size, stride, padding)`	1D слой усредняющего пулинга.
`torch.nn.AvgPool2d(kernel_size, stride, padding, ceil_mode, count_include_pad)`	2D слой усредняющего пулинга.
`torch.nn.AvgPool3d(kernel_size, stride, padding, ceil_mode, count_include_pad)`	3D слой усредняющего пулинга.
`torch.nn.AdaptiveMaxPool1d(output_size, return_indices)`	1D адаптивный макс-пулинг, фиксированный размер выхода.
`torch.nn.AdaptiveMaxPool2d(output_size, return_indices)`	2D адаптивный макс-пулинг, фиксированный размер выхода.
`torch.nn.AdaptiveMaxPool3d(output_size, return_indices)`	3D адаптивный макс-пулинг, фиксированный размер выхода.
`torch.nn.AdaptiveAvgPool1d(output_size)`	1D адаптивный усредняющий пулинг, фиксированный размер выхода.
`torch.nn.AdaptiveAvgPool2d(output_size)`	2D адаптивный усредняющий пулинг, фиксированный размер выхода.
`torch.nn.AdaptiveAvgPool3d(output_size)`	3D адаптивный усредняющий пулинг, фиксированный размер выхода.
`torch.nn.LPPool1d(norm_type, kernel_size, stride, padding)`	1D слой Lp-пулинга.
`torch.nn.LPPool2d(norm_type, kernel_size, stride, padding)`	2D слой Lp-пулинга.
`torch.nn.FractionalMaxPool2d(kernel_size, output_size, output_ratio, return_indices)`	2D дробный макс-пулинг, с использованием случайных размеров шага.
`torch.nn.FractionalMaxPool3d(kernel_size, output_size, output_ratio, return_indices)`	3D дробный макс-пулинг, с использованием случайных размеров шага.

Слои дополнения

Класс/Функция	Описание
`torch.nn.ReflectionPad1d(padding)`	1D отражающее дополнение, копирует, отражая вдоль границы.
`torch.nn.ReflectionPad2d(padding)`	2D отражающее дополнение, копирует, отражая вдоль границы.
`torch.nn.ReflectionPad3d(padding)`	3D отражающее дополнение, копирует, отражая вдоль границы.
`torch.nn.ReplicationPad1d(padding)`	1D дополнение повторением, копирует краевые значения вдоль границы.
`torch.nn.ReplicationPad2d(padding)`	2D дополнение повторением, копирует краевые значения вдоль границы.
`torch.nn.ReplicationPad3d(padding)`	3D дополнение повторением, копирует краевые значения вдоль границы.
`torch.nn.ZeroPad1d(padding)`	1D дополнение нулями.
`torch.nn.ZeroPad2d(padding)`	2D дополнение нулями.
`torch.nn.ZeroPad3d(padding)`	3D дополнение нулями.
`torch.nn.ConstantPad1d(padding, value)`	1D константное дополнение, заполняет заданным значением.
`torch.nn.ConstantPad2d(padding, value)`	2D константное дополнение, заполняет заданным значением.
`torch.nn.ConstantPad3d(padding, value)`	3D константное дополнение, заполняет заданным значением.
`torch.nn.CircularPad1d(padding)`	1D циклическое дополнение.
`torch.nn.CircularPad2d(padding)`	2D циклическое заполнение.
`torch.nn.CircularPad3d(padding)`	3D циклическое заполнение.

Функции активации (нелинейные активации — взвешенная сумма)

Класс/Функция	Описание
`torch.nn.ReLU(inplace)`	Функция активации ReLU, f(x) = max(0, x).
`torch.nn.ReLU6(inplace)`	Функция активации ReLU6, f(x) = min(max(0, x), 6).
`torch.nn.Sigmoid()`	Сигмоидная функция активации, f(x) = 1 / (1 + exp(-x)).
`torch.nn.Tanh()`	Функция активации tanh, f(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x)).
`torch.nn.LeakyReLU(negative_slope, inplace)`	LeakyReLU, допускает малые градиенты для отрицательных значений.
`torch.nn.PReLU(num_parameters, init)`	Parametric ReLU, с обучаемым параметром отрицательного наклона.
`torch.nn.ELU(alpha, inplace)`	Экспоненциальная линейная единица, использует экспоненциальную функцию для отрицательных значений.
`torch.nn.CELU(alpha, inplace)`	Непрерывно дифференцируемая экспоненциальная линейная единица.
`torch.nn.SELU(inplace)`	Самонормализующаяся экспоненциальная линейная единица.
`torch.nn.GELU()`	Gaussian Error Linear Unit, обычно используемая в трансформерах.
`torch.nn.SiLU(inplace)`	Сигмоидальная линейная единица (Swish), f(x) = x * sigmoid(x).
`torch.nn.Mish(inplace)`	Функция активации Mish, f(x) = x * tanh(softplus(x)).
`torch.nn.Hardtanh(min_value, max_value, inplace)`	Жёсткий гиперболический тангенс, ограничивает диапазон выходных значений.
`torch.nn.Hardswish(inplace)`	Hard Swish, сглаженная версия ReLU6.
`torch.nn.Hardsigmoid(inplace)`	Hard Sigmoid, кусочно-линейная аппроксимация.
`torch.nn.RReLU(lower, upper, inplace)`	Randomized LeakyReLU, случайно выбирает отрицательный наклон во время обучения.
`torch.nn.Softplus(beta, threshold)`	Softplus, гладкая аппроксимация ReLU.
`torch.nn.Softshrink(lambda)`	Функция активации Softshrink.
`torch.nn.Hardshrink(lambda)`	Функция активации Hardshrink.
`torch.nn.Softsign()`	Функция активации Softsign, f(x) = x / (1 + \|x\|).
`torch.nn.Tanhshrink()`	Tanhshrink，f(x) = x - tanh(x).
`torch.nn.LogSigmoid()`	Log Sigmoid, f(x) = log(sigmoid(x)).
`torch.nn.Threshold(threshold, value, inplace)`	Пороговая функция активации.
`torch.nn.GLU(dim)`	Gated Linear Unit, разделяет вход на две части по заданному измерению и поэлементно их перемножает.

Функции активации (нелинейные активации — другие)

Класс/Функция	Описание
`torch.nn.Softmax(dim)`	Функция активации Softmax, преобразует значения в распределение вероятностей.
`torch.nn.Softmax2d()`	Softmax по пространственным измерениям, используется для изображений.
`torch.nn.LogSoftmax(dim)`	Log Softmax, численно устойчивая версия Softmax.
`torch.nn.Softmin(dim)`	Softmin, противоположность Softmax.
`torch.nn.AdaptiveLogSoftmaxWithLoss(in_features, n_classes, cutoffs, div_value, head_bias)`	Adaptive Log Softmax, используется для классификации с большим словарём.

Слои нормализации

Класс/Функция	Описание
`torch.nn.BatchNorm1d(num_features, eps, momentum, affine, track_running_stats)`	Одномерный слой пакетной нормализации, нормализует данные мини-батча.
`torch.nn.BatchNorm2d(num_features, eps, momentum, affine, track_running_stats)`	Двумерный слой пакетной нормализации, обычно используется в свёрточных сетях.
`torch.nn.BatchNorm3d(num_features, eps, momentum, affine, track_running_stats)`	Трёхмерный слой пакетной нормализации, используется для трёхмерных данных, таких как видео.
`torch.nn.LazyBatchNorm1d()`	Одномерная пакетная нормализация с отложенной инициализацией.
`torch.nn.LazyBatchNorm2d()`	Двумерная пакетная нормализация с отложенной инициализацией.
`torch.nn.LazyBatchNorm3d()`	Трёхмерная пакетная нормализация с отложенной инициализацией.
`torch.nn.LayerNorm(normalized_shape, eps, elementwise_affine)`	Слоевая нормализация, обычно используемая в трансформерах.
`torch.nn.GroupNorm(num_groups, num_channels, eps, affine)`	Групповая нормализация, нормализует после группировки каналов.
`torch.nn.InstanceNorm1d(num_features, eps, momentum, affine, track_running_stats)`	Одномерная нормализация экземпляра, используемая для переноса стиля.
`torch.nn.InstanceNorm2d(num_features, eps, momentum, affine, track_running_stats)`	Двумерная нормализация экземпляра, используемая для переноса стиля.
`torch.nn.InstanceNorm3d(num_features, eps, momentum, affine, track_running_stats)`	Трёхмерная нормализация экземпляра, используемая для переноса стиля.
`torch.nn.SyncBatchNorm(num_features, eps, momentum, affine, track_running_stats, process_group)`	Синхронизированная пакетная нормализация, используемая для распределённого обучения на нескольких GPU.
`torch.nn.LocalResponseNorm(k, alpha, beta, size)`	Локальная нормализация отклика, используемая в свёрточных нейронных сетях для латерального торможения.
`torch.nn.RMSNorm(normalized_shape, eps, elementwise_affine)`	RMS-нормализация, обычно используемая в трансформерах.

Слои рекуррентных нейронных сетей.

Класс/Функция	Описание
`torch.nn.RNN(input_size, hidden_size, num_layers, nonlinearity, bias, batch_first, dropout, bidirectional)`	Простой слой RNN.
`torch.nn.LSTM(input_size, hidden_size, num_layers, bias, batch_first, dropout, bidirectional, proj_size)`	Слой LSTM (долгая краткосрочная память).
`torch.nn.GRU(input_size, hidden_size, num_layers, bias, batch_first, dropout, bidirectional, proj_size)`	Слой GRU (управляемый рекуррентный блок).
`torch.nn.RNNCell(input_size, hidden_size, bias, nonlinearity)`	Ячейка RNN (одиночный слой).
`torch.nn.LSTMCell(input_size, hidden_size, bias)`	Ячейка LSTM (одиночный слой).
`torch.nn.GRUCell(input_size, hidden_size, bias)`	Ячейка GRU (одиночный слой).

Слои Transformer

Класс/Функция	Описание
`torch.nn.Transformer(d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout, activation, custom_encoder, custom_decoder, layer_norm_eps, normalize_before, need_src_mask, need_tgt_mask, need_memory_mask, batch_first, norm_first, bias)`	Полная модель Transformer.
`torch.nn.TransformerEncoder(encoder_layer, num_layers, norm)`	Энкодер Transformer.
`torch.nn.TransformerDecoder(decoder_layer, num_layers, norm)`	Декодер Transformer.
`torch.nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, activation, layer_norm_eps, batch_first, norm_first, bias)`	Слой энкодера Transformer.
`torch.nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout, activation, layer_norm_eps, batch_first, norm_first, bias)`	Слой декодера Transformer.
`torch.nn.MultiheadAttention(embed_dim, num_heads, dropout, bias, add_bias_kv, add_zero_attn, kdim, vdim, batch_first)`	Механизм многоголового внимания.

Механизмы внимания

Функция	Описание
`torch.nn.functional.scaled_dot_product_attention(query, key, value, attn_mask, dropout_p, is_causal)`	Масштабированное внимание на основе скалярного произведения, оптимизированная реализация механизма внимания в PyTorch.
`torch.nn.attention.sdpa_kernel(backends)`	Устанавливает бэкенд внимания SDP (Scaled Dot-Product).

Слои встраивания (разреженные слои)

Класс/Функция	Описание
`torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)`	Слой встраивания, отображает дискретные индексы в плотные векторы.
`torch.nn.EmbeddingBag(num_embeddings, embedding_dim, max_norm, norm_type, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx)`	Embedding bag, агрегирует несколько встраиваний.

Слои Dropout

Класс/Функция	Описание
`torch.nn.Dropout(p, inplace)`	Слой Dropout, случайным образом обнуляет элементы входных данных.
`torch.nn.Dropout1d(p, inplace)`	Одномерный Dropout, используется для одномерных входных данных.
`torch.nn.Dropout2d(p, inplace)`	Двумерный Dropout, используется для двумерных карт признаков.
`torch.nn.Dropout3d(p, inplace)`	Трёхмерный Dropout, используется для трёхмерных объёмов признаков.
`torch.nn.AlphaDropout(p, inplace)`	Alpha Dropout, сохраняет свойства самонормализации.
`torch.nn.FeatureAlphaDropout(p, inplace)`	Feature Alpha Dropout.

Слои компьютерного зрения

Класс/Функция	Описание
`torch.nn.PixelShuffle(upscale_factor)`	Pixel shuffle, преобразует размерности каналов в пространственные размерности (апсемплинг).
`torch.nn.PixelUnshuffle(downscale_factor)`	Inverse pixel shuffle, преобразует пространственные размерности в размерности каналов (даунсемплинг).
`torch.nn.Upsample(size, scale_factor, mode, align_corners, recompute_scale_factor)`	Слой апсемплинга.
`torch.nn.UpsamplingNearest2d(size, scale_factor)`	Двумерный апсемплинг методом ближайшего соседа.
`torch.nn.UpsamplingBilinear2d(size, scale_factor, align_corners)`	Двумерный билинейный апсемплинг.
`torch.nn.ChannelShuffle(groups)`	Channel shuffle, используется для сетей ChannelShuffle.

Функции потерь

Класс/Функция	Описание
`torch.nn.MSELoss(size_average, reduce, reduction)`	Потеря среднеквадратичной ошибки.
`torch.nn.L1Loss(size_average, reduce, reduction)`	Потеря L1 (средняя абсолютная ошибка).
`torch.nn.CrossEntropyLoss(weight, size_average, ignore_index, reduce, reduction, label_smoothing)`	Потеря кросс-энтропии, используется для задач многоклассовой классификации.
`torch.nn.NLLLoss(weight, size_average, ignore_index, reduce, reduction)`	Потеря отрицательного логарифмического правдоподобия.
`torch.nn.BCELoss(weight, size_average, reduce, reduction)`	Потеря бинарной кросс-энтропии (бинарная классификация).
`torch.nn.BCEWithLogitsLoss(weight, pos_weight, size_average, reduce, reduction, label_smoothing)`	Потеря бинарной кросс-энтропии с Sigmoid, численно более устойчива.
`torch.nn.KLDivLoss(size_average, reduce, reduction, log_target)`	Потеря KL-дивергенции, используется для сопоставления распределений.
`torch.nn.HuberLoss(delta, size_average, reduce, reduction)`	Потеря Huber, комбинация L1 и L2, более устойчива к выбросам.
`torch.nn.SmoothL1Loss(beta, size_average, reduce, reduction)`	Потеря Smooth L1 (вариант потери Huber).
`torch.nn.CTCLoss(blank, reduction, zero_infinity)`	Потеря Connectionist Temporal Classification, используется для последовательностных задач, таких как распознавание речи.
`torch.nn.PoissonNLLLoss(log_input, full, size_average, reduce, reduction)`	Потеря отрицательного логарифмического правдоподобия Пуассона.
`torch.nn.GaussianNLLLoss(full, size_average, reduce, reduction)`	Потеря отрицательного логарифмического правдоподобия Гаусса.
`torch.nn.MarginRankingLoss(margin, size_average, reduce, reduction)`	Потеря ранжирования с margin, используется для обучения ранжированию.
`torch.nn.HingeEmbeddingLoss(margin, size_average, reduce, reduction)`	Потеря Hinge для эмбеддингов, используется для метрического обучения.
`torch.nn.MultiLabelMarginLoss(size_average, reduce, reduction)`	Многометочная потеря с margin.
`torch.nn.SoftMarginLoss(size_average, reduce, reduction)`	Потеря с мягким margin.
`torch.nn.MultiLabelSoftMarginLoss(weight, size_average, reduce, reduction)`	Многометочная потеря с мягким margin.
`torch.nn.CosineEmbeddingLoss(margin, size_average, reduce, reduction)`	Cosine embedding loss, используется для метрического обучения.
`torch.nn.MultiMarginLoss(p, margin, weight, size_average, reduce, reduction)`	Multi-class margin loss.
`torch.nn.TripletMarginLoss(margin, p, eps, swap, size_average, reduce, reduction)`	Triplet loss, используется для метрического и контрастивного обучения.
`torch.nn.TripletMarginWithDistanceLoss(distance_function, margin, swap, size_average, reduce, reduction)`	Triplet loss с функцией расстояния.

Функции расстояния

Класс/Функция	Описание
`torch.nn.PairwiseDistance(p, eps, keepdim)`	Вычисление попарных расстояний.
`torch.nn.CosineSimilarity(dim, eps)`	Вычисление косинусного сходства.

Параллельные слои (DataParallel)

Класс/Функция	Описание
`torch.nn.DataParallel(module, device_ids, output_device, dim)`	Параллелизм данных, запускает модель параллельно на нескольких GPU.
`torch.nn.parallel.DistributedDataParallel(module, device_ids, broadcast_buffers, bucket_cap_mb, find_unused_parameters, gradient_as_bucket_view, static_graph)`	Распределённый параллелизм данных, используется для многоузлового распределённого обучения.

Вспомогательные функции (nn.functional)

Функция	Описание
`torch.nn.functional.relu(input, inplace)`	Применяет функцию активации ReLU.
`torch.nn.functional.sigmoid(input)`	Применяет функцию активации Sigmoid.
`torch.nn.functional.tanh(input)`	Применяет функцию активации Tanh.
`torch.nn.functional.softmax(input, dim, dtype)`	Применяет функцию активации Softmax.
`torch.nn.functional.log_softmax(input, dim, dtype)`	Применяет функцию активации Log Softmax.
`torch.nn.functional.gelu(input)`	Применяет функцию активации GELU.
`torch.nn.functional.silu(input)`	Применяет функцию активации SiLU (Swish).
`torch.nn.functional.mish(input)`	Применяет функцию активации Mish.
`torch.nn.functional.hardswish(input)`	Применяет функцию активации Hardswish.
`torch.nn.functional.leaky_relu(input, negative_slope, inplace)`	Применяет функцию активации LeakyReLU.
`torch.nn.functional.elu(input, alpha, inplace)`	Применяет функцию активации ELU.
`torch.nn.functional.dropout(input, p, training, inplace)`	Применяет Dropout.
`torch.nn.functional.conv1d(input, weight, bias, stride, padding, dilation, groups)`	Одномерная операция свёртки.
`torch.nn.functional.conv2d(input, weight, bias, stride, padding, dilation, groups)`	Двумерная операция свёртки.
`torch.nn.functional.conv3d(input, weight, bias, stride, padding, dilation, groups)`	Трёхмерная операция свёртки.
`torch.nn.functional.max_pool1d(input, kernel_size, stride, padding, dilation, return_indices)`	Одномерное объединение по максимуму.
`torch.nn.functional.max_pool2d(input, kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	Двумерное объединение по максимуму.
`torch.nn.functional.avg_pool1d(input, kernel_size, stride, padding, ceil_mode, count_include_pad)`	Одномерное объединение по среднему.
`torch.nn.functional.avg_pool2d(input, kernel_size, stride, padding, ceil_mode, count_include_pad)`	Двумерное объединение по среднему.
`torch.nn.functional.linear(input, weight, bias)`	Линейное преобразование (умножение матриц).
`torch.nn.functional.cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction, label_smoothing)`	Вычисляет потерю кросс-энтропии.
`torch.nn.functional.mse_loss(input, target, size_average, reduce, reduction)`	Вычисляет потерю среднеквадратичной ошибки.
`torch.nn.functional.l1_loss(input, target, size_average, reduce, reduction)`	Вычисляет потерю L1.
`torch.nn.functional.binary_cross_entropy(input, target, weight, size_average, reduce, reduction)`	Вычисляет потерю бинарной кросс-энтропии.
`torch.nn.functional.nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction)`	Вычисляет потерю отрицательного логарифмического правдоподобия.
`torch.nn.functional.huber_loss(input, target, delta, size_average, reduce, reduction)`	Вычисляет потерю Хубера.
`torch.nn.functional.batch_norm(input, running_mean, running_var, weight, bias, training, momentum, eps, track_running_stats)`	Операция пакетной нормализации.
`torch.nn.functional.layer_norm(input, normalized_shape, weight, bias, eps)`	Операция послойной нормализации.
`torch.nn.functional.group_norm(input, num_groups, weight, bias, eps)`	Операция групповой нормализации.
`torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners, recompute_scale_factor)`	Интерполяция (повышающая/понижающая дискретизация).
`torch.nn.functional.grid_sample(input, grid, mode, padding_mode, align_corners)`	Выборка по сетке, используется для регистрации изображений и пространственных трансформерных сетей.
`torch.nn.functional.affine_grid(theta, size, align_corners)`	Генерация аффинной сетки, используется для пространственных трансформерных сетей.
`torch.nn.functional.pixel_shuffle(input, upscale_factor)`	Перестановка пикселей.
`torch.nn.functional.pixel_unshuffle(input, downscale_factor)`	Обратная перестановка пикселей.
`torch.nn.functional.pad(input, pad, mode, value)`	Операция дополнения.
`torch.nn.functional.one_hot(tensor, num_classes)`	Преобразует целые числа в one-hot-кодирование.
`torch.nn.functional.embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)`	Операция встраивания.
`torch.nn.functional.cosine_similarity(x1, x2, dim, eps)`	Вычисление косинусного сходства.
`torch.nn.functional.pairwise_distance(x1, x2, p, eps, keepdim)`	Вычисление попарных расстояний.

Вспомогательные функции (nn.utils)

Функция	Описание
`torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type, error_if_nonfinite)`	Обрезает норму градиента (in-place операция).
`torch.nn.utils.clip_grad_norm(parameters, max_norm, norm_type)`	Обрезает норму градиента (не in-place).
`torch.nn.utils.clip_grad_value_(parameters, clip_value)`	Обрезает диапазон значений градиента.
`torch.nn.utils.get_total_norm(parameters, norm_type)`	Вычисляет общую норму градиента.
`torch.nn.utils.weight_norm(module, name, dim)`	Применяет нормализацию весов к параметрам модуля.
`torch.nn.utils.remove_weight_norm(module, name)`	Удаляет нормализацию весов.
`torch.nn.utils.spectral_norm(module, name, n_power_iterations, eps, bias)`	Применяет спектральную нормализацию к параметрам модуля.
`torch.nn.utils.remove_spectral_norm(module, name)`	Удаляет спектральную нормализацию.
`torch.nn.utils.fuse_conv_bn_eval(conv, bn)`	Объединяет свёрточные слои и слои пакетной нормализации (режим вывода).
`torch.nn.utils.fuse_linear_bn_eval(linear, bn)`	Объединяет линейные слои и слои пакетной нормализации (режим вывода).
`torch.nn.utils.skip_init(module_class, args, *kwargs)`	Пропускает инициализацию параметров.
`torch.nn.utils.parameters_to_vector(parameters)`	Преобразует список параметров в вектор.
`torch.nn.utils.vector_to_parameters(vector, parameters)`	Преобразует вектор в список параметров.

Инициализация параметров (nn.init)

Функция	Описание
`torch.nn.init.zeros_(tensor)`	Инициализирует тензор нулями.
`torch.nn.init.ones_(tensor)`	Инициализирует тензор единицами.
`torch.nn.init.uniform_(tensor, a, b)`	Инициализация равномерным распределением.
`torch.nn.init.normal_(tensor, mean, std)`	Инициализация нормальным распределением.
`torch.nn.init.constant_(tensor, val)`	Инициализация константным значением.
`torch.nn.init.eye_(tensor)`	Инициализация единичной матрицей (применимо только к двумерным квадратным матрицам).
`torch.nn.init.dirac_(tensor)`	Инициализация дельтой Дирака (сохраняет количество входных каналов).
`torch.nn.init.xavier_uniform_(tensor, gain)`	Инициализация равномерным распределением Xavier.
`torch.nn.init.xavier_normal_(tensor, gain)`	Инициализация нормальным распределением Xavier.
`torch.nn.init.kaiming_uniform_(tensor, a, mode, nonlinearity)`	Инициализация равномерным распределением Kaiming, подходит для активаций ReLU.
`torch.nn.init.kaiming_normal_(tensor, a, mode, nonlinearity)`	Инициализация нормальным распределением Kaiming, подходит для активаций ReLU.
`torch.nn.init.trunc_normal_(tensor, mean, std, a, b)`	Инициализация усечённым нормальным распределением.
`torch.nn.init.orthogonal_(tensor, gain)`	Ортогональная инициализация.
`torch.nn.init.sparse_(tensor, sparsity, std)`	Разреженная инициализация (в основном нули).
`torch.nn.init.calculate_gain(nonlinearity, param)`	Вычислить значение коэффициента усиления инициализации.

Вспомогательные функции для RNN

Функция	Описание
`torch.nn.utils.rnn.PackedSequence`	Упаковать последовательности для обработки последовательностей переменной длины.
`torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first, enforce_sorted)`	Упаковать дополненные последовательности.
`torch.nn.utils.rnn.pad_packed_sequence(input, batch_first, padding_value, total_length)`	Распаковать последовательности.
`torch.nn.utils.rnn.pad_sequence(sequences, batch_first, padding_value)`	Дополнить последовательности до одинаковой длины.
`torch.nn.utils.rnn.pack_sequence(sequences, enforce_sorted)`	Напрямую упаковать список последовательностей.

Функции прореживания

Функция	Описание
`torch.nn.utils.prune.random_unstructured(module, name, amount)`	Случайное неструктурированное прореживание.
`torch.nn.utils.prune.l1_unstructured(module, name, amount)`	Неструктурированное прореживание L1.
`torch.nn.utils.prune.global_unstructured(parameters, pruning_method, amount)`	Глобальное неструктурированное прореживание.
`torch.nn.utils.prune.remove(module, name)`	Удалить прореживание.
`torch.nn.utils.prune.is_pruned(module)`	Проверить, был ли модуль прорежен.

Слой Flatten

Класс/Функция	Описание
`torch.nn.Flatten(start_dim, end_dim)`	Flatten тензора, преобразование многомерного тензора в двумерный.
`torch.nn.Unflatten(dim, unflattened_size)`	Unflatten, преобразование одномерного тензора в многомерный.

Пример

import torch
import torch.nn as nn

# Определить простую нейронную сеть
class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(10, 20)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(20, 1)

def forward(self, x):
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x

# Создать модель и входные данные
model = SimpleNet()
input = torch.randn(5, 10)
output = model(input)
print(output)

Пример: классификация изображений с использованием CNN

import torch
import torch.nn as nn

class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
# Свёрточный слой
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)

# Слой пулинга
self.pool = nn.MaxPool2d(2, 2)

# Пакетная нормализация
self.bn1 = nn.BatchNorm2d(16)
self.bn2 = nn.BatchNorm2d(32)
self.bn3 = nn.BatchNorm2d(64)

# Функция активации
self.relu = nn.ReLU()

# Полносвязный слой
self.fc1 = nn.Linear(64 * 4 * 4, 256)
self.fc2 = nn.Linear(256, 10)

# Dropout
self.dropout = nn.Dropout(0.5)

def forward(self, x):
# Свёртка -> BN -> ReLU -> Пул
x = self.pool(self.relu(self.bn1(self.conv1(x))))
x = self.pool(self.relu(self.bn2(self.conv2(x))))
x = self.pool(self.relu(self.bn3(self.conv3(x))))

# Выравнивание
x = x.view(x.size(0), -1)

# FC -> ReLU -> Dropout -> FC
x = self.dropout(self.relu(self.fc1(x)))
x = self.fc2(x)
return x

# Создание модели
model = CNN()
print(model)

# Проверка прямого распространения
input_tensor = torch.randn(1, 3, 32, 32)
output = model(input_tensor)
print("Форма выхода:", output.shape)

Пример: классификация текста с использованием LSTM

import torch
import torch.nn as nn

class LSTMClassifier(nn.Module):
def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, output_dim):
super(LSTMClassifier, self).__init__()

# Слой эмбеддингов
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)

# Слой LSTM
self.lstm = nn.LSTM(
embedding_dim,
hidden_dim,
num_layers=num_layers,
batch_first=True,
bidirectional=True,
dropout=0.5
)

# Полносвязный слой
self.fc = nn.Linear(hidden_dim * 2, output_dim)

# Dropout
self.dropout = nn.Dropout(0.5)

def forward(self, text, text_lengths):
# Embedding
embedded = self.embedding(text)

# Упаковка последовательностей для обработки входных данных переменной длины
packed = nn.utils.rnn.pack_padded_sequence(
embedded, text_lengths.cpu(), batch_first=True, enforce_sorted=False
)

# LSTM
packed_output, (hidden, cell) = self.lstm(packed)

# Распаковка
output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)

# Объединить финальные скрытые состояния двунаправленного слоя
hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)

# Dropout и полносвязный слой
hidden = self.dropout(hidden)
output = self.fc(hidden)

return output

# Параметры
vocab_size = 10000
embedding_dim = 128
hidden_dim = 256
num_layers = 2
output_dim = 5 # 5 классов

# Создание модели
model = LSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, output_dim)
print(model)

Пример: использование Transformer Encoder

import torch
import torch.nn as nn

class TransformerClassifier(nn.Module):
def __init__(self, input_dim, d_model, nhead, num_layers, dim_feedforward, output_dim, dropout):
super(TransformerClassifier, self).__init__()

# Слой эмбеддингов
self.embedding = nn.Linear(input_dim, d_model)

# Позиционное кодирование
self.positional_encoding = nn.Parameter(torch.randn(1, 1000, d_model) * 0.1)

# Слой энкодера Transformer
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model,
nhead=nhead,
dim_feedforward=dim_feedforward,
dropout=dropout,
batch_first=True
)

# Энкодер Transformer
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)

# Головка классификации
self.fc = nn.Linear(d_model, output_dim)
self.dropout = nn.Dropout(dropout)

def forward(self, x):
# Добавить позиционное кодирование
seq_len = x.size(1)
x = self.embedding(x) + self.positional_encoding[:, :seq_len, :]

# Кодирование трансформером
x = self.transformer_encoder(x)

# Использовать выход в первой позиции для классификации (аналогично токену CLS)
x = x[:, 0, :]

x = self.dropout(x)
x = self.fc(x)

return x

# Параметры
input_dim = 512
d_model = 512
nhead = 8
num_layers = 6
dim_feedforward = 2048
output_dim = 10
dropout = 0.1

# Создание модели
model = TransformerClassifier(input_dim, d_model, nhead, num_layers, dim_feedforward, output_dim, dropout)
print(model)

#
x = torch.randn(32, 100, input_dim) # batch_size=32, seq_len=100
output = model(x)
print("Форма выхода:", output.shape) # (32, 10)

Если вам нужна более подробная информация, обратитесь кофициальной документации PyTorch。

Другие расширения