fixed pl early stop --> patience was consumed if actual_monitor == best_monitor. Set policy to greater or equal.

main.py

@@ -49,16 +49,16 @@ def main(args):
     if args.bert_embedder:
         bertEmbedder = BertGen(multilingualIndex, batch_size=args.batch_bert, nepochs=args.nepochs_bert,
                                patience=args.patience_bert, gpus=args.gpus, n_jobs=args.n_jobs)
-        bertEmbedder.transform(lX)
         embedder_list.append(bertEmbedder)
 
     # Init DocEmbedderList (i.e., first-tier learners or view generators) and metaclassifier
     docEmbedders = DocEmbedderList(embedder_list=embedder_list, probabilistic=True)
     meta = MetaClassifier(meta_learner=get_learner(calibrate=False, kernel='rbf'),
-                          meta_parameters=get_params(optimc=args.optimc))
+                          meta_parameters=get_params(optimc=args.optimc),
+                          n_jobs=args.n_jobs)
 
     # Init Funnelling Architecture
-    gfun = Funnelling(first_tier=docEmbedders, meta_classifier=meta)
+    gfun = Funnelling(first_tier=docEmbedders, meta_classifier=meta, n_jobs=args.n_jobs)
 
     # Training ---------------------------------------
     print('\n[Training Generalized Funnelling]')
@@ -71,7 +71,7 @@ def main(args):
     print('\n[Testing Generalized Funnelling]')
     time_te = time.time()
     ly_ = gfun.predict(lXte)
-    l_eval = evaluate(ly_true=lyte, ly_pred=ly_)
+    l_eval = evaluate(ly_true=lyte, ly_pred=ly_, n_jobs=args.n_jobs)
     time_te = round(time.time() - time_te, 3)
     print(f'Testing completed in {time_te} seconds!')
 
