I’m not too much into keras anymore. But I think it used to do some automated magic in terms of reducing learning rate if reaching a plateau.
But 15% in absolute difference is quite a lot.
And you can simplify your network code like this (there’s no need to handle all the layers manually during the forward pass):
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()

        features = []

        # convolutional layer (sees 150x150x3 image tensor)112,56,28
        features += [nn.Conv2d(3, 200, 3),
                     nn.Relu()]
        # convolutional layer (sees 16x16x16 tensor)
        features += [nn.Conv2d(200, 180, 3),
                     nn.Relu()]
        # convolutional layer (sees 8x8x32 tensor)
        features += [nn.Conv2d(180, 180, 3),
                     nn.Relu()]
        features += [nn.Conv2d(180, 140, 3),
                     nn.Relu()]
        features += [nn.Conv2d(140, 100, 3),
                     nn.Relu()]
        features += [nn.Conv2d(100, 50, 3),
                     nn.Relu()]
        # max pooling layer
        features += [nn.MaxPool2d(5, 5)]

        classification = []
        # linear layer (7 * 7 * 128 -> 1024)
        classification += [nn.Linear(800, 180),
                           nn.Relu()]
        # linear layer (500 -> 10)
        classification += [nn.Linear(180, 100),
                           nn.Relu()]
        classification += [nn.Linear(100, 50),
                           nn.Relu()]
        classification += [nn.Linear(50, 6),
                           nn.Relu()]        
        # dropout layer (p=0.5)
        classification += [nn.Dropout(0.5)]

        self.features = nn.Sequential(*features)
        self.classification = nn.Sequential(*classification)

    def forward(self, x):
        # add sequence of convolutional and max pooling layers
        x = self.features(x)
        x = x.view(-1, 800)
        x = self.classification(x)
        return x