Manual de referencia de PyTorch torch.nn

de PyTorchtorch.nnEl módulo es un módulo central para construir y entrenar redes neuronales; proporciona una amplia variedad de clases y funciones para definir y operar redes neuronales.

A continuación se presentantorch.nnalgunos componentes clave del módulo y sus funciones:

1. Clase nn.Module：

nn.ModuleEs la clase base de todos los modelos de redes neuronales personalizados. Los usuarios suelen derivar sus propias clases de modelo de esta clase y definir en ella la estructura de las capas de la red y la función de propagación hacia adelante (forward pass).

2. Capas predefinidas (Modules)：

Incluye varios tipos de componentes de capas, como capas convolucionales (nn.Conv1d, nn.Conv2d, nn.Conv3d), capas totalmente conectadas (nn.Linear), funciones de activación (nn.ReLU, nn.Sigmoid, nn.Tanh), etc.

3. Clases contenedoras：

nn.Sequential: Permiten combinar varias capas en orden para formar redes simples apiladas linealmente.
nn.ModuleListynn.ModuleDict: Pueden almacenar y acceder dinámicamente a submódulos, admitiendo colecciones de módulos de longitud variable o con nombre.

4. Funciones de pérdida (Loss Functions)：

torch.nnIncluye una serie de funciones de pérdida para medir la diferencia entre las predicciones del modelo y las etiquetas verdaderas, como el error cuadrático medio (nn.MSELoss), la pérdida de entropía cruzada (nn.CrossEntropyLoss), etc.

5. Interfaz funcional (Functional Interface)：

nn.functional(Generalmente abreviada comoF), contiene muchas funciones que pueden actuar directamente sobre tensores. Implementan las mismas funcionalidades que los objetos de capa, pero no tienen la capacidad de guardar y actualizar parámetros. Por ejemplo, se puede usarF.relu()para realizar una operación ReLU directamente, oF.conv2d()para realizar una operación de convolución.

6. Métodos de inicialización：

torch.nn.initProporcionan algunas estrategias comunes de inicialización de pesos, como la inicialización de Xavier (nn.init.xavier_uniform_()) y la inicialización de Kaiming (nn.init.kaiming_uniform_()), que son cruciales para entrenar redes neuronales con éxito.

7. Capa Transformer：

PyTorch proporciona componentes completos de la arquitectura Transformer, incluyendonn.Transformer, nn.TransformerEncoder, nn.TransformerDecodery mecanismos de atenciónnn.MultiheadAttention, etc.

8. Capas de normalización：

Incluyen normalización por lotes (BatchNorm), normalización de capa (LayerNorm), normalización de grupo (GroupNorm), normalización de instancia (InstanceNorm) y RMSNorm, etc.

Manual de referencia del módulo PyTorch torch.nn

Contenedores de redes neuronales

Clase/Función	Descripción
`torch.nn.Module`	La clase base de todos los módulos de redes neuronales.
`torch.nn.Sequential(*args)`	Combina varios módulos en orden.
`torch.nn.ModuleList(modules)`	Almacena submódulos en una lista.
`torch.nn.ModuleDict(modules)`	Almacena submódulos en un diccionario.
`torch.nn.ParameterList(parameters)`	Almacena parámetros en una lista.
`torch.nn.ParameterDict(parameters)`	Almacena parámetros en un diccionario.
`torch.nn.Parameter(data)`	Crea un tensor de parámetros aprendible.
`torch.nn.Buffer(data)`	Crea un buffer persistente (parámetro no aprendible).
`torch.nn.Identity(args, *kwargs)`	Capa de transformación identidad, la entrada se emite directamente.

Hooks globales

Función	Descripción
`register_module_forward_pre_hook(hook)`	Registra un hook previo a la propagación hacia adelante.
`register_module_forward_hook(hook)`	Registra un hook de propagación hacia adelante.
`register_module_backward_hook(hook)`	Registra un hook de propagación hacia atrás.
`register_module_full_backward_pre_hook(hook)`	Registra un hook previo completo de propagación hacia atrás.
`register_module_full_backward_hook(hook)`	Registra un hook completo de propagación hacia atrás.

Capas lineales

Clase/Función	Descripción
`torch.nn.Linear(in_features, out_features, bias)`	Capa totalmente conectada (transformación lineal).
`torch.nn.Bilinear(in1_features, in2_features, out_features, bias)`	Capa bilineal.
`torch.nn.LazyLinear(out_features, bias)`	Capa lineal de inicialización diferida; infiere automáticamente la dimensión de entrada en la primera propagación hacia adelante.

