Add input

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+DeBERTaV3/input/*.csv filter=lfs diff=lfs merge=lfs -text

DeBERTaV3.py

@@ -0,0 +1,97 @@
+import numpy as np
+import pandas as pd
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from fastai.text.all import *
+from sklearn.model_selection import train_test_split
+
+from torch.utils.data import Dataset
+
+torch.serialization.add_safe_globals(['L'])
+
+class QuestionDataset(Dataset):
+    def __init__(self, X, y, tokenizer):
+        self.text = X
+        self.targets = y
+        self.tok = tokenizer
+    
+    def __len__(self):
+        return len(self.text)
+    
+    def __getitem__(self, idx):
+        
+        text = self.text[idx]
+        targ = self.targets[idx]
+        
+        return self.tok(text, padding='max_length', 
+                        truncation=True,
+                        max_length=30,
+                        return_tensors="pt")["input_ids"][0], tensor(targ)
+    
+    def new_empty(self):
+        return QuestionDataset([], [], self.tok)
+
+class ModelLoader:
+    def __init__(self):
+        self.path = "DeBERTaV3/input/"
+        self.train_df = pd.read_csv(self.path + "cleaned_train.csv")
+        self.test_df = pd.read_csv(self.path + "cleaned_test.csv")
+
+        self.tokenizer = AutoTokenizer.from_pretrained('microsoft/deberta-v3-base')
+        self.df = self.train_df
+        
+        # Train/validation split
+        self.X_train, self.X_valid, self.y_train, self.y_valid = train_test_split(
+            self.df["question_text"].tolist(),
+            self.df["target"].tolist(),
+            stratify=self.df["target"],
+            test_size=0.01
+        )
+
+        self.train_ds = QuestionDataset(self.X_train, self.y_train, self.tokenizer)
+        self.valid_ds = QuestionDataset(self.X_valid, self.y_valid, self.tokenizer)
+
+        self.train_dl = DataLoader(self.train_ds, batch_size=256)
+        self.valid_dl = DataLoader(self.valid_ds, batch_size=512)
+        self.dls = DataLoaders(self.train_dl, self.valid_dl)
+
+        self.bert = AutoModelForSequenceClassification.from_pretrained('microsoft/deberta-v3-base').train()
+
+        self.classifier = nn.Sequential(
+            nn.Linear(768, 1024),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(1024, 2)
+        )
+
+        self.bert.classifier = self.classifier
+
+        class BertClassifier(nn.Module):
+            def __init__(self, bert):
+                super(BertClassifier, self).__init__()
+                self.bert = bert
+            
+            def forward(self, x):
+                return self.bert(x).logits
+
+        self.model = BertClassifier(self.bert)
+
+        # Calculate class weights
+        n_0 = (self.train_df["target"] == 0).sum()
+        n_1 = (self.train_df["target"] == 1).sum()
+        n = n_0 + n_1
+
+        self.class_weights = tensor([n / (n + n_0), n / (n + n_1)])
+        self.learn = Learner(self.dls, self.model,
+                             loss_func=nn.CrossEntropyLoss(weight=self.class_weights),
+                             metrics=[accuracy, F1Score()]).to_fp16()
+        try:
+            # First attempt: Try loading with weights_only=True
+            self.learn.load('fastai_QIQC-deberta-v3', strict=False, weights_only=True)
+        except Exception as e:
+            print(f"Warning: Could not load with weights_only=True. Falling back to default loading. Error: {e}")
+            # Second attempt: Fall back to regular loading if the first attempt fails
+            self.learn.load('fastai_QIQC-deberta-v3', strict=False)
+
+    def get_learner(self):
+        return self.learn

DeBERTaV3/input/cleaned_test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c2a623a1d168b9b2194021ee7f0cadbe02b91ff1fef44ecf2359ef571e7f12c
+size 35730197

DeBERTaV3/input/cleaned_train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f87965feb2d3d9a46af19a4ebc645e951afb86219d7f7bfe8b5a6e2e06a7980
+size 126708414

app.py

@@ -12,6 +12,7 @@ from transformers import AutoTokenizer, AutoModelForSequenceClassification
 from fastai.vision.all import *
 from fastai.text.all import *
 from torch.utils.data import Dataset
+from DeBERTaV3 import ModelLoader
 
 model_lst = ["DeBERTaV3", "BiLSTM"]
 
@@ -72,31 +73,11 @@ class QuestionDataset(Dataset):
     def new_empty(self):
         return QuestionDataset([], [], self.tok)
     
-learn_infer = load_learner('DeBERTaV3/models/fastai_QIQC-deberta-v3.pkl', cpu=True)
+model_loader = ModelLoader()
+learner = model_loader.get_learner()
 print("Learner loaded successfully.")
 
-# ## define the model
-# bert = AutoModelForSequenceClassification.from_pretrained('microsoft/deberta-v3-base').train()
-
-# classifier = nn.Sequential(
-#     nn.Linear(768, 1024),
-#     nn.ReLU(),
-#     nn.Dropout(0.5),
-#     nn.Linear(1024, 2)
-# )
-
-# bert.classifier = classifier
-
-# class BertClassifier(Module):
-#     def __init__(self, bert):
-#         self.bert = bert
-#     def forward(self, x):
-#         x = self.bert(x)
-#         return x.logits
-
-# model = BertClassifier(bert)
-
-## Recreate the DataLoader
+## DataLoader
 class TestDS:
     def __init__(self, tensors):
         self.tensors = tensors
@@ -118,7 +99,7 @@ class DeBERTaV3Model:
         test_dl = DataLoader(TestDS(test_tensor), bs=128)
 
         # Get predictions
-        preds = learn_infer.get_preds(dl=test_dl)
+        preds = learner.get_preds(dl=test_dl)
         label = "Insincere" if (F.softmax(preds[0], dim=1)[:, 1]>0.4878) else "Sincere"
         probs = {
             "Probability": float(F.softmax(preds[0], dim=1)[:, 1]),