Introducción a las funciones comunes de la red neuronal Pytorch (actualizada continuamente...)

1. nn.Lineal()

En aprendizaje profundo,nn.Linear() es la clase utilizada en PyTorch para definir capas lineales. Se utiliza para construir la capa lineal del modelo de red neuronal y transformar linealmente los datos de entrada. El uso de parámetros de nn.Linear() es el siguiente:

nn.Linear(in_features, out_features, bias=True)

Los parámetros se explican a continuación:

in_features: el tamaño de la característica de entrada, es decir, el tamaño de la última dimensión del tensor de entrada. Por ejemplo, si la forma del tensor de entrada es (batch_size, in_features), entonces in_features es el tamaño de la característica de entrada.
out_features: el tamaño de la característica de salida, es decir, el tamaño de la última dimensión del tensor de salida de la capa lineal. Si la forma del tensor de entrada es (batch_size, in_features), entonces la forma del tensor de salida será (batch_size, out_features).
bias: si se debe utilizar el término de compensación. El valor predeterminado es Verdadero, lo que indica que la capa lineal contiene un término de sesgo. Si se establece en False, la capa lineal no contiene un término de sesgo.

Por ejemplo, supongamos que tenemos un tensor de entradax con forma (batch_size, input_size) y queremos ingresarlo en una capa lineal para su transformación. La forma del tensor de salida es (batch_size, output_size), puedes usar el siguiente código:

import torch.nn as nn

input_size = 10
output_size = 5
batch_size = 32

x = torch.randn(batch_size, input_size)

linear_layer = nn.Linear(input_size, output_size)
output = linear_layer(x)

print(output.shape)  # 输出: (32, 5)

En el código anterior, creamos un nn.Linear objetolinear_layer que establece el tamaño de las características de entrada en input_size , el tamaño de las entidades de salida se establece en output_size. Luego pasamos el tensor de entrada x a linear_layer y obtenemos el tensor de salida output. La forma del tensor de salida es (batch_size, output_size), que se ajusta a la definición de capa lineal.

Nota: al definir una capa lineal usandonn.Linear(), PyTorch inicializará automáticamente los pesos y los términos de sesgo de la capa lineal. Estas inicializaciones se pueden ajustar modificando linear_layer.weight y linear_layer.bias.

2. nn.Secuencial()

En PyTorch,nn.Sequential() es una clase contenedora que se utiliza para organizar y apilar múltiples capas de redes neuronales de forma secuencial. El uso de parámetros de nn.Sequential() es el siguiente:

nn.Sequential(*args)

Los parámetros se explican a continuación:

*args: un número variable de parámetros, cada parámetro es un objeto de capa (como nn.Linear, nn.Conv2d, etc.). Estos objetos de capa forman la estructura de red de nn.Sequential en secuencia.

Por ejemplo, supongamos que queremos construir una red neuronal simple, que incluya una capa lineal, una capa de función de activación y una capa de salida. Podemos usar nn.Sequential() para definir esta estructura de red:

import torch.nn as nn

input_size = 10
hidden_size = 20
output_size = 5
batch_size = 32

x = torch.randn(batch_size, input_size)

model = nn.Sequential(
    nn.Linear(input_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, output_size)
)

output = model(x)

print(output.shape)  # 输出: (32, 5)

En el código anterior, usamos nn.Sequential() para definir un modelo de red neuronal llamado model. El modelo consta de una capa lineal (tamaño de la característica de entrada input_size, tamaño de la característica de salida hidden_size), una capa de función de activación ReLU y una capa lineal (el tamaño de la característica de entrada es hidden_size, y el tamaño de la característica de salida es output_size). Pasamos el tensor de entrada x a model y obtenemos el tensor de salida output.

Connn.Sequential(), podemos definir fácilmente un modelo de red neuronal que contenga múltiples capas sin especificar manualmente las dimensiones de entrada y salida de cada capa. PyTorch inferirá automáticamente el tamaño de entrada de la siguiente capa en función del tamaño de salida de la capa anterior.

3. nn.BatchNorm2d()

En aprendizaje profundo,nn.BatchNorm2d() es una clase en PyTorch que se utiliza para definir una capa de normalización por lotes 2D. Se utiliza para realizar operaciones de normalización por lotes en redes neuronales para acelerar el entrenamiento del modelo y mejorar la capacidad de generalización del modelo. El uso de parámetros de nn.BatchNorm2d() es el siguiente:

nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

Los parámetros se explican a continuación:

num_features: Introduzca el número de funciones o el número de canales. Para capas convolucionales 2D, num_features suele ser igual al número de canales de salida de la capa convolucional.
eps (opcional): Valor pequeño para estabilidad numérica. El valor predeterminado es 1e-05.
momentum (opcional): Momento utilizado para calcular la media y la varianza. El valor predeterminado es 0.1.
affine (opcional): valor booleano, controla si se agregan parámetros de transformación afines que se pueden aprender. Si True, se aprenden y aplican el factor de escala y el término de sesgo. El valor predeterminado es True.
track_running_stats (opcional): valor booleano que controla si las estadísticas globales de todo el conjunto de datos se rastrean y actualizan durante el entrenamiento. El valor predeterminado es True. Durante la inferencia, se recomienda configurarlo en False para utilizar las estadísticas de cada minilote.

