Estás leyendo la publicación: ¿Cómo usar Torchbearer para ajustar modelos ML con PyTorch?
Para los modelos basados en TensorFlow, tenemos Keras, que brinda acceso a toda la funcionalidad compleja del preprocesamiento, modelado y administración de devoluciones de llamada de TensorFlow en forma de API simple y de alto nivel. En este espacio similar para PyTorch, hay una biblioteca llamada Torchbearer que es básicamente una biblioteca de ajuste de modelos para los modelos de PyTorch y ofrece una métrica de alto nivel y una API de devolución de llamada que se puede usar en una variedad de aplicaciones. En este artículo, vamos a discutir esta biblioteca en detalle con sus implementaciones prácticas. También veremos cómo este marco ayuda a interpretar los modelos de aprendizaje automático ajustados. A continuación se presentan los puntos principales que vamos a cubrir en este artículo.
Tabla de contenido
- Necesidad de portador de la antorcha
- Diseño de Portador de la Antorcha
- Entrenamiento y visualización de una SVM
Primero comprendamos la necesidad de esta biblioteca.
Necesidad de portador de la antorcha
El ascenso meteórico del aprendizaje profundo ha generado una gran cantidad de marcos que permiten el procesamiento de tensores acelerado por hardware y la diferenciación automática. La programación diferenciable, una caracterización más amplia, ha tomado gradualmente su lugar. El ajuste es un método que consiste en maximizar los parámetros de un algoritmo diferenciable mediante descenso de gradiente. Pytorch es una biblioteca que ha ganado popularidad en los últimos años, gracias a su facilidad de uso para crear modelos que ejecutan operaciones de tensor no estándar.
Esto hace que PyTorch sea particularmente adecuado para proyectos de investigación en los que es posible que sea necesario cambiar o modificar cualquier aspecto de la definición de un modelo. Sin embargo, debido a que PyTorch se enfoca únicamente en el procesamiento de tensores y la diferenciación automatizada, carece de la API de ajuste de modelos de alto nivel que se encuentra en otros marcos como Keras. Además, tales bibliotecas rara vez permiten una programación diferenciable en su sentido más amplio.
Como resultado, el portador de la antorcha, una biblioteca de Python que respalda la investigación acelerando el proceso de ajuste del modelo mientras mantiene la transparencia y la generalidad. Una API de ajuste de modelos está en el corazón del portador de la antorcha, lo que permite una fácil personalización de todos los aspectos del proceso de ajuste. También ofrecemos una robusta API de métricas que le permite recopilar información continua y promedios. Finalmente, el portador de la antorcha tiene una serie de devoluciones de llamadas avanzadas.
Diseño de Portador de la Antorcha
La biblioteca de torchbearer está escrita en Python y usa PyTorch, torchvision y tqdm, con algunas funciones proporcionadas por NumPy, sci-kit-learn y tensor board. Las abstracciones centrales de Torchbearer son pruebas, devoluciones de llamadas y métricas.
Torchbearer es diferente de otras bibliotecas similares como ignite o tnt debido a estos conceptos de diseño. Ninguna biblioteca, por ejemplo, tiene una gran cantidad de devoluciones de llamada integradas para funciones sofisticadas. Además, tanto ignite como tnt utilizan una API basada en eventos para el ajuste de modelos, lo que hace que el código sea menos claro y legible para los humanos.
Analicemos brevemente sus principales API.
API de seguimiento
La clase Trial implementa una interfaz de ajuste de modelo PyTorch basada en el Prueba.ejecutar(…) método. también hay predecir(…) y evaluar(…) métodos para inferir modelos y evaluar modelos guardados. La clase Trial también tiene un método de dictado de estado que devuelve un diccionario que comprende los parámetros del modelo, el estado del optimizador y los estados de devolución de llamada, que se pueden almacenar y luego volver a cargar usando load_state_dict.
API de devolución de llamada
Durante el procedimiento de ajuste, la API de devolución de llamada define clases que se pueden usar para realizar una variedad de tareas. Un componente portador de la antorcha que se proporciona a cada devolución de llamada es el diccionario de estado mutable, que contiene las variables intermedias requeridas por la versión de prueba. Las devoluciones de llamadas pueden cambiar la naturaleza del proceso de adaptación en tiempo real como resultado de esto. Las devoluciones de llamada se pueden implementar como funciones decoradas utilizando la API de decorador.
API de métricas
La API de métricas utiliza un árbol para permitir que los datos fluyan de una métrica a un conjunto de elementos secundarios. Esto permite el cálculo de agregados como la media móvil o la desviación estándar. Ensamblar estas estructuras de datos puede ser difícil, por lo que Torchbearer incluye una API decoradora para hacerlo más fácil. El default_for_key(…) decorador permite hacer referencia a la métrica en la definición de prueba con una cadena.
Entrenamiento y visualización de SVM
En esta sección, intentaremos implementar la antorcha modelo SVM y entrenaremos, evaluaremos y visualizaremos el hiperplano utilizando la biblioteca Torchbearer. Este ejemplo está tomado del repositorio oficial de Torchbearer.
SVM busca el hiperplano con mayor margen de separación entre las clases de datos. Minimizamos lo siguiente para un SVM de margen blando donde x son nuestros datos:
Esto se puede expresar como una optimización sobre nuestros pesos w y el sesgo b, donde minimizamos la pérdida de bisagra mientras tomamos en cuenta un término de caída de peso de nivel 2.
Ahora, antes de modelar esto en PyTorch, primero instalemos e importemos la biblioteca Torchbearer.
# instalar e importar portador de antorcha !pip install -q portador de antorcha importar portador de antorcha
Después de esto, definamos la SVM y la función de pérdida de bisagra.
# define SVM import torch.nn como nn class LinearSVM(nn.Module): “””Máquina de vectores de soporte””” def __init__(self): super(LinearSVM, self).__init__() self.w = nn.Parameter( torch.randn(1, 2), require_grad=True) self.b = nn.Parameter(torch.randn(1), require_grad=True) def adelante(self, x): h = x.matmul(self.wt( )) + self.b return h # define la función de pérdida def bisagra_pérdida(y_pred, y_true): return torch.mean(torch.clamp(1 – y_pred.t() * y_true, min=0))
Ahora crearemos y normalizaremos los datos sintéticos que serán separados por los hiperplanos.
# cargar datos importar numpy como np de sklearn.datasets importar make_blobs X, Y = make_blobs(n_samples=1024, centers=2, cluster_std=1.2, random_state=1) X = (X – X.mean()) / X.std () Y[np.where(Y == 0)] = -1 X, Y = torch.FloatTensor(X), torch.FloatTensor(Y) # normalizar los datos delta = 0.01 x = np.arange(X[:, 0].min(), X[:, 0].max(), delta) y = np.arange(X[:, 1].min(), X[:, 1].max(), delta) x, y = np.meshgrid(x, y) xy = lista(mapa(np.ravel, [x, y]))
Ahora definiremos las devoluciones de llamada y la función de visualización.
# función de visualización de torchbearer import callbacks %matplotlib notebook import matplotlib import matplotlib.pyplot as plt @callbacks.on_step_training @callbacks.only_if(lambda state: state[torchbearer.BATCH] % 10 == 0) def dibujar_margen(estado): w = estado[torchbearer.MODEL].w[0].detach().to(‘cpu’).numpy() b = estado[torchbearer.MODEL].b[0].detach().to(‘cpu’).numpy() z = (w.dot(xy) + b).reshape(x.shape) z[np.where(z > 1.)] = 4z[np.where((z > 0.) & (z <= 1.))] = 3 z[np.where((z > -1.) & (z <= 0.))] = 2z[np.where(z <= -1.)] = 1 plt.clf() plt.dispersión(x=X[:, 0]y=X[:, 1]c=”negro”, s=10) plt.contourf(x, y, z, cmap=plt.cm.jet, alpha=0.5) fig.canvas.draw()
Nos gustaría usar una SVM de margen suave porque no sabemos si nuestros datos son linealmente separables. Para lograr esto, podemos usar la devolución de llamada L2WeightDecay en torchbearer. Debido a que solo usamos un mini lote en cada paso para aproximar el gradiente sobre todos los datos, todo este proceso se conoce como descenso de subgradiente. Ahora entrenemos el modelo y veamos el resultado.
# entrenar el modelo desde torchbearer import Trial from torchbearer.callbacks import L2WeightDecay, ExponentialLR import torch.optim as optim device=”cuda” if torch.cuda.is_available() else ‘cpu’ fig = plt.figure(figsize=(5, 5)) svm = LinearSVM() modelo = Trial(svm, optim.SGD(svm.parameters(), 0.1), bisagra_pérdida, [‘loss’]devoluciones de llamada =[draw_margin, ExponentialLR(0.999, step_on_batch=True), L2WeightDecay(0.01, params=[svm.w])]).to(dispositivo) model.with_train_data(X, Y, batch_size=32) model.run(epochs=50, detallado=1)
El resultado de la trama se puede guardar en el directorio de trabajo como se muestra a continuación.
#fig se guardará en el directorio de trabajo fig.savefig(‘svm.png’, bbox_inches=”tight”)
Y aquí están los hiperplanos de SVM que separan los datos sintéticos anteriores sin problemas.
Ultimas palabras
A lo largo de este artículo, hemos discutido Torchbearer, una biblioteca que simplifica el proceso de entrenamiento y ayuda en tipos diferenciales de programación para modelos PyTorch. A partir de la implementación práctica anterior, hemos visto cuán fácilmente podemos entrenar el modelo utilizando este marco. Un conjunto completo de devoluciones de llamadas integradas (como registro, disminución de peso y puntos de control de modelos) y una API métrica sólida son dos de las características clave de Torchbearer.