Capas convolucionales

Clase/Función	Descripción
`torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	Capa convolucional unidimensional, comúnmente usada en texto y audio.
`torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	Capa convolucional bidimensional, comúnmente usada en imágenes.
`torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias, padding_mode)`	Capa convolucional tridimensional, comúnmente usada en video y datos volumétricos.
`torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	Convolución transpuesta (deconvolución) unidimensional, para muestreo ascendente (upsampling).
`torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	Convolución transpuesta (deconvolución) bidimensional, para muestreo ascendente.
`torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride, padding, output_padding, groups, bias, dilation, padding_mode)`	Convolución transpuesta (deconvolución) tridimensional, para muestreo ascendente.
`torch.nn.Unfold(kernel_size, dilation, padding, stride)`	Expande el tensor de entrada en bloques de ventana deslizante.
`torch.nn.Fold(output_size, kernel_size, dilation, padding, stride)`	Recombina los bloques expandidos en un tensor.

Capas de pooling

Clase/Función	Descripción
`torch.nn.MaxPool1d(kernel_size, stride, padding, dilation, return_indices)`	Capa de max pooling unidimensional.
`torch.nn.MaxPool2d(kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	Capa de max pooling bidimensional.
`torch.nn.MaxPool3d(kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	Capa de max pooling tridimensional.
`torch.nn.MaxUnpool1d(kernel_size, stride, padding)`	Capa de max unpooling unidimensional.
`torch.nn.MaxUnpool2d(kernel_size, stride, padding)`	Capa de max unpooling bidimensional.
`torch.nn.MaxUnpool3d(kernel_size, stride, padding)`	Capa de max unpooling tridimensional.
`torch.nn.AvgPool1d(kernel_size, stride, padding)`	Capa de average pooling unidimensional.
`torch.nn.AvgPool2d(kernel_size, stride, padding, ceil_mode, count_include_pad)`	Capa de average pooling bidimensional.
`torch.nn.AvgPool3d(kernel_size, stride, padding, ceil_mode, count_include_pad)`	Capa de average pooling tridimensional.
`torch.nn.AdaptiveMaxPool1d(output_size, return_indices)`	Max pooling adaptativo unidimensional, con tamaño de salida fijo.
`torch.nn.AdaptiveMaxPool2d(output_size, return_indices)`	Max pooling adaptativo bidimensional, con tamaño de salida fijo.
`torch.nn.AdaptiveMaxPool3d(output_size, return_indices)`	Max pooling adaptativo tridimensional, con tamaño de salida fijo.
`torch.nn.AdaptiveAvgPool1d(output_size)`	Average pooling adaptativo unidimensional, con tamaño de salida fijo.
`torch.nn.AdaptiveAvgPool2d(output_size)`	Average pooling adaptativo bidimensional, con tamaño de salida fijo.
`torch.nn.AdaptiveAvgPool3d(output_size)`	Average pooling adaptativo tridimensional, con tamaño de salida fijo.
`torch.nn.LPPool1d(norm_type, kernel_size, stride, padding)`	Capa de Lp pooling unidimensional.
`torch.nn.LPPool2d(norm_type, kernel_size, stride, padding)`	Capa de Lp pooling bidimensional.
`torch.nn.FractionalMaxPool2d(kernel_size, output_size, output_ratio, return_indices)`	Max pooling fraccional bidimensional, con pasos aleatorios.
`torch.nn.FractionalMaxPool3d(kernel_size, output_size, output_ratio, return_indices)`	Max pooling fraccional tridimensional, con pasos aleatorios.

Capas de relleno (Padding Layers)

Clase/Función	Descripción
`torch.nn.ReflectionPad1d(padding)`	Relleno por reflexión unidimensional; copia reflejando a lo largo del borde.
`torch.nn.ReflectionPad2d(padding)`	Relleno por reflexión bidimensional; copia reflejando a lo largo del borde.
`torch.nn.ReflectionPad3d(padding)`	Relleno por reflexión tridimensional; copia reflejando a lo largo del borde.
`torch.nn.ReplicationPad1d(padding)`	Relleno por replicación unidimensional; copia los valores del borde a lo largo del límite.
`torch.nn.ReplicationPad2d(padding)`	Relleno por replicación bidimensional; copia los valores del borde a lo largo del límite.
`torch.nn.ReplicationPad3d(padding)`	Relleno por replicación tridimensional; copia los valores del borde a lo largo del límite.
`torch.nn.ZeroPad1d(padding)`	Relleno con ceros unidimensional.
`torch.nn.ZeroPad2d(padding)`	Relleno con ceros bidimensional.
`torch.nn.ZeroPad3d(padding)`	Relleno con ceros tridimensional.
`torch.nn.ConstantPad1d(padding, value)`	Relleno constante unidimensional; rellena con un valor especificado.
`torch.nn.ConstantPad2d(padding, value)`	Relleno constante bidimensional; rellena con un valor especificado.
`torch.nn.ConstantPad3d(padding, value)`	Relleno constante tridimensional; rellena con un valor especificado.
`torch.nn.CircularPad1d(padding)`	Relleno cíclico unidimensional.
`torch.nn.CircularPad2d(padding)`	Relleno cíclico bidimensional.
`torch.nn.CircularPad3d(padding)`	Relleno cíclico tridimensional.

Funciones de activación (activación no lineal - tipo suma ponderada)

Clase/Función	Descripción
`torch.nn.ReLU(inplace)`	Función de activación ReLU, f(x) = max(0, x).
`torch.nn.ReLU6(inplace)`	Función de activación ReLU6, f(x) = min(max(0, x), 6).
`torch.nn.Sigmoid()`	Función de activación Sigmoid, f(x) = 1 / (1 + exp(-x)).
`torch.nn.Tanh()`	Función de activación Tanh, f(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x)).
`torch.nn.LeakyReLU(negative_slope, inplace)`	LeakyReLU, permite que los valores negativos tengan un gradiente pequeño.
`torch.nn.PReLU(num_parameters, init)`	ReLU parametrizado, con parámetro de pendiente negativa aprendible.
`torch.nn.ELU(alpha, inplace)`	Unidad lineal exponencial (ELU), usa una función exponencial para valores negativos.
`torch.nn.CELU(alpha, inplace)`	Unidad lineal exponencial continua y diferenciable.
`torch.nn.SELU(inplace)`	Unidad lineal exponencial auto-normalizada.
`torch.nn.GELU()`	Unidad lineal de error gaussiano (GELU), comúnmente usada en Transformers.
`torch.nn.SiLU(inplace)`	Unidad lineal Sigmoid (Swish), f(x) = x * sigmoid(x).
`torch.nn.Mish(inplace)`	Función de activación Mish, f(x) = x * tanh(softplus(x)).
`torch.nn.Hardtanh(min_value, max_value, inplace)`	Tangente hiperbólica dura, limita el rango de salida.
`torch.nn.Hardswish(inplace)`	Hard Swish, versión suavizada de ReLU6.
`torch.nn.Hardsigmoid(inplace)`	Hard Sigmoid, aproximación lineal por partes.
`torch.nn.RReLU(lower, upper, inplace)`	LeakyReLU aleatorio, selecciona aleatoriamente la pendiente negativa durante el entrenamiento.
`torch.nn.Softplus(beta, threshold)`	Softplus, aproximación suave de ReLU.
`torch.nn.Softshrink(lambda)`	Función de activación Softshrink.
`torch.nn.Hardshrink(lambda)`	Función de activación Hardshrink.
`torch.nn.Softsign()`	Función de activación 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)`	Función de activación por umbral.
`torch.nn.GLU(dim)`	Unidad lineal con compuerta (GLU), divide la entrada en dos partes a lo largo de una dimensión especificada y las multiplica elemento a elemento.

Funciones de activación (activación no lineal - otras)

Clase/Función	Descripción
`torch.nn.Softmax(dim)`	Función de activación Softmax, convierte valores en una distribución de probabilidad.
`torch.nn.Softmax2d()`	Softmax sobre dimensiones espaciales, utilizado para imágenes.
`torch.nn.LogSoftmax(dim)`	Log Softmax, versión numéricamente estable de Softmax.
`torch.nn.Softmin(dim)`	Softmin, lo opuesto a Softmax.
`torch.nn.AdaptiveLogSoftmaxWithLoss(in_features, n_classes, cutoffs, div_value, head_bias)`	Log Softmax adaptativo, para clasificación con vocabulario grande.

Capas de normalización

Clase/Función	Descripción
`torch.nn.BatchNorm1d(num_features, eps, momentum, affine, track_running_stats)`	Capa de normalización por lotes unidimensional, normaliza datos de mini-lotes.
`torch.nn.BatchNorm2d(num_features, eps, momentum, affine, track_running_stats)`	Capa de normalización por lotes bidimensional, comúnmente usada en redes convolucionales.
`torch.nn.BatchNorm3d(num_features, eps, momentum, affine, track_running_stats)`	Capa de normalización por lotes tridimensional, para datos tridimensionales como videos.
`torch.nn.LazyBatchNorm1d()`	Normalización por lotes unidimensional con inicialización diferida.
`torch.nn.LazyBatchNorm2d()`	Normalización por lotes bidimensional con inicialización diferida.
`torch.nn.LazyBatchNorm3d()`	Normalización por lotes tridimensional con inicialización diferida.
`torch.nn.LayerNorm(normalized_shape, eps, elementwise_affine)`	Normalización de capa, común en Transformers.
`torch.nn.GroupNorm(num_groups, num_channels, eps, affine)`	Normalización por grupos, normaliza después de agrupar los canales.
`torch.nn.InstanceNorm1d(num_features, eps, momentum, affine, track_running_stats)`	Normalización por instancias unidimensional, para transferencia de estilo.
`torch.nn.InstanceNorm2d(num_features, eps, momentum, affine, track_running_stats)`	Normalización por instancias bidimensional, para transferencia de estilo.
`torch.nn.InstanceNorm3d(num_features, eps, momentum, affine, track_running_stats)`	Normalización por instancias tridimensional, para transferencia de estilo.
`torch.nn.SyncBatchNorm(num_features, eps, momentum, affine, track_running_stats, process_group)`	Normalización por lotes sincronizada, para entrenamiento distribuido multi-GPU.
`torch.nn.LocalResponseNorm(k, alpha, beta, size)`	Normalización de respuesta local, para inhibición lateral en redes neuronales convolucionales.
`torch.nn.RMSNorm(normalized_shape, eps, elementwise_affine)`	Normalización RMS, común en Transformers.

Capas de redes neuronales recurrentes

Clase/Función	Descripción
`torch.nn.RNN(input_size, hidden_size, num_layers, nonlinearity, bias, batch_first, dropout, bidirectional)`	Capa RNN simple.
`torch.nn.LSTM(input_size, hidden_size, num_layers, bias, batch_first, dropout, bidirectional, proj_size)`	Capa LSTM (memoria a largo y corto plazo).
`torch.nn.GRU(input_size, hidden_size, num_layers, bias, batch_first, dropout, bidirectional, proj_size)`	Capa GRU (unidad recurrente con compuertas).
`torch.nn.RNNCell(input_size, hidden_size, bias, nonlinearity)`	Celda RNN (capa única).
`torch.nn.LSTMCell(input_size, hidden_size, bias)`	Celda LSTM (capa única).
`torch.nn.GRUCell(input_size, hidden_size, bias)`	Celda GRU (capa única).

Capas de Transformer

Clase/Función	Descripción
`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)`	Modelo Transformer completo.
`torch.nn.TransformerEncoder(encoder_layer, num_layers, norm)`	Codificador Transformer.
`torch.nn.TransformerDecoder(decoder_layer, num_layers, norm)`	Decodificador Transformer.
`torch.nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, activation, layer_norm_eps, batch_first, norm_first, bias)`	Capa de codificador Transformer.
`torch.nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout, activation, layer_norm_eps, batch_first, norm_first, bias)`	Capa de decodificador Transformer.
`torch.nn.MultiheadAttention(embed_dim, num_heads, dropout, bias, add_bias_kv, add_zero_attn, kdim, vdim, batch_first)`	Mecanismo de atención de múltiples cabezas.

Mecanismo de atención (Attention)

Función	Descripción
`torch.nn.functional.scaled_dot_product_attention(query, key, value, attn_mask, dropout_p, is_causal)`	Atención de producto punto escalado, implementación optimizada de atención de PyTorch.
`torch.nn.attention.sdpa_kernel(backends)`	Configurar el backend de SDP (atención de producto punto escalado).

Capas de embedding (capas dispersas)

Clase/Función	Descripción
`torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)`	Capa de embedding, mapea índices discretos a vectores densos.
`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)`	Bolsa de embeddings, agrega múltiples embeddings.

Capas de Dropout

Clase/Función	Descripción
`torch.nn.Dropout(p, inplace)`	Capa de Dropout, pone a cero elementos de entrada aleatoriamente.
`torch.nn.Dropout1d(p, inplace)`	Dropout unidimensional, para entradas unidimensionales.
`torch.nn.Dropout2d(p, inplace)`	Dropout bidimensional, para mapas de características bidimensionales.
`torch.nn.Dropout3d(p, inplace)`	Dropout tridimensional, para volúmenes de características tridimensionales.
`torch.nn.AlphaDropout(p, inplace)`	Alpha Dropout, mantiene propiedades de auto-normalización.
`torch.nn.FeatureAlphaDropout(p, inplace)`	Alpha Dropout de características.

Capas visuales (Vision Layers)

Clase/Función	Descripción
`torch.nn.PixelShuffle(upscale_factor)`	Reorganización de píxeles, convierte la dimensión de canales en dimensión espacial (sobremuestreo).
`torch.nn.PixelUnshuffle(downscale_factor)`	Operación inversa de reorganización de píxeles, convierte la dimensión espacial en dimensión de canales (submuestreo).
`torch.nn.Upsample(size, scale_factor, mode, align_corners, recompute_scale_factor)`	Capa de sobremuestreo.
`torch.nn.UpsamplingNearest2d(size, scale_factor)`	Sobremuestreo bidimensional por vecino más cercano.
`torch.nn.UpsamplingBilinear2d(size, scale_factor, align_corners)`	Sobremuestreo bidimensional bilineal.
`torch.nn.ChannelShuffle(groups)`	Mezcla de canales, para redes ChannelShuffle.

Funciones de pérdida

Clase/Función	Descripción
`torch.nn.MSELoss(size_average, reduce, reduction)`	Pérdida de error cuadrático medio (Mean Squared Error).
`torch.nn.L1Loss(size_average, reduce, reduction)`	Pérdida L1 (Error absoluto medio).
`torch.nn.CrossEntropyLoss(weight, size_average, ignore_index, reduce, reduction, label_smoothing)`	Pérdida de entropía cruzada, para tareas de clasificación múltiple.
`torch.nn.NLLLoss(weight, size_average, ignore_index, reduce, reduction)`	Pérdida de verosimilitud logarítmica negativa.
`torch.nn.BCELoss(weight, size_average, reduce, reduction)`	Pérdida de entropía cruzada binaria (clasificación binaria).
`torch.nn.BCEWithLogitsLoss(weight, pos_weight, size_average, reduce, reduction, label_smoothing)`	Pérdida de entropía cruzada binaria con Sigmoid, numéricamente más estable.
`torch.nn.KLDivLoss(size_average, reduce, reduction, log_target)`	Pérdida de divergencia KL, para coincidencia de distribuciones.
`torch.nn.HuberLoss(delta, size_average, reduce, reduction)`	Pérdida de Huber, combinación de L1 y L2, más robusta a valores atípicos.
`torch.nn.SmoothL1Loss(beta, size_average, reduce, reduction)`	Pérdida L1 suavizada (variante de la pérdida de Huber).
`torch.nn.CTCLoss(blank, reduction, zero_infinity)`	Pérdida de clasificación temporal conexionista, para tareas secuenciales como reconocimiento de voz.
`torch.nn.PoissonNLLLoss(log_input, full, size_average, reduce, reduction)`	Pérdida de verosimilitud logarítmica negativa de Poisson.
`torch.nn.GaussianNLLLoss(full, size_average, reduce, reduction)`	Pérdida de verosimilitud logarítmica negativa gaussiana.
`torch.nn.MarginRankingLoss(margin, size_average, reduce, reduction)`	Pérdida de ranking por margen, para aprender a ordenar.
`torch.nn.HingeEmbeddingLoss(margin, size_average, reduce, reduction)`	Pérdida de incrustación hinge, para aprendizaje de métricas.
`torch.nn.MultiLabelMarginLoss(size_average, reduce, reduction)`	Pérdida de margen multi-etiqueta.
`torch.nn.SoftMarginLoss(size_average, reduce, reduction)`	Pérdida de margen suave.
`torch.nn.MultiLabelSoftMarginLoss(weight, size_average, reduce, reduction)`	Pérdida de margen suave multi-etiqueta.
`torch.nn.CosineEmbeddingLoss(margin, size_average, reduce, reduction)`	Pérdida de incrustación por coseno, para aprendizaje de métricas.
`torch.nn.MultiMarginLoss(p, margin, weight, size_average, reduce, reduction)`	Pérdida de margen multiclase.
`torch.nn.TripletMarginLoss(margin, p, eps, swap, size_average, reduce, reduction)`	Pérdida de tripletes, para aprendizaje de métricas y aprendizaje contrastivo.
`torch.nn.TripletMarginWithDistanceLoss(distance_function, margin, swap, size_average, reduce, reduction)`	Pérdida de tripletes con función de distancia.

Funciones de distancia

Clase/Función	Descripción
`torch.nn.PairwiseDistance(p, eps, keepdim)`	Cálculo de distancia por pares.
`torch.nn.CosineSimilarity(dim, eps)`	Cálculo de similitud por coseno.

Capas paralelas (DataParallel)

Clase/Función	Descripción
`torch.nn.DataParallel(module, device_ids, output_device, dim)`	Paralelismo de datos, ejecuta el modelo en paralelo en múltiples GPUs.
`torch.nn.parallel.DistributedDataParallel(module, device_ids, broadcast_buffers, bucket_cap_mb, find_unused_parameters, gradient_as_bucket_view, static_graph)`	Paralelismo de datos distribuido, para entrenamiento distribuido multi-nodo.

Funciones utilitarias (nn.functional)

Función	Descripción
`torch.nn.functional.relu(input, inplace)`	Aplica la función de activación ReLU.
`torch.nn.functional.sigmoid(input)`	Aplica la función de activación Sigmoid.
`torch.nn.functional.tanh(input)`	Aplica la función de activación Tanh.
`torch.nn.functional.softmax(input, dim, dtype)`	Aplica la función de activación Softmax.
`torch.nn.functional.log_softmax(input, dim, dtype)`	Aplica la función de activación Log Softmax.
`torch.nn.functional.gelu(input)`	Aplica la función de activación GELU.
`torch.nn.functional.silu(input)`	Aplica la función de activación SiLU (Swish).
`torch.nn.functional.mish(input)`	Aplica la función de activación Mish.
`torch.nn.functional.hardswish(input)`	Aplica la función de activación Hardswish.
`torch.nn.functional.leaky_relu(input, negative_slope, inplace)`	Aplica la función de activación LeakyReLU.
`torch.nn.functional.elu(input, alpha, inplace)`	Aplica la función de activación ELU.
`torch.nn.functional.dropout(input, p, training, inplace)`	Aplica Dropout.
`torch.nn.functional.conv1d(input, weight, bias, stride, padding, dilation, groups)`	Operación de convolución unidimensional.
`torch.nn.functional.conv2d(input, weight, bias, stride, padding, dilation, groups)`	Operación de convolución bidimensional.
`torch.nn.functional.conv3d(input, weight, bias, stride, padding, dilation, groups)`	Operación de convolución tridimensional.
`torch.nn.functional.max_pool1d(input, kernel_size, stride, padding, dilation, return_indices)`	Agrupación máxima (max pooling) unidimensional.
`torch.nn.functional.max_pool2d(input, kernel_size, stride, padding, dilation, return_indices, ceil_mode)`	Agrupación máxima bidimensional.
`torch.nn.functional.avg_pool1d(input, kernel_size, stride, padding, ceil_mode, count_include_pad)`	Agrupación promedio unidimensional.
`torch.nn.functional.avg_pool2d(input, kernel_size, stride, padding, ceil_mode, count_include_pad)`	Agrupación promedio bidimensional.
`torch.nn.functional.linear(input, weight, bias)`	Transformación lineal (multiplicación de matrices).
`torch.nn.functional.cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction, label_smoothing)`	Calcula la pérdida de entropía cruzada.
`torch.nn.functional.mse_loss(input, target, size_average, reduce, reduction)`	Calcula la pérdida de error cuadrático medio.
`torch.nn.functional.l1_loss(input, target, size_average, reduce, reduction)`	Calcula la pérdida L1.
`torch.nn.functional.binary_cross_entropy(input, target, weight, size_average, reduce, reduction)`	Calcula la pérdida de entropía cruzada binaria.
`torch.nn.functional.nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction)`	Calcula la pérdida de verosimilitud logarítmica negativa.
`torch.nn.functional.huber_loss(input, target, delta, size_average, reduce, reduction)`	Calcula la pérdida de Huber.
`torch.nn.functional.batch_norm(input, running_mean, running_var, weight, bias, training, momentum, eps, track_running_stats)`	Operación de normalización por lotes.
`torch.nn.functional.layer_norm(input, normalized_shape, weight, bias, eps)`	Operación de normalización de capa.
`torch.nn.functional.group_norm(input, num_groups, weight, bias, eps)`	Operación de normalización por grupos.
`torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners, recompute_scale_factor)`	Interpolación (sobremuestreo/submuestreo).
`torch.nn.functional.grid_sample(input, grid, mode, padding_mode, align_corners)`	Muestreo de rejilla, para registro de imágenes y redes de transformación espacial.
`torch.nn.functional.affine_grid(theta, size, align_corners)`	Generación de rejilla afín, para redes de transformación espacial.
`torch.nn.functional.pixel_shuffle(input, upscale_factor)`	Reorganización de píxeles.
`torch.nn.functional.pixel_unshuffle(input, downscale_factor)`	Operación inversa de reorganización de píxeles.
`torch.nn.functional.pad(input, pad, mode, value)`	Operación de relleno (padding).
`torch.nn.functional.one_hot(tensor, num_classes)`	Convierte enteros a codificación one-hot.
`torch.nn.functional.embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)`	Operación de embedding.
`torch.nn.functional.cosine_similarity(x1, x2, dim, eps)`	Cálculo de similitud por coseno.
`torch.nn.functional.pairwise_distance(x1, x2, p, eps, keepdim)`	Cálculo de distancia por pares.

Funciones de utilidad (nn.utils)

Función	Descripción
`torch.nn.utils.clip_grad_norm_(parameters, max_norm, norm_type, error_if_nonfinite)`	Recorte de la norma del gradiente (operación in situ).
`torch.nn.utils.clip_grad_norm(parameters, max_norm, norm_type)`	Recorte de la norma del gradiente (no in situ).
`torch.nn.utils.clip_grad_value_(parameters, clip_value)`	Recorte de los valores del gradiente a un rango.
`torch.nn.utils.get_total_norm(parameters, norm_type)`	Calcula la norma total del gradiente.
`torch.nn.utils.weight_norm(module, name, dim)`	Aplica normalización de pesos a los parámetros del módulo.
`torch.nn.utils.remove_weight_norm(module, name)`	Elimina la normalización de pesos.
`torch.nn.utils.spectral_norm(module, name, n_power_iterations, eps, bias)`	Aplica normalización espectral a los parámetros del módulo.
`torch.nn.utils.remove_spectral_norm(module, name)`	Elimina la normalización espectral.
`torch.nn.utils.fuse_conv_bn_eval(conv, bn)`	Fusiona capa convolucional y capa de normalización por lotes (modo inferencia).
`torch.nn.utils.fuse_linear_bn_eval(linear, bn)`	Fusiona capa lineal y capa de normalización por lotes (modo inferencia).
`torch.nn.utils.skip_init(module_class, args, *kwargs)`	Omite la inicialización de parámetros.
`torch.nn.utils.parameters_to_vector(parameters)`	Aplana una lista de parámetros en un vector.
`torch.nn.utils.vector_to_parameters(vector, parameters)`	Remodela un vector en una lista de parámetros.

Inicialización de parámetros (nn.init)

Función	Descripción
`torch.nn.init.zeros_(tensor)`	Inicializa el tensor con ceros.
`torch.nn.init.ones_(tensor)`	Inicializa el tensor con unos.
`torch.nn.init.uniform_(tensor, a, b)`	Inicialización con distribución uniforme.
`torch.nn.init.normal_(tensor, mean, std)`	Inicialización con distribución normal.
`torch.nn.init.constant_(tensor, val)`	Inicialización con valor constante.
`torch.nn.init.eye_(tensor)`	Inicialización con matriz identidad (solo para matrices cuadradas 2D).
`torch.nn.init.dirac_(tensor)`	Inicialización delta de Dirac (preserva el número de canales de entrada).
`torch.nn.init.xavier_uniform_(tensor, gain)`	Inicialización uniforme de Xavier.
`torch.nn.init.xavier_normal_(tensor, gain)`	Inicialización normal de Xavier.
`torch.nn.init.kaiming_uniform_(tensor, a, mode, nonlinearity)`	Inicialización uniforme de Kaiming, adecuada para la activación ReLU.
`torch.nn.init.kaiming_normal_(tensor, a, mode, nonlinearity)`	Inicialización normal de Kaiming, adecuada para la activación ReLU.
`torch.nn.init.trunc_normal_(tensor, mean, std, a, b)`	Inicialización con distribución normal truncada.
`torch.nn.init.orthogonal_(tensor, gain)`	Inicialización ortogonal.
`torch.nn.init.sparse_(tensor, sparsity, std)`	Inicialización dispersa (mayormente ceros).
`torch.nn.init.calculate_gain(nonlinearity, param)`	Calcular el valor de ganancia de inicialización.

Funciones de utilidad RNN

Función	Descripción
`torch.nn.utils.rnn.PackedSequence`	Empaquetar secuencias para manejar secuencias de longitud variable.
`torch.nn.utils.rnn.pack_padded_sequence(input, lengths, batch_first, enforce_sorted)`	Empaquetar secuencias rellenadas.
`torch.nn.utils.rnn.pad_packed_sequence(input, batch_first, padding_value, total_length)`	Desempaquetar secuencias.
`torch.nn.utils.rnn.pad_sequence(sequences, batch_first, padding_value)`	Rellenar secuencias a la misma longitud.
`torch.nn.utils.rnn.pack_sequence(sequences, enforce_sorted)`	Empaquetar directamente una lista de secuencias.

Funciones de poda (Pruning)

Función	Descripción
`torch.nn.utils.prune.random_unstructured(module, name, amount)`	Poda no estructurada aleatoria.
`torch.nn.utils.prune.l1_unstructured(module, name, amount)`	Poda no estructurada L1.
`torch.nn.utils.prune.global_unstructured(parameters, pruning_method, amount)`	Poda no estructurada global.
`torch.nn.utils.prune.remove(module, name)`	Eliminar poda.
`torch.nn.utils.prune.is_pruned(module)`	Verificar si el módulo está podado.

Capa Flatten

Clase/Función	Descripción
`torch.nn.Flatten(start_dim, end_dim)`	Aplanar tensor, convierte un tensor multidimensional en bidimensional.
`torch.nn.Unflatten(dim, unflattened_size)`	Desaplanar, reforma un tensor unidimensional a multidimensional.

Ejemplos

import torch
import torch.nn as nn

# Definir una red neuronal simple
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

# Crear el modelo y la entrada
model = SimpleNet()
input = torch.randn(5, 10)
output = model(input)
print(output)

Ejemplo: clasificación de imágenes con CNN

import torch
import torch.nn as nn

class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
# Capa convolucional
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)

# Capa de pooling
self.pool = nn.MaxPool2d(2, 2)

# Normalización por lotes
self.bn1 = nn.BatchNorm2d(16)
self.bn2 = nn.BatchNorm2d(32)
self.bn3 = nn.BatchNorm2d(64)

# Función de activación
self.relu = nn.ReLU()

# Capa totalmente conectada
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):
# Conv -> BN -> ReLU -> Pool
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))))

# Flatten
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

# Crear el modelo
model = CNN()
print(model)

# Probar la propagación hacia adelante
input_tensor = torch.randn(1, 3, 32, 32)
output = model(input_tensor)
print("Output shape:", output.shape)

Ejemplo: clasificación de texto con 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__()

# Capa de embedding
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)

# Capa LSTM
self.lstm = nn.LSTM(
embedding_dim,
hidden_dim,
num_layers=num_layers,
batch_first=True,
bidirectional=True,
dropout=0.5
)

# Capa totalmente conectada
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)

# Empaquetar secuencias para manejar entradas de longitud variable
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)

# Desempaquetar
output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)

# Combinar los últimos estados ocultos de la dirección bidireccional
hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)

# Dropout y totalmente conectada
hidden = self.dropout(hidden)
output = self.fc(hidden)

return output

# Parámetros
vocab_size = 10000
embedding_dim = 128
hidden_dim = 256
num_layers = 2
output_dim = 5 # 5 clases

# Crear el modelo
model = LSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, output_dim)
print(model)

Ejemplo: uso del codificador Transformer

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__()

# Capa de embedding
self.embedding = nn.Linear(input_dim, d_model)

# Codificación posicional
self.positional_encoding = nn.Parameter(torch.randn(1, 1000, d_model) * 0.1)

# Capa del codificador Transformer
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model,
nhead=nhead,
dim_feedforward=dim_feedforward,
dropout=dropout,
batch_first=True
)

# Codificador Transformer
self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)

# Cabecera de clasificación
self.fc = nn.Linear(d_model, output_dim)
self.dropout = nn.Dropout(dropout)

def forward(self, x):
# Agregar codificación posicional
seq_len = x.size(1)
x = self.embedding(x) + self.positional_encoding[:, :seq_len, :]

# Codificación Transformer
x = self.transformer_encoder(x)

# Usar la salida de la primera posición para clasificación (similar al token CLS)
x = x[:, 0, :]

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

return x

# Parámetros
input_dim = 512
d_model = 512
nhead = 8
num_layers = 6
dim_feedforward = 2048
output_dim = 10
dropout = 0.1

# Crear el modelo
model = TransformerClassifier(input_dim, d_model, nhead, num_layers, dim_feedforward, output_dim, dropout)
print(model)

# Probar
x = torch.randn(32, 100, input_dim) # batch_size=32, seq_len=100
output = model(x)
print("Output shape:", output.shape) # (32, 10)

Si necesita información más detallada, puede consultarDocumentación oficial de PyTorch。

Otras extensiones