Por ejemplo, supongamos que tenemos un tensor de entradax con forma (batch_size, num_channels, height, width) y queremos realizar una normalización por lotes después de la capa convolucional Para operar, puede utilice el siguiente código:

import torch.nn as nn

batch_size = 32
num_channels = 64
height = 28
width = 28

x = torch.randn(batch_size, num_channels, height, width)

bn_layer = nn.BatchNorm2d(num_channels)
output = bn_layer(x)

print(output.shape)  # 输出: (32, 64, 28, 28)

En el código anterior, creamos un nn.BatchNorm2d objetobn_layer con el número de características de entrada establecidas en num_channels. Luego pasamos el tensor de entrada x a bn_layer y obtenemos el tensor de salida output. El tensor de salida tiene la misma forma que el tensor de entrada (batch_size, num_channels, height, width), correspondiente a las características de entrada de la capa de normalización por lotes.

La capa de normalización por lotes calcula y actualiza automáticamente la media y la varianza de cada dimensión de característica durante el proceso de entrenamiento y utiliza estas estadísticas para las operaciones de normalización. Durante el proceso de capacitación, la capa de normalización por lotes también puede controlar si se actualizan las estadísticas globales de todo el conjunto de datos a través del parámetro track_running_stats.

4. laboratorio

LabML (Lab Meta Learning) es una herramienta de gestión y seguimiento de experimentos de código abierto diseñada para ayudar a los investigadores a organizar y registrar mejor los experimentos de aprendizaje profundo. LabML proporciona un conjunto de funciones simple pero poderoso para rastrear todos los aspectos de un experimento, incluida la configuración de hiperparámetros, la estructura del modelo, el proceso de capacitación y las métricas de resultados.

LabML proporciona bibliotecas de Python y herramientas relacionadas que se pueden utilizar junto con marcos de aprendizaje profundo comunes (como PyTorch, TensorFlow). Al utilizar LabML, puede registrar fácilmente la configuración y los parámetros del experimento, realizar un seguimiento de las métricas y registros durante el proceso de capacitación y visualizar los resultados experimentales. LabML también admite funciones como capacitación distribuida, comparación de experimentos y puntos de control automáticos.

LabML está diseñado para simplificar el proceso de gestión y reproducción experimental, proporcionar un mecanismo consistente de registro y seguimiento experimental y ayudar a los investigadores a organizar y compartir mejor los experimentos. Su objetivo es mejorar la eficiencia y reproducibilidad de la investigación sobre aprendizaje profundo.

