def train_model(
        self,
        dataset_handler: inlp_dataset_handler.ClassificationDatasetHandler
    ) -> float:
        """
        :param dataset_handler:
        :return:  accuracy score on the dev set / Person's R in the case of regression
        """

        X_train, Y_train = dataset_handler.get_current_training_set()
        X_train1, X_train2 = X_train
        X_dev, Y_dev = dataset_handler.get_current_dev_set()
        X_dev1, X_dev2 = X_dev

        device = self.model_params["device"]
        train_dataset = Dataset(X_train1, X_train2, Y_train, device=device)
        dev_dataset = Dataset(X_dev1, X_dev2, Y_dev, device=device)

        self.model = self.model_class(
            train_dataset,
            dev_dataset,
            input_dim=self.model_params["input_dim"],
            hidden_dim=self.model_params["hidden_dim"],
            batch_size=self.model_params["batch_size"],
            verbose=self.model_params["verbose"],
            same_weights=self.model_params["same_weights"],
            compare_by=self.model_params["compare_by"]).to(device)
        score = self.model.train_network(self.model_params["num_iter"])
        return score
    def train_model(self, dataset_handler: inlp_dataset_handler.ClassificationDatasetHandler) -> float:

        """
        :param dataset_handler:
        :return:  accuracy score on the dev set / Person's R in the case of regression
        """

        X_train, Y_train = dataset_handler.get_current_training_set()
        X_dev, Y_dev = dataset_handler.get_current_dev_set()

        self.model.fit(X_train, Y_train)
        score = self.model.score(X_dev, Y_dev)
        return score
    def train_model(
        self,
        dataset_handler: inlp_dataset_handler.ClassificationDatasetHandler
    ) -> float:
        """
        :param dataset_handler:
        :return:  accuracy score on the dev set / Person's R in the case of regression
        """

        X_train, sents_train, ids_train = dataset_handler.get_current_training_set(
        )
        X_train1, X_train2 = X_train
        X_dev, sents_dev, ids_dev = dataset_handler.get_current_dev_set()
        X_dev1, X_dev2 = X_dev

        device = self.model_params["device"]
        ids_train1, ids_train2 = ids_train
        ids_dev1, ids_dev2 = ids_dev
        sents_train1, sents_train2 = sents_train
        sents_dev1, sents_dev2 = sents_dev

        train_dataset = MetricLearningDataset(X_train1,
                                              X_train2,
                                              sents_train1,
                                              sents_train2,
                                              ids_train1,
                                              ids_train2,
                                              device=device)
        dev_dataset = MetricLearningDataset(X_dev1,
                                            X_dev2,
                                            sents_dev1,
                                            sents_dev2,
                                            ids_dev1,
                                            ids_dev2,
                                            device=device)

        self.model = self.model_class(
            train_dataset,
            dev_dataset,
            input_dim=self.model_params["input_dim"],
            hidden_dim=self.model_params["hidden_dim"],
            batch_size=self.model_params["batch_size"],
            verbose=self.model_params["verbose"],
            k=self.model_params["k"],
            p=self.model_params["p"],
            mode=self.model_params["mode"],
            final=self.model_params["final"],
            device=self.model_params["device"])
        self.model = self.model.to(device)
        score = self.model.train_network(self.model_params["num_iter"])
        return score
    def train_model(
        self,
        dataset_handler: inlp_dataset_handler.ClassificationDatasetHandler
    ) -> float:
        """
        :param dataset_handler:
        :return:  accuracy score on the dev set / Person's R in the case of regression
        """

        X_train, Y_train = dataset_handler.get_current_training_set()
        X_dev, Y_dev = dataset_handler.get_current_dev_set()
        train_loader = DataLoader(list(zip(X_train, Y_train)), batch_size=16)
        dev_loader = DataLoader(list(zip(X_dev, Y_dev)), batch_size=16)
        trainer = pl.Trainer(max_epochs=self.num_epochs,
                             min_epochs=1,
                             gpus=1 if self.device_to_use == "cuda" else 0)
        trainer.fit(self, train_loader, dev_loader)

        score = self.score(X_dev, Y_dev)
        return score