Esta entrada es parte del curso de Deep learning con PyTorch.
TensorBoard es una de las herramientas más potentes de visualización en machine learning. Permite realizar funciones interesantes como:
- Visualizar métricas como la pérdida y la exactitud.
- Visualizar los grafos creados por el modelo.
- Ver histógramas de los parámetros y como cambian en el tiempo.
- Ver imágenes y datos de de audio o texto.
PyTorch permite trabajar con TensorBoard. En la versión PyTorch 1.1.0, TensorBoard se soportaba de manera experimental pero desde la versión PyTorch 1.2.0 ya está integrada plenamente.
Primero, tendremos que instalar la extensión de Tensorboard para notebooks y cargarla, como se ve a continuación.
!pip install -q tf-nightly-2.0-preview #Carga la extension %load_ext tensorboard
Después, crearemos el directorio donde guardaremos los logs que almacene TensorBoard.
import os logs_base_dir = "runs" os.makedirs(logs_base_dir, exist_ok=True)
Creamos una clase con varias capas de redes neuronales, instanciamos un objeto de esta clase y lo optimizamos con autograd.
Para usar TensorBoard, primero creamos un objeto SummaryWriter() que permite crear un archivo de eventos en el directorio indicado (por defecto sería “runs”) y añadir eventos en el archivo.
Después, le indicamos qué eventos guardar en el archivo creado. En este caso, vamos a registrar dos tipos de eventos o logs:
- El grafo creado por el modelo, lo que hará con writer.add_graph(net,input).
- La pérdida en cada iteración, que la registraremos con writer.add_scalar(‘training loss’,loss.data).
import torch import torch.nn as nn from torch.utils.tensorboard import SummaryWriter from torch.autograd import Variable input_size= 10 output_size= 1 hidden_size= 50 train_size= 5000 batch_size=10 num_epochs= 10 learning_rate =1e-3 writer = SummaryWriter() len=int(train_size/batch_size) input=torch.normal(0, 1, size=(train_size, input_size)) input=input/input.max() linear1=nn.Linear(input_size, output_size) with torch.no_grad(): label=linear1(input) class Net(nn.Module): def __init__(self, input_size, hidden_size, num_classes): super(Net, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.relu1 = nn.ReLU() self.fc2 = nn.Linear(hidden_size, output_size) def forward(self, x): out = self.fc1(x) out = self.relu1(out) out = self.fc2(out) return out net = Net(input_size, hidden_size, output_size) criterion = nn.L1Loss() optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) for epoch in range(num_epochs): for i in range(len): optimizer.zero_grad() input1=input[i*batch_size:(i+1)*batch_size] label1=label[i*batch_size:(i+1)*batch_size] output = net(input1) loss = criterion(output, label1) loss.backward() optimizer.step() writer.add_scalar('training loss',loss.data) writer.add_graph(net,input) writer.close()
Ahora llamaremos a Tensorboard.
%tensorboard --logdir {logs_base_dir}
Reusing TensorBoard on port 6006 (pid 187), started 0:08:49 ago. (Use '!kill 187' to kill it.)
Vemos el grafo creado.

Y ahora vemos como evoluciona la función de coste o pérdida en cada iteración.

Por último, borraremos el directorio creado para almacenar el archivo de logs.
!rm -rf runs
Thanks for sharing, this is a fantastic article post. Thanks Again. Really Cool. Tammie Vaughan Pettiford