[BUG] swanlab.log->step paramter bug

[Zeyi-Lin]

🐛 Bug description [Please make everyone to understand it]

when set step paramter, if value is not increase by 1, 2, 5 ...., will accur show problem:

code:

import swanlab

swanlab.init()

for i in range(100):
    swanlab.log({"loss": i}, step=i + 100)

🚑 Any additional [like screenshots]

• SwanLab Version:v0.1.6

• Platform:MacOS

[Zeyi-Lin]

Similar problems also include this type:

bug is because the number of X-axis coordinates exceeds the limit.

[SAKURA-CAT]

In fact, this bug is an internal problem of the line chart component.

[Zeyi-Lin]

补充testcode:

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

import swanlab

# Make logging

# Plugin testing number for epoch, batch size and learning rate
epoch = 10
batch_size = 64
Learning_rate = 0.01

swanlab.init(
    experiment_name="LeNet",
    config={"epoch": epoch, "batch_size": batch_size, "Learning_rate": Learning_rate},
)

# Make sure to train on GPU
device = torch.device("mps")
print(device)


class Lenet5(nn.Module):  # Define this network
    def __init__(self):  # initialization
        super(Lenet5, self).__init__()
        ## Convolutional 1
        self.conv1 = nn.Conv2d(
            in_channels=1, out_channels=6, kernel_size=5, padding=2
        )  # input size=(1*28*28), output size=(6*28*28)
        # input 1 image channel, output 6 channels, 5*5 squre convolution
        # Output=((input-kernel_size+2*padding)/stride)+1
        ## Subsampling layer 2
        self.samp2 = nn.MaxPool2d(kernel_size=2, stride=2)  # output size=(6*14*14)
        ## Convolutional layer 3
        self.conv3 = nn.Conv2d(
            in_channels=6, out_channels=16, kernel_size=5
        )  # input size=(16*10*10), output size=(16*5*5)
        ## Subsampling layer 4
        self.samp4 = nn.MaxPool2d(kernel_size=2, stride=2)
        ## Convolutional layer 5 or Full connection layer 5 (16*5*5,120)
        self.conv5 = nn.Conv2d(in_channels=16, out_channels=120, kernel_size=5)

        ## activate function
        self.relu = nn.ReLU()

        self.flatten = nn.Flatten()
        ## Full connection layer 6
        self.f6 = nn.Linear(120, 84)
        self.output = nn.Linear(84, 10)

    # Define the progress of forward propagation, output=x
    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.samp2(x)
        x = self.relu(self.conv3(x))
        x = self.samp4(x)
        x = self.conv5(x)
        x = self.flatten(x)
        x = self.f6(x)
        x = self.output(x)
        return x


# Define the network defined above
net = Lenet5().to(device)


# Loading and normalizing Mnist dataset
transform = transforms.ToTensor()  # Define data preprocessing methods to convert images into tensors
trainset = torchvision.datasets.MNIST(root="./data", train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(
    trainset,
    batch_size=batch_size,
    shuffle=True,
)
testset = torchvision.datasets.MNIST(root="./data", train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(
    testset,
    batch_size=batch_size,
    shuffle=False,
)

# Define a loss function and optimizer
criterion = nn.CrossEntropyLoss()  # Cross Entropy Loss function
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)  # Stoochastic Gradient Descent

# Loop over the datast to train the network
iteration_num = 0
for epoch in range(epoch):
    running_loss = 0.0
    for i, data in enumerate(trainloader):
        iteration_num += 1
        # Get the inputs
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)

        # Clear the existing gradients buffers
        optimizer.zero_grad()

        outputs = net(inputs)  # Forward
        loss = criterion(outputs, labels)
        loss.backward()  # Backpropagate the error
        optimizer.step()  # Does the update

        # print statistics
        running_loss += loss.item()
        if i % 100 == 99:  # print every 100 mini-batches
            print("[%d,%d] loss = %.03f" % (epoch + 1, i + 1, running_loss / 100))
            swanlab.log({"epoch": epoch + 1}, iteration_num)
            swanlab.log({"loss": running_loss / 100}, iteration_num)
            running_loss = 0.0

    # Test the accuracy after every epoch
    with torch.no_grad():
        correct = 0
        total = 0
        for data in testloader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum()
        print("The accuracy of %d epoch is %d%%" % (epoch + 1, (100 * correct / total)))
        swanlab.log({"accuracy": (100 * correct / total)}, iteration_num)

    torch.save(net, f"net_{epoch}.pth")