Kaggle/digit-recognizer-convolution-ver/main.ipynb

In [46]:

import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
import pandas as pd

In [47]:

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#train_df=pd.read_csv("/kaggle/input/competitions/digit-recognizer/train.csv")
#test_df=pd.read_csv("/kaggle/input/competitions/digit-recognizer/test.csv")
train_df=pd.read_csv("train.csv")
test_df=pd.read_csv("test.csv")

In [48]:

fig, ax = plt.subplots(nrows=2, ncols=2, sharex='all', sharey='all')
ax = ax.flatten()
for i in range(4):
    img = train_df.iloc[i][1:].to_numpy().reshape(28,28)
    # ax[i].imshow(img,cmap='Greys')
    ax[i].imshow(img)
    ax[i].set_title(f'{train_df.iloc[i][0]}')

In [49]:

class DatasetMnist(Dataset):
    def __init__(self,df):
        self.df=df
    def __len__(self):
        return len(self.df)
    def __getitem__(self, idx):
        item= {"Data": torch.tensor(self.df.iloc[idx][1:].to_numpy().reshape(28, 28),dtype=torch.float), "label": torch.tensor(self.df.iloc[idx][0],dtype=torch.long)}
        return item
batch_size =64
train_dataset = DatasetMnist(train_df)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

In [50]:

class MnistModule(nn.Module):
    '''
    (batch_size,1,28,28)
    '''
    def __init__(self):
        super(MnistModule, self).__init__()
        self.cov1=nn.Conv2d(in_channels=1, out_channels=16, kernel_size=7)
        self.cov2=nn.Conv2d(in_channels=16, out_channels=32, kernel_size=7)
        self.cov3=nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5)
        self.cov4=nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5)
        self.cov5=nn.Conv2d(in_channels=128, out_channels=256, kernel_size=5)
        self.linear1 = nn.Linear(in_features=4*4*256, out_features=128)
        self.linear2 = nn.Linear(in_features=128, out_features=10)
        self.relu = nn.ReLU()

    def forward(self,X):
        X=X.view(-1,1,28,28)
        X=self.cov5(self.cov4(self.cov3(self.cov2(self.cov1(X)))))
        X=X.view(-1,256*4*4)
        return self.linear2(self.relu(self.linear1(X)))

In [51]:

model = MnistModule()
model=model.to(device)
loss_func = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-4)
scheduler=torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)

In [ ]:

epochs = 30
for epoch in range(epochs):
    model.train()
    training_loss=0
    for batch in train_loader:
        optimizer.zero_grad()
        X = batch['Data']
        labels=batch['label']
        X=X.to(device)
        labels=labels.to(device)
        #print(model(X),'\n',labels)
        loss = loss_func(model(X),labels)
        loss.backward()
        optimizer.step()
        training_loss+=loss.item()
    scheduler.step()
    print(f"train_loss: {training_loss/len(train_loader)}")

In [ ]:

class DatasetMnistTest(Dataset):
    def __init__(self,df):
        self.df=df
    def __len__(self):
        return len(self.df)
    def __getitem__(self, idx):
        item= {"Data": torch.tensor(self.df.iloc[idx].to_numpy().reshape(28, 28),dtype=torch.float)}
        return item
test_dataset = DatasetMnistTest(test_df)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
all_preds = []
with torch.no_grad():
    for batch in test_loader:
        input_ids = batch['Data'].to(device)
        outputs = model(input_ids)
        preds = torch.argmax(outputs, dim=1)
        all_preds.extend(preds.cpu().numpy())
idd = range(1,len(all_preds)+1)
submission = pd.DataFrame({
    'ImageId':idd,
    'Label': all_preds
})
print(submission)
submission.to_csv('submission.csv', index=False)
print("Submission saved!")

In [ ]: