Add files via upload

Author: jpmedras

workspace/Datasets/dataset.py

@@ -1,5 +1,4 @@
 from torch.utils.data import Dataset
-from torch import tensor
 
 class ProblemDataset(Dataset):
     def __init__(self, data, inputs_encoder, labels_encoder):
@@ -10,4 +9,16 @@ def __len__(self):
         return len(self.inputs)
 
     def __getitem__(self, index):
-        return self.inputs[index], self.labels[index]
+        return self.inputs[index], self.labels[index]
+    
+def tolist(dataset):
+    inputs = []
+    labels = []
+
+    for inp, lab in dataset:
+        inputs.append(inp[0, :].numpy().tolist())
+        labels.append(lab.numpy().tolist())
+    
+    labels = [item for sublist in labels for item in sublist]
+
+    return inputs, labels

workspace/Datasets/encoders.py

@@ -25,21 +25,10 @@ def inputs_encoder(inputs):
 
             encoded_input = cat((encoded_input_ids, encoded_attention_mask, encoded_token_type_ids), dim = 0).unsqueeze(0)
             encoded_inputs.append(encoded_input)
+    
+        encoded = cat(encoded_inputs)
 
-        try:
-            encoded = cat(encoded_inputs)
-            return encoded
-        except:
-            print('Number of inputs:', len(encoded_inputs))
-            max_dif = max([e.shape[2] for e in encoded_inputs])
-            print('Max shape:', max_dif)
-            for idx, e in enumerate(encoded_inputs):
-                if e.shape[2] != max_len:
-                    print(idx)
-                    print(e.shape[2])
-                    print(inputs[idx])
-                    break
-            return None
+        return encoded
 
     def labels_encoder(labels):
         encoded_labels = []

workspace/Models/classic_classifier.py

@@ -0,0 +1,27 @@
+from sklearn.pipeline import Pipeline
+from sklearn.feature_extraction.text import TfidfTransformer
+
+import matplotlib.pyplot as plt
+from sklearn.metrics import f1_score, confusion_matrix, ConfusionMatrixDisplay
+
+class ClassicClassifier():
+    def __init__(self, clf):
+        self.text_clf = Pipeline([
+            ('tfidf', TfidfTransformer()),
+            ('clf', clf()),
+        ])
+
+    def fit(self, inputs, labels):
+        self.text_clf = self.text_clf.fit(inputs, labels)
+
+    def predict(self, inputs):
+        return self.text_clf.predict(inputs)
+    
+    def evaluate(self, labels, predicts):
+        target_names = ['Easy', 'Medium', 'Hard']
+        macro_f1 = f1_score(labels, predicts, average='macro')
+        cm = confusion_matrix(labels, predicts)
+        disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=target_names)
+        print(f'Macro F1: {macro_f1}')
+        disp.plot()
+        plt.show()

workspace/Models/model.py

@@ -1,46 +1,47 @@
+import torch
 from torch import nn, long, argmax, optim, save
-from torch import no_grad
 from transformers import BertModel
 from torch import cuda
-from Datasets.dataloader import create_dataloader
 from loss import calc_loss
 
 import matplotlib.pyplot as plt
 from sklearn.metrics import f1_score, confusion_matrix, ConfusionMatrixDisplay
 
 class BERTModule(nn.Module):
-    def __init__(self, epochs = 10, learning_rate = 1e-05, dropout_p = 0.3):
+    def __init__(self, n_classes, dropout_p = 0.3):
         super(BERTModule, self).__init__()
         self.bert = BertModel.from_pretrained('bert-base-uncased')
         # for param in self.bert.parameters():
         #   param.requires_grad = False
         self.dropout = nn.Dropout(p = dropout_p)
-        self.fc = nn.Linear(768, 3)
+        self.fc = nn.Linear(768, n_classes)
 
-        self.epochs = epochs
-        self.learning_rate = learning_rate
+        self.device = 'cuda' if cuda.is_available() else 'cpu'
+        self.to(self.device)
 
     def forward(self, ids, masks, ttis):
         _, pooled_output = self.bert(ids, attention_mask = masks, token_type_ids = ttis, return_dict = False)
-        output_2 = self.dropout(pooled_output)
-        output = self.fc(output_2)
-        
+        output_drop = self.dropout(pooled_output)
+        output = self.fc(output_drop)
+
         return output
-    
-    def fit(self, train_loader, test_loader):
-        self.device = 'cuda' if cuda.is_available() else 'cpu'
-        self.to(self.device)
 
-        self.train()
-        
+    def fit(self, train_loader, test_loader, epochs = 10, learning_rate = 1e-05):
+        self.epochs = epochs
+        self.learning_rate = learning_rate
+
         criterion = nn.CrossEntropyLoss()
         optimizer = optim.Adam(params = self.parameters(), lr = self.learning_rate)
-        
-        print('Begin training...')
+
+        self.to(self.device)
+
+        self.train()
 
         train_losses = []
         test_losses = []
 
+        print('Begin training...')
+
         for epoch in range(self.epochs):
             train_loss = 0.
 
@@ -66,9 +67,9 @@ def fit(self, train_loader, test_loader):
                 optimizer.step()
 
                 train_loss += loss.item()
-    
+
             avg_train_loss = train_loss / len(train_loader)
-            avg_test_loss = calc_loss(self, test_loader, criterion, self.device)
+            avg_test_loss = calc_loss(self, test_loader, criterion)
 
             train_losses.append(avg_train_loss)
             test_losses.append(avg_test_loss)
@@ -88,9 +89,9 @@ def evaluate(self, dataloader):
         data_labels = []
         data_outputs = []
 
-        with no_grad():
+        with torch.no_grad():
             for inputs, labels in dataloader:
-        
+
                 ids = inputs[:, 0].to(self.device, dtype=long)
                 masks = inputs[:, 1].to(self.device, dtype=long)
                 tti = inputs[:, 2].to(self.device, dtype=long)
@@ -109,15 +110,41 @@ def evaluate(self, dataloader):
                 data_labels.extend(labels.cpu().detach().numpy().tolist())
                 data_outputs.extend(outputs.cpu().detach().numpy().tolist())
 
-    
         target_names = ['Easy', 'Medium', 'Hard']
         macro_f1 = f1_score(data_labels, data_outputs, average='macro')
         cm = confusion_matrix(data_labels, data_outputs)
-        disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Easy', 'Medium', 'Hard'])
+        disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=target_names)
         print(f'Macro F1: {macro_f1}')
         disp.plot()
         plt.show()
 
+    def predict(self, text):
+        self.eval()
+
+        from Datasets.encoders import define_encoders
+        input_encoder, _ = define_encoders(max_len=300)
+
+        with torch.no_grad():
+            input = input_encoder(text)
+
+            ids = input[:, 0].to(self.device, dtype=long)
+            masks = input[:, 1].to(self.device, dtype=long)
+            tti = input[:, 2].to(self.device, dtype=long)
+            labels = labels.squeeze().to(self.device, dtype=long)
+
+            assert ids.shape == masks.shape, 'Ids != Masks'
+            assert masks.shape == tti.shape, 'Masks != Ttis'
+            assert ids.shape == tti.shape, 'Ids != Ttis'
+
+            assert ids.shape[0] == labels.shape[0], 'inputs and labels are incompatible'
+
+            outputs = self(ids, masks, tti)
+            outputs = nn.functional.softmax(outputs, dim=1)
+            outputs = argmax(outputs, dim=1)
+
+            outputs = outputs.cpu().detach().numpy().tolist()
+
+            print(len(outputs))
 
-    def predict():
-        return 1
+            print(f'Text: {text}')
+            print(f'Difficulty: {text}')

workspace/inference.py

@@ -0,0 +1,20 @@
+from torch import load
+
+from Datasets.test_dataset import ProblemDataset
+from Datasets.load import load_data
+from Models.model import BERTModule
+
+model_path = 'model_ep2_lr1e-05.pth'
+
+model = BERTModule(n_classes = 3)
+model.load_state_dict(load(model_path))
+
+text = """
+You want to create as many non-degenerate triangles as possible while satisfying the following requirements. Each triangle consists of 3
+ distinct special points (not necessarily from different sides) as its corners. Each special point can only become the corner of at most 1
+ triangle. All triangles must not intersect with each other.
+
+Determine the maximum number of non-degenerate triangles that you can create.
+"""
+
+model.predict(text=text)

workspace/loss.py

@@ -1,15 +1,16 @@
 import torch
 from torch import long
 
-def calc_loss(model, dataloader, criterion, device):
-
+def calc_loss(model, dataloader, criterion):
     with torch.no_grad():
-        total_loss = 0.0
+        total_loss = 0.
         for inputs, labels in dataloader:
-            ids = inputs[:, 0].to(device, dtype=long)
-            masks = inputs[:, 1].to(device, dtype=long)
-            tti = inputs[:, 2].to(device, dtype=long)
-            labels = labels.squeeze().to(device, dtype=long)
+            ids = inputs[:, 0].to(model.device, dtype=long)
+            masks = inputs[:, 1].to(model.device, dtype=long)
+            tti = inputs[:, 2].to(model.device, dtype=long)
+            labels = labels.squeeze().to(model.device, dtype=long)
+
+            # print(ids.shape)
 
             outputs = model(ids, masks, tti)
 

workspace/train.py

@@ -1,5 +1,3 @@
-from torch import nn, long, optim, save
-
 from Datasets.dataset import ProblemDataset
 from Models.model import BERTModule
 
@@ -11,18 +9,25 @@
 
 from show_loss import show_loss_evolution
 
+from Models.classic_classifier import ClassicClassifier
+
+from sklearn.svm import SVC
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.ensemble import RandomForestClassifier
+
+from Datasets.dataset import tolist
+
 SEED = 42
 MAX_LEN = 200
-BATCH_SIZE = 8
+TRAIN_BATCH_SIZE = 8
+TEST_BATCH_SIZE = 4
 EPOCHS = 5
 LEARNING_RATE = 1e-05
 DATA_PATH = '../data/leetcode.csv'
 
 define_seed(SEED)
 
 inputs_encoder, labels_encoder = define_encoders(MAX_LEN)
-# TODO: Error in inputs_encoder, some inputs are getting dim_size greatter than MAX_LEN
-# an code is done to print the first input that gets a tensor with different shape
 
 data = load_data(data_path=DATA_PATH)
 
@@ -37,14 +42,29 @@
     seed=SEED
 )
 
-train_loader = create_dataloader(dataset = train_set, batch_size = BATCH_SIZE, type='train')
-test_loader = create_dataloader(dataset = test_set, batch_size = BATCH_SIZE, type='test')
+train_loader = create_dataloader(dataset = train_set, batch_size = TRAIN_BATCH_SIZE, type='train')
+test_loader = create_dataloader(dataset = test_set, batch_size = TEST_BATCH_SIZE, type='test')
 
-model = BERTModule(epochs = EPOCHS, learning_rate = LEARNING_RATE)
+model = BERTModule(n_classes = 3)
 
-train_losses, test_losses = model.fit(train_loader=train_loader, test_loader=test_loader)
+train_losses, test_losses = model.fit(train_loader=train_loader, test_loader=test_loader, epochs = EPOCHS, learning_rate = LEARNING_RATE)
 
 model.evaluate(dataloader=train_loader)
 model.evaluate(dataloader=test_loader)
 
-show_loss_evolution(EPOCHS, train_losses, test_losses)
+show_loss_evolution(EPOCHS, train_losses, test_losses)
+
+X_train, y_train = tolist(train_set)
+X_test, y_test = tolist(test_set)
+
+svc = ClassicClassifier(SVC)
+gb = ClassicClassifier(GradientBoostingClassifier)
+rf = ClassicClassifier(RandomForestClassifier)
+
+svc.fit(X_train, y_train)
+gb.fit(X_train, y_train)
+rf.fit(X_train, y_train)
+
+svc.evaluate(y_test, svc.predict(X_test))
+gb.evaluate(y_test, gb.predict(X_test))
+rf.evaluate(y_test, rf.predict(X_test))