def configurate_inputs()

in ModelConf.py [0:0]

• 86 lines of code
• 56 McCabe index (conditional complexity)

    def configurate_inputs(self):

        def configurate_data_path(self):
            self.pretrained_emb_path =self.pre_trained_emb

            if self.mode != "normal":
                self.train_data_path = None
                self.valid_data_path = None
                self.test_data_path = None
                self.predict_data_path = None
                self.pretrained_emb_path = None

            if hasattr(self.params, 'train_data_path') and self.params.train_data_path:
                self.train_data_path = self.params.train_data_path
            if hasattr(self.params, 'valid_data_path') and self.params.valid_data_path:
                self.valid_data_path = self.params.valid_data_path
            if hasattr(self.params, 'test_data_path') and self.params.test_data_path:
                self.test_data_path = self.params.test_data_path
            if hasattr(self.params, 'predict_data_path') and self.params.predict_data_path:
                self.predict_data_path = self.params.predict_data_path
            if hasattr(self.params, 'pretrained_emb_path') and self.params.pretrained_emb_path:
                self.pretrained_emb_path = self.params.pretrained_emb_path

            if self.phase == 'train' or self.phase == 'cache':
                if self.valid_data_path is None and self.test_data_path is not None:
                    # We support test_data_path == None, if someone set valid_data_path to None while test_data_path is not None,
                    # swap the valid_data_path and test_data_path
                    self.valid_data_path = self.test_data_path
                    self.test_data_path = None
            elif self.phase == 'predict':
                if self.predict_data_path is None and self.test_data_path is not None:
                    self.predict_data_path = self.test_data_path
                    self.test_data_path = None
            
            return self

        def configurate_data_format(self):
            # file columns
            if self.phase == 'train' or self.phase == 'test' or self.phase == 'cache':
                self.file_columns = self.file_header
                if self.file_columns is None:
                    self.raise_configuration_error('file_columns')
            if self.phase == 'predict':
                self.file_columns, self.predict_file_columns = self.file_header, self.predict_file_header
                if self.file_columns is None and self.predict_file_columns is None:
                    self.raise_configuration_error('predict_file_columns')
                if self.file_columns and self.predict_file_columns is None:
                    self.predict_file_columns = self.file_columns

            # target
            if self.phase != 'predict':
                self.answer_column_name = self.target
                if self.target is None and self.phase != 'cache':
                    self.raise_configuration_error('target')

            if ProblemTypes[self.problem_type] == ProblemTypes.sequence_tagging and self.add_start_end_for_seq is None:
                self.add_start_end_for_seq = True

            # pretrained embedding
            if 'word' in self.architecture[0]['conf'] and self.pretrained_emb_path:
                if hasattr(self.params, 'involve_all_words_in_pretrained_emb') and self.params.involve_all_words_in_pretrained_emb:
                    self.involve_all_words_in_pretrained_emb = self.params.involve_all_words_in_pretrained_emb
                if hasattr(self.params, 'pretrained_emb_type') and self.params.pretrained_emb_type:
                    self.pretrained_emb_type = self.params.pretrained_emb_type
                if hasattr(self.params, 'pretrained_emb_binary_or_text') and self.params.pretrained_emb_binary_or_text:
                    self.pretrained_emb_binary_or_text = self.params.pretrained_emb_binary_or_text
                self.pretrained_emb_dim = self.architecture[0]['conf']['word']['dim']
            else:
                self.pretrained_emb_path = None
                self.involve_all_words_in_pretrained_emb = None
                self.pretrained_emb_type = None
                self.pretrained_emb_binary_or_text = None
                self.pretrained_emb_dim = None
            
            return self

        def configurate_model_input(self):
            self.object_inputs = self.model_inputs
            self.object_inputs_names = [name for name in self.object_inputs]

            return self

        self.problem_type = self.dataset_type.lower()

        # previous model path
        if hasattr(self.params, 'previous_model_path') and self.params.previous_model_path:
            self.previous_model_path = self.params.previous_model_path
        else:
            self.previous_model_path = os.path.join(self.save_base_dir, self.model_name)

        # pretrained model path
        if hasattr(self.params, 'pretrained_model_path') and self.params.pretrained_model_path:
            self.pretrained_model_path = self.params.pretrained_model_path

        # saved problem path
        model_path = None
        if self.phase == 'train':
            model_path = self.pretrained_model_path
        elif self.phase == 'test' or self.phase == 'predict':
            model_path = self.previous_model_path
        if model_path:
            model_path_dir = os.path.dirname(model_path)
            self.saved_problem_path = os.path.join(model_path_dir, '.necessary_cache', 'problem.pkl')
            if not os.path.isfile(self.saved_problem_path):
                self.saved_problem_path = os.path.join(model_path_dir, 'necessary_cache', 'problem.pkl')
            if not (os.path.isfile(model_path) and os.path.isfile(self.saved_problem_path)):
                raise Exception('Previous trained model %s or its dictionaries %s does not exist!' % (model_path, self.saved_problem_path))

        configurate_data_path(self)
        configurate_data_format(self)
        configurate_model_input(self)