Puede encontrar más detalles, ejemplos y documentación sobre LabML en su página de GitHub (https://github.com/lab-ml/labml).

4.1 laboratorioml.experimento()

labml.experiment()es una función en la biblioteca LabML que crea un objeto de experimento para registrar y administrar la configuración, los parámetros, las métricas y los resultados de un experimento de aprendizaje profundo.

LabML es una herramienta de código abierto para el seguimiento y la gestión de experimentos, diseñada para ayudar a los investigadores a organizar y documentar mejor los experimentos de aprendizaje profundo. Proporciona un conjunto de funciones simple pero poderoso para rastrear todos los aspectos de un experimento, incluida la configuración de hiperparámetros, la estructura del modelo, el proceso de capacitación y las métricas de resultados.

labml.experiment()Las funciones son el punto de entrada para crear objetos experimentales de LabML. Al llamar a esta función, puede crear un objeto de experimento y utilizar sus métodos y propiedades para el seguimiento y registro del experimento.

A continuación se muestran algunos ejemplos de uso comunes:

import labml

# 创建实验对象
experiment = labml.experiment()

# 记录超参数
experiment.configs({
    
    
    'learning_rate': 0.001,
    'batch_size': 32,
    'num_epochs': 10
})

# 记录模型结构
experiment.add_pytorch_graph(model)

# 记录训练循环
with experiment.train():
    for epoch in range(num_epochs):
        for batch in data_loader:
            # 执行训练步骤

            # 记录训练指标
            experiment.log_metrics({
    
    'loss': loss.item()})

# 记录验证循环
with experiment.validation():
    for batch in validation_loader:
        # 执行验证步骤

        # 记录验证指标
        experiment.log_metrics({
    
    'accuracy': accuracy.item()})

# 记录测试循环
with experiment.test():
    for batch in test_loader:
        # 执行测试步骤

        # 记录测试指标
        experiment.log_metrics({
    
    'accuracy': accuracy.item()})

# 结束实验
experiment.close()

Al usarlabml.experiment() para crear objetos experimentales, puede aprovechar las funciones proporcionadas por LabML para registrar y rastrear todos los aspectos del experimento y obtener registros detallados e información de resultados durante el proceso. experimento. . Puede personalizar la estructura y el contenido de grabación del experimento según sus necesidades reales.

Tenga en cuenta que el código de muestra anterior es solo para fines de demostración y el uso real puede variar según sus necesidades específicas y su entorno experimental. Puede consultar la documentación oficial y el código de muestra de LabML para obtener instrucciones y ejemplos de uso más detallados.

4.1.1 labml.experimento.create()

En LabML, labml.experiment.create() es una función utilizada para crear experimentos. Le permite definir varios parámetros y configuraciones de sus experimentos. El uso de parámetros de labml.experiment.create() es el siguiente:

labml.experiment.create(name=None, comment=None, writers=None, check_git_status=True, include_modules=None)

Los parámetros se explican a continuación:

name (opcional): el nombre del experimento, utilizado para identificarlo. Si no se especifica, el valor predeterminado es None.
comment (opcional): Una breve nota o descripción del experimento. Si no se especifica, el valor predeterminado es None.
writers (opcional): Escritores para registrar resultados experimentales. Puede ser un único objeto de escritura o una lista de objetos de escritura. Si no se especifica, el valor predeterminado es None, lo que significa que los resultados experimentales no se registrarán.
check_git_status (opcional): valor booleano que indica si se debe verificar el estado de Git. Si True, verifica el estado del repositorio de Git, incluidos los cambios no confirmados y las confirmaciones no enviadas, al crear el experimento. Si el repositorio de Git está en un estado sucio, se genera una excepción. Si False, el estado de Git no se verifica. El valor predeterminado es True.
include_modules (opcional): Lista de módulos a incluir en el experimento. Puede ser un solo módulo o una lista de módulos. El valor predeterminado es None, lo que significa que se utilizan todos los módulos.

A modo de ejemplo, aquí se muestra un ejemplo de usolabml.experiment.create() para crear un experimento:

import labml

# 创建实验
labml.experiment.create(
    name='my_experiment',
    comment='This is my experiment',
    writers='tensorboard'
)

# 进行实验运行
for i in range(10):
    # 运行实验步骤
    # ...

    # 记录实验结果
    labml.logger.log('loss', i)

En el código anterior, creamos un experimento llamado usando labml.experiment.create(). También proporcionamos una breve nota que describe el experimento. Se utiliza el parámetro , lo que indica que se utiliza el escritor TensorBoard para registrar los resultados experimentales. my_experimentwriters='tensorboard'

En el ciclo del experimento en ejecución, podemos usar la funciónlabml.logger.log() para registrar los resultados experimentales. En este ejemplo, registramos i como el valor de loss cada vez que recorre el ciclo.

LabML proporciona varios escritores, como TensorBoard, CSV, MongoDB, etc. Puede elegir el escritor apropiado según sus necesidades y usarlo como el writers parámetro Pasado alabml.experiment.create()

5. labml_nn

labml_nn es una biblioteca de Python. Es parte del proyecto LabML, una biblioteca de herramientas para construir redes neuronales y realizar experimentos de aprendizaje profundo. LabML es un proyecto de código abierto que tiene como objetivo proporcionar herramientas y marcos para la experimentación y el desarrollo del aprendizaje automático.

labml_nn proporciona una serie de modelos avanzados de redes neuronales y herramientas de capacitación diseñadas para simplificar el proceso de experimentos de aprendizaje profundo. Se basa en el marco de aprendizaje profundo de PyTorch y proporciona algunas características y herramientas adicionales para hacer que la definición, el entrenamiento y la evaluación del modelo sean más convenientes y escalables.

Las funciones de labml_nn incluyen, entre otras:

Construcción de modelos: labml_nn proporciona un módulo de construcción de modelos avanzado que permite a los usuarios definir modelos complejos de redes neuronales utilizando un código conciso.
Bucle de entrenamiento: labml_nn proporciona una herramienta de bucle de entrenamiento flexible que puede administrar fácilmente el proceso de entrenamiento del modelo, incluida la carga de datos por lotes, la propagación hacia adelante, el cálculo de pérdidas, la propagación hacia atrás y la actualización de parámetros, etc.
Monitoreo de capacitación: labml_nn proporciona herramientas para el monitoreo en tiempo real del proceso de capacitación, incluidas curvas de pérdida, seguimiento de métricas y visualización en tiempo real.
Registros de experimentos: labml_nn puede ayudar a los usuarios a registrar y administrar la configuración, los parámetros, los indicadores y los resultados de los experimentos de aprendizaje profundo para facilitar la reproducción de los experimentos y el análisis de los resultados.

labml_nn es una biblioteca liviana y fácil de usar adecuada para una variedad de tareas y proyectos de aprendizaje profundo. Tiene buena escalabilidad y flexibilidad y se puede personalizar y ampliar según las necesidades del usuario.

Puede obtener más detalles y ejemplos de uso sobre labml_nn y otros módulos relacionados visitando la página GitHub del proyecto LabML (https://github.com/lab-ml/labml).