-
each row represents an image. in a row the first column is the label and the rest are the pixel values. no, should i? what would be the advantage?
-
Yes the training datasets are all shuffled
-
I’ll show the network and also other stuff in case you’d like to see
Network:
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2),
nn.ReLU(inplace=True),
nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Dropout(p = 0.25),
nn.Conv2d(32, 64, kernel_size=3, stride=1,padding=1),
nn.BatchNorm2d(64),
nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(64),
nn.Conv2d(64, 128, kernel_size=3, stride=1,padding=1),
nn.Conv2d(128, 128, kernel_size=3, stride=1,padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Dropout(p = 0.25),
)
self.classifier = nn.Sequential(
nn.Dropout(p = 0.25),
nn.Linear(128 * 8 * 8, 512),
nn.ReLU(inplace=True),
nn.Dropout(p = 0.25),
nn.Linear(512, 23),
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
Dataloader:
class mydata(Dataset):
def __init__(self, file_path,
transform = transforms.Compose([transforms.ToPILImage(),
transforms.ToTensor(),
transforms.Normalize(mean=(0.5,), std=(0.5,))])
):
df = pd.read_csv(file_path)
self.X = df.iloc[:,1:].values.reshape((-1,33,33)).astype(np.uint8)[:,:,:,None]
self.y = torch.from_numpy(df.iloc[:,0].values)
self.transform = transform
def __len__(self):
return len(self.X)
def __getitem__(self, idx):
return self.transform(self.X[idx]), self.y[idx]
Train function:
def train(epoch, i):
model.train()
exp_lr_scheduler.step()
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
if (batch_idx + 1)% 100 == 0:
print('File: {} Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
i, epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
100. * (batch_idx + 1) / len(train_loader), loss.data))
print('Training data:')
evaluate(train_loader)
print('Test data:')
evaluate(test_loader)
Evaluate function:
def evaluate(data_loader):
model.eval()
loss = 0
correct = 0
with torch.no_grad():
for data, target in data_loader:
output = model(data)
loss += F.cross_entropy(output, target, size_average=False).data
pred = output.data.max(1, keepdim=True)[1]
correct += pred.eq(target.data.view_as(pred)).sum()
loss /= len(data_loader.dataset)
print('\nAverage loss: {:.4f}, Accuracy: {}/{} ({:.3f}%)\n'.format(
loss, correct, len(data_loader.dataset),
100. * correct / len(data_loader.dataset)))
The rest:
batch_size = 64
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.003)
criterion = nn.CrossEntropyLoss()
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
test_dataset = mydata('./data/1.csv', )
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,batch_size=batch_size, shuffle=False)