Last update for a while in this project....

WOP

Co-Authored-By: Ranuga-D <[email protected]>

Author: Programmer-RD-AI

.gitignore

@@ -158,4 +158,7 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+# local
 .history/
+wandb/

learning/sample_submission.csv renamed to ML/data/sample_submission.csv

@@ -5,7 +5,7 @@ class Loader(Dataset):
     def __init__(self, path: str, transform: bool = None) -> None:
         self.path = path
         self.transform = transform
-        self.data: pd.DataFrame = pd.read_csv(self.path).iloc[:5000]
+        self.data: pd.DataFrame = pd.read_csv(self.path)
 
     def __len__(self) -> int:
         return len(self.data)

learning/test.csv renamed to ML/data/test.csv

@@ -9,7 +9,7 @@ def __init__(
         test_split: float = 0.125,
         seed: int = 42,
         batch_size: int = 32,
-        **kwargs
+        **kwargs,
     ) -> None:
         super().__init__(**kwargs)
         self.X = self.data["text"].to_numpy()
@@ -27,36 +27,39 @@ def __init__(
             np.array(self.y_test),
         )
         self.batch_size = batch_size
-        # self.get_batches()
-        
+        self.get_batches()
 
     def get_batches(self):
         X = self.X_train if self.train else self.X_test
         y = self.y_train if self.train else self.y_test
         X_batches = []
         y_batches = []
-        for i in range(0, len(X), self.batch_size):
+        iterator = tqdm(
+            range(0, (round(len(X) / self.batch_size) - 1) * self.batch_size, self.batch_size)
+        )
+        for i in iterator:
             X_iter = X[i : i + self.batch_size]
             y_iter = y[i : i + self.batch_size]
-            X_batches.append(X_iter)
-            y_batches.append(y_iter)
+            new_X_iter = []
+            for j in X_iter:
+                new_X_iter.append(self.transform(j))
+            X_batches.append(new_X_iter)
+            y_batches.append([y_iter])
         if self.train:
-            self.X_train = F.to_tensor(X_batches, padding_value=1)
+            self.X_train = X_batches
             self.y_train = np.array(y_batches)
         else:
-            self.X_test = F.to_tensor(X_batches, padding_value=1)
+            self.X_test = X_batches
             self.y_test = np.array(y_batches)
 
-        print(X_batches[0], y_batches[0])
-
     def __getitem__(self, index) -> Tuple[torch.tensor, torch.tensor]:
         if self.train:
             return (
-                self.transform(self.X_train[index]),
+                self.X_train[index],
                 [self.y_train[index]],
             )
         return (
-            self.transform(self.X_test[index]),
+            self.X_test[index],
             [self.y_test[index]],
         )
 

learning/train.csv renamed to ML/data/train.csv

@@ -0,0 +1,9 @@
+from ML import *
+
+
+class ClearCache:
+    def __enter__(self):
+        torch.cuda.empty_cache()
+
+    def __exit__(self, *args):
+        torch.cuda.empty_cache()

ML/dataset/loader.py

@@ -24,10 +24,13 @@ def test(self):
         n = 0
         with torch.inference_mode():
             for X, y in self.test_dataloader:
-                X = torch.tensor(X).to("cuda").view(1, -1)
+                y = y[0]
+                X = F.to_tensor(X, padding_value=1).to("cuda")
                 y = torch.tensor(y).to("cuda")
                 preds = torch.argmax(torch.softmax(self.model(X), dim=1), dim=1)
-                results = classification_report(preds, y, class_names=["0", "1"])
+                results = classification_report(
+                    preds, y.view(-1, 1).squeeze(1), class_names=["0", "1"]
+                )
                 precision = results["weighted avg"]["precision"]
                 recall = results["weighted avg"]["recall"]
                 f1score = results["weighted avg"]["f1-score"]

ML/dataset/main_loaders.py

@@ -1,5 +1,6 @@
 from ML import *
 import torchtext.functional as F
+from ML.helper_functions.test import *
 
 
 class Train:
@@ -33,12 +34,12 @@ def train(self, run_name):
         for _ in iterator:
             torch.cuda.empty_cache()
             for i, (X, y) in enumerate(self.train_dataloader):
+                y = y[0]
                 torch.cuda.empty_cache()
-                X = torch.tensor(X).to("cuda").view(1, -1)
-                y = torch.tensor(y).to("cuda")
-                print(X.shape, y.shape)
+                X = F.to_tensor(X, padding_value=1).to("cuda")
+                y = torch.tensor(y).to(dtype=torch.long, device="cuda")
                 self.optimizer.zero_grad()
-                loss = self.criterion(self.model(X), y)
+                loss = self.criterion(self.model(X), y.view(-1, 1).squeeze(1))
                 loss.backward()
                 self.optimizer.step()
                 iterator.set_description(f"{i}/{len(self.train_dataloader)}")