@@ -112,8 +112,8 @@ if __name__ == '__main__':
     parser.add_argument('dataset', help='Path to the dataset')
 
     parser.add_argument('-o', '--output', dest='csv_dir', metavar='',
-                        help='Result file (default ../csv_logs/gfun/gfun_results.csv)', type=str,
-                        default='../csv_logs/gfun/gfun_results.csv')
+                        help='Result file (default csv_logs/gfun/gfun_results.csv)', type=str,
+                        default='csv_logs/gfun/gfun_results.csv')
 
     parser.add_argument('-x', '--post_embedder', dest='post_embedder', action='store_true',
                         help='deploy posterior probabilities embedder to compute document embeddings',

src/models/lstm_class.py

@@ -1,112 +0,0 @@
-#taken from https://github.com/prakashpandey9/Text-Classification-Pytorch/blob/master/models/LSTM.py
-from models.helpers import *
-from torch.autograd import Variable
-
-
-class RNNMultilingualClassifier(nn.Module):
-
-    def __init__(self, output_size, hidden_size, lvocab_size, learnable_length, lpretrained=None,
-                 drop_embedding_range=None, drop_embedding_prop=0, post_probabilities=True, only_post=False,
-                 bert_embeddings=False):
-
-        super(RNNMultilingualClassifier, self).__init__()
-        self.output_size = output_size
-        self.hidden_size = hidden_size
-        self.drop_embedding_range = drop_embedding_range
-        self.drop_embedding_prop = drop_embedding_prop
-        self.post_probabilities = post_probabilities
-        self.bert_embeddings = bert_embeddings
-        assert 0 <= drop_embedding_prop <= 1, 'drop_embedding_prop: wrong range'
-
-        self.lpretrained_embeddings = nn.ModuleDict()
-        self.llearnable_embeddings = nn.ModuleDict()
-        self.embedding_length = None
-        self.langs = sorted(lvocab_size.keys())
-        self.only_post = only_post
-
-        self.n_layers = 1
-        self.n_directions = 1
-
-        self.dropout = nn.Dropout(0.6)
-
-        lstm_out = 256
-        ff1 = 512
-        ff2 = 256
-
-        lpretrained_embeddings = {}
-        llearnable_embeddings = {}
-        if only_post==False:
-            for l in self.langs:
-                pretrained = lpretrained[l] if lpretrained else None
-                pretrained_embeddings, learnable_embeddings, embedding_length = init_embeddings(
-                    pretrained, lvocab_size[l], learnable_length
-                )
-                lpretrained_embeddings[l] = pretrained_embeddings
-                llearnable_embeddings[l] = learnable_embeddings
-                self.embedding_length = embedding_length
-
-            # self.lstm = nn.LSTM(self.embedding_length, hidden_size, dropout=0.2 if self.n_layers>1 else 0, num_layers=self.n_layers, bidirectional=(self.n_directions==2))
-            self.rnn = nn.GRU(self.embedding_length, hidden_size)
-            self.linear0 = nn.Linear(hidden_size * self.n_directions, lstm_out)
-            self.lpretrained_embeddings.update(lpretrained_embeddings)
-            self.llearnable_embeddings.update(llearnable_embeddings)
-
-        self.linear1 = nn.Linear(lstm_out, ff1)
-        self.linear2 = nn.Linear(ff1, ff2)
-
-        if only_post:
-            self.label = nn.Linear(output_size, output_size)
-        elif post_probabilities and not bert_embeddings:
-            self.label = nn.Linear(ff2 + output_size, output_size)
-        elif bert_embeddings and not post_probabilities:
-            self.label = nn.Linear(ff2 + 768, output_size)
-        elif post_probabilities and bert_embeddings:
-            self.label = nn.Linear(ff2 + output_size + 768, output_size)
-        else:
-            self.label = nn.Linear(ff2, output_size)
-
-    def forward(self, input, post, bert_embed, lang):
-        if self.only_post:
-            doc_embedding = post
-        else:
-            doc_embedding = self.transform(input, lang)
-            if self.post_probabilities:
-                doc_embedding = torch.cat([doc_embedding, post], dim=1)
-            if self.bert_embeddings:
-                doc_embedding = torch.cat([doc_embedding, bert_embed], dim=1)
-
-        logits = self.label(doc_embedding)
-        return logits
-
-    def transform(self, input, lang):
-        batch_size = input.shape[0]
-        input = embed(self, input, lang)
-        input = embedding_dropout(input, drop_range=self.drop_embedding_range, p_drop=self.drop_embedding_prop,
-                                  training=self.training)
-        input = input.permute(1, 0, 2)
-        h_0 = Variable(torch.zeros(self.n_layers*self.n_directions, batch_size, self.hidden_size).cuda())
-        # c_0 = Variable(torch.zeros(self.n_layers*self.n_directions, batch_size, self.hidden_size).cuda())
-        # output, (_, _) = self.lstm(input, (h_0, c_0))
-        output, _ = self.rnn(input, h_0)
-        output = output[-1, :, :]
-        output = F.relu(self.linear0(output))
-        output = self.dropout(F.relu(self.linear1(output)))
-        output = self.dropout(F.relu(self.linear2(output)))
-        return output
-
-    def finetune_pretrained(self):
-        for l in self.langs:
-            self.lpretrained_embeddings[l].requires_grad = True
-            self.lpretrained_embeddings[l].weight.requires_grad = True
-
-    def get_embeddings(self, input, lang):
-        batch_size = input.shape[0]
-        input = embed(self, input, lang)
-        input = embedding_dropout(input, drop_range=self.drop_embedding_range, p_drop=self.drop_embedding_prop,
-                                  training=self.training)
-        input = input.permute(1, 0, 2)
-        h_0 = Variable(torch.zeros(self.n_layers * self.n_directions, batch_size, self.hidden_size).cuda())
-        output, _ = self.rnn(input, h_0)
-        output = output[-1, :, :]
-        return output.cpu().detach().numpy()
-

src/util/common.py

@@ -378,7 +378,7 @@ def get_method_name(args):
     for i, conf in enumerate(_id_conf):
         if conf:
             _id += _id_name[i]
-    _id = _id if not args.gru_wce else _id + '_wce'
+    _id = _id if not args.rnn_wce else _id + '_wce'
     _dataset_path = args.dataset.split('/')[-1].split('_')
     dataset_id = _dataset_path[0] + _dataset_path[-1]
     return _id, dataset_id

src/view_generators.py

@@ -18,6 +18,7 @@ This module contains the view generators that take care of computing the view sp
 from abc import ABC, abstractmethod
 # from time import time
 
+import torch
 from pytorch_lightning import Trainer
 from pytorch_lightning.loggers import TensorBoardLogger
 from pytorch_lightning.callbacks.early_stopping import EarlyStopping
@@ -241,6 +242,10 @@ class RecurrentGen(ViewGen):
         self.logger = TensorBoardLogger(save_dir='../tb_logs', name='rnn', default_hp_metric=False)
         self.early_stop_callback = EarlyStopping(monitor='val-macroF1', min_delta=0.00,
                                                  patience=self.patience, verbose=False, mode='max')
+
+        # modifying EarlyStopping global var in order to compute >= with respect to the best score
+        self.early_stop_callback.mode_dict['max'] = torch.ge
+
         self.lr_monitor = LearningRateMonitor(logging_interval='epoch')
 
     def _init_model(self):
@@ -348,6 +353,9 @@ class BertGen(ViewGen):
         self.early_stop_callback = EarlyStopping(monitor='val-macroF1', min_delta=0.00,
                                                  patience=self.patience, verbose=False, mode='max')
 
+        # modifying EarlyStopping global var in order to compute >= with respect to the best score
+        self.early_stop_callback.mode_dict['max'] = torch.ge
+
     def _init_model(self):
         output_size = self.multilingualIndex.get_target_dim()
         return BertModel(output_size=output_size, stored_path=self.stored_path, gpus=self.gpus)
@@ -361,7 +369,7 @@ class BertGen(ViewGen):
         :param ly: dict {lang: target vectors}
         :return: self.
         """
-        print('# Fitting BertGen (M)...')
+        print('# Fitting BertGen (B)...')
         create_if_not_exist(self.logger.save_dir)
         self.multilingualIndex.train_val_split(val_prop=0.2, max_val=2000, seed=1)
         bertDataModule = BertDataModule(self.multilingualIndex, batchsize=self.batch_size, max_len=512)