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 [56]:

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.cov6=nn.Conv2d(in_channels=256, out_channels=512, kernel_size=4)
        self.linear1 = nn.Linear(in_features=1*1*512, 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.cov6(self.cov5(self.cov4(self.cov3(self.cov2(self.cov1(X))))))
        X=X.view(-1,512)
        return self.linear2(self.relu(self.linear1(X)))

In [57]:

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 [58]:

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)}")

---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
Cell In[58], line 14
     12     loss = loss_func(model(X),labels)
     13     loss.backward()
---> 14     optimizer.step()
     15     training_loss+=loss.item()
     16 scheduler.step()

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/lr_scheduler.py:166, in LRScheduler.__init__.<locals>.patch_track_step_called.<locals>.wrap_step.<locals>.wrapper(*args, **kwargs)
    164 opt = opt_ref()
    165 opt._opt_called = True  # type: ignore[union-attr]
--> 166 return func.__get__(opt, opt.__class__)(*args, **kwargs)

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/optimizer.py:526, in Optimizer.profile_hook_step.<locals>.wrapper(*args, **kwargs)
    521             raise RuntimeError(
    522                 f"{func} must return None or a tuple of (new_args, new_kwargs), but got {result}."
    523             )
    525 # pyrefly: ignore [invalid-param-spec]
--> 526 out = func(*args, **kwargs)
    527 self._optimizer_step_code()
    529 # call optimizer step post hooks

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/optimizer.py:81, in _use_grad_for_differentiable.<locals>._use_grad(*args, **kwargs)
     79     torch.set_grad_enabled(self.defaults["differentiable"])
     80     torch._dynamo.graph_break()
---> 81     ret = func(*args, **kwargs)
     82 finally:
     83     torch._dynamo.graph_break()

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/adam.py:248, in Adam.step(self, closure)
    236     beta1, beta2 = group["betas"]
    238     has_complex = self._init_group(
    239         group,
    240         params_with_grad,
   (...)    245         state_steps,
    246     )
--> 248     adam(
    249         params_with_grad,
    250         grads,
    251         exp_avgs,
    252         exp_avg_sqs,
    253         max_exp_avg_sqs,
    254         state_steps,
    255         amsgrad=group["amsgrad"],
    256         has_complex=has_complex,
    257         beta1=beta1,
    258         beta2=beta2,
    259         lr=group["lr"],
    260         weight_decay=group["weight_decay"],
    261         eps=group["eps"],
    262         maximize=group["maximize"],
    263         foreach=group["foreach"],
    264         capturable=group["capturable"],
    265         differentiable=group["differentiable"],
    266         fused=group["fused"],
    267         grad_scale=getattr(self, "grad_scale", None),
    268         found_inf=getattr(self, "found_inf", None),
    269         decoupled_weight_decay=group["decoupled_weight_decay"],
    270     )
    272 return loss

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/optimizer.py:151, in _disable_dynamo_if_unsupported.<locals>.wrapper.<locals>.maybe_fallback(*args, **kwargs)
    149     return disabled_func(*args, **kwargs)
    150 else:
--> 151     return func(*args, **kwargs)

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/adam.py:970, in adam(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, foreach, capturable, differentiable, fused, grad_scale, found_inf, has_complex, decoupled_weight_decay, amsgrad, beta1, beta2, lr, weight_decay, eps, maximize)
    967 else:
    968     func = _single_tensor_adam
--> 970 func(
    971     params,
    972     grads,
    973     exp_avgs,
    974     exp_avg_sqs,
    975     max_exp_avg_sqs,
    976     state_steps,
    977     amsgrad=amsgrad,
    978     has_complex=has_complex,
    979     beta1=beta1,
    980     beta2=beta2,
    981     lr=lr,
    982     weight_decay=weight_decay,
    983     eps=eps,
    984     maximize=maximize,
    985     capturable=capturable,
    986     differentiable=differentiable,
    987     grad_scale=grad_scale,
    988     found_inf=found_inf,
    989     decoupled_weight_decay=decoupled_weight_decay,
    990 )

File ~/.conda/envs/nn/lib/python3.11/site-packages/torch/optim/adam.py:545, in _single_tensor_adam(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, grad_scale, found_inf, amsgrad, has_complex, beta1, beta2, lr, weight_decay, eps, maximize, capturable, differentiable, decoupled_weight_decay)
    543         denom = (max_exp_avg_sqs[i].sqrt() / bias_correction2_sqrt).add_(eps)
    544     else:
--> 545         denom = (exp_avg_sq.sqrt() / bias_correction2_sqrt).add_(eps)
    547     param.addcdiv_(exp_avg, denom, value=-step_size)  # type: ignore[arg-type]
    549 # Lastly, switch back to complex view

KeyboardInterrupt: 

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 [ ]: