Initial commit

ML/Kaggles/SantanderTransaction/dataset.py

@@ -0,0 +1,23 @@
+import pandas as pd
+import torch
+from torch.utils.data import TensorDataset
+from torch.utils.data.dataset import random_split
+from math import ceil
+
+def get_data():
+    train_data = pd.read_csv("new_shiny_train.csv")
+    y = train_data["target"]
+    X = train_data.drop(["ID_code", "target"], axis=1)
+    X_tensor = torch.tensor(X.values, dtype=torch.float32)
+    y_tensor = torch.tensor(y.values, dtype=torch.float32)
+    ds = TensorDataset(X_tensor, y_tensor)
+    train_ds, val_ds = random_split(ds, [int(0.999*len(ds)), ceil(0.001*len(ds))])
+
+    test_data = pd.read_csv("new_shiny_test.csv")
+    test_ids = test_data["ID_code"]
+    X = test_data.drop(["ID_code"], axis=1)
+    X_tensor = torch.tensor(X.values, dtype=torch.float32)
+    y_tensor = torch.tensor(y.values, dtype=torch.float32)
+    test_ds = TensorDataset(X_tensor, y_tensor)
+
+    return train_ds, val_ds, test_ds, test_ids

ML/Kaggles/SantanderTransaction/train.py

@@ -0,0 +1,55 @@
+import torch
+from sklearn import metrics
+from tqdm import tqdm
+import torch.nn as nn
+import torch.optim as optim
+from utils import get_predictions
+from dataset import get_data
+from torch.utils.data import DataLoader
+import torch.nn.functional as F
+
+class NN(nn.Module):
+    def __init__(self, input_size, hidden_dim):
+        super(NN, self).__init__()
+        self.bn = nn.BatchNorm1d(input_size)
+        self.fc1 = nn.Linear(2, hidden_dim)
+        self.fc2 = nn.Linear(input_size//2*hidden_dim, 1)
+
+    def forward(self, x):
+        N = x.shape[0]
+        x = self.bn(x)
+        orig_features = x[:, :200].unsqueeze(2) # (N, 200, 1)
+        new_features = x[:, 200:].unsqueeze(2) # (N, 200, 1)
+        x = torch.cat([orig_features, new_features], dim=2) # (N, 200, 2)
+        x = F.relu(self.fc1(x)).reshape(N, -1) # (N, 200*hidden_dim)
+        return torch.sigmoid(self.fc2(x)).view(-1)
+
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+model = NN(input_size=400, hidden_dim=100).to(DEVICE)
+optimizer = optim.Adam(model.parameters(), lr=2e-3, weight_decay=1e-4)
+loss_fn = nn.BCELoss()
+train_ds, val_ds, test_ds, test_ids = get_data()
+train_loader = DataLoader(train_ds, batch_size=1024, shuffle=True)
+val_loader = DataLoader(val_ds, batch_size=1024)
+test_loader = DataLoader(test_ds, batch_size=1024)
+
+for epoch in range(20):
+    probabilities, true = get_predictions(val_loader, model, device=DEVICE)
+    print(f"VALIDATION ROC: {metrics.roc_auc_score(true, probabilities)}")
+
+    for batch_idx, (data, targets) in enumerate(train_loader):
+        data = data.to(DEVICE)
+        targets = targets.to(DEVICE)
+
+        # forward
+        scores = model(data)
+        loss = loss_fn(scores, targets)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+from utils import get_submission
+get_submission(model, test_loader, test_ids, DEVICE)
+
+

ML/Kaggles/SantanderTransaction/utils.py

@@ -0,0 +1,39 @@
+import pandas as pd
+import numpy as np
+import torch
+
+def get_predictions(loader, model, device):
+    model.eval()
+    saved_preds = []
+    true_labels = []
+
+    with torch.no_grad():
+        for x,y in loader:
+            x = x.to(device)
+            y = y.to(device)
+            scores = model(x)
+            saved_preds += scores.tolist()
+            true_labels += y.tolist()
+
+    model.train()
+    return saved_preds, true_labels
+
+def get_submission(model, loader, test_ids, device):
+    all_preds = []
+    model.eval()
+    with torch.no_grad():
+        for x,y in loader:
+            print(x.shape)
+            x = x.to(device)
+            score = model(x)
+            prediction = score.float()
+            all_preds += prediction.tolist()
+
+    model.train()
+
+    df = pd.DataFrame({
+        "ID_code" : test_ids.values,
+        "target" : np.array(all_preds)
+    })
+
+    df.to_csv("sub.csv", index=False)