[AutoML] 구현을 향해, AutoSklearnClassifeir.fit(2) - 5편

서론

검색창에 AutoML을 검색하면, 잘 만들어진 프레임워크들이 많습니다.

많은 프레임워크들을 보고 코드의 의도와 구현 방식을 배우는 것이 목표입니다.

AutoSklearnClassifier Source
원본은 아래 공식 홈페이지에서 확인할 수 있습니다.

APIs — AutoSklearn 0.14.7 documentation

---

[AutoML] 구현을 향해, AutoSklearnClassifeir.fit(2) - 5편

AutoSklearnClassifier.fit 메서드

class AutoSklearnClassifier(AutoSklearnEstimator, ClassifierMixin):

    def fit(self, X, y,
                X_test=None,
                y_test=None,
                feat_type=None,
                dataset_name=None):

            y = convert_if_sparse(y)

            target_type = type_of_target(y)
            supported_types = ['binary', 'multiclass', 'multilabel-indicator']
            if target_type not in supported_types:
                raise ValueError("Classification with data of type {} is "
                                 "not supported. Supported types are {}. "
                                 "You can find more information about scikit-learn "
                                 "data types in: "
                                 "https://scikit-learn.org/stable/modules/multiclass.html"
                                 "".format(
                                        target_type,
                                        supported_types
                                    )
                                 )

            self.target_type = target_type

            super().fit(
                X=X,
                y=y,
                X_test=X_test,
                y_test=y_test,
                feat_type=feat_type,
                dataset_name=dataset_name,
            )

            self.classes_ = self.automl_.InputValidator.target_validator.classes_

 

 

• AutoSklearnClassifier은 AutoSklearnEstimator을 상속받아 fit메서드를 사용 중이기 때문에 AutoSklearnEstimator의 fit메서드를 확인해 보겠음

AutoSklearnEstimator.fit 메서드

class AutoSklearnEstimator(BaseEstimator):
    def fit(self, **kwargs):

        # Automatically set the cutoff time per task
        if self.per_run_time_limit is None:
            self.per_run_time_limit = self._n_jobs * self.time_left_for_this_task // 10

        if self.automl_ is None:
            self.automl_ = self.build_automl()
        self.automl_.fit(load_models=self.load_models, **kwargs)

        return self

1. per_run_time_limit

• 학습에 필요한 시간제한을 설정

2. build_automl()

• 해당 메서드는 AutoSklearnEstimator 클래스 내부 메서드 이며, 알고리즘을 빌드하는 것으로 추정되며, 확인을 위해 코드를 살펴보겠음
• _get_automl_class()메서드에서 리턴 값으로 automl을 생성하고 있음

class AutoSklearnEstimator(BaseEstimator):
    def build_automl(self):

        automl = self._get_automl_class()(
            temporary_directory=self.tmp_folder,
            delete_tmp_folder_after_terminate=self.delete_tmp_folder_after_terminate,
            time_left_for_this_task=self.time_left_for_this_task,
            per_run_time_limit=self.per_run_time_limit,
            initial_configurations_via_metalearning=self.initial_configurations_via_metalearning,
            ensemble_size=self.ensemble_size,
            ensemble_nbest=self.ensemble_nbest,
            max_models_on_disc=self.max_models_on_disc,
            seed=self.seed,
            memory_limit=self.memory_limit,
            include=self.include,
            exclude=self.exclude,
            resampling_strategy=self.resampling_strategy,
            resampling_strategy_arguments=self.resampling_strategy_arguments,
            n_jobs=self._n_jobs,
            dask_client=self.dask_client,
            get_smac_object_callback=self.get_smac_object_callback,
            disable_evaluator_output=self.disable_evaluator_output,
            smac_scenario_args=self.smac_scenario_args,
            logging_config=self.logging_config,
            metadata_directory=self.metadata_directory,
            metric=self.metric,
            scoring_functions=self.scoring_functions,
            get_trials_callback=self.get_trials_callback
        )

        return automl

_get_automl_class()

NotImplementedError 에러

• 이름 그대로 아직 구현되지 않았다는 에러표시임, 이것을 사용하는 개발자에게도 알려주는 역할
• TODO의 역할을 하기도함
• 여기서는 자식 클래스인 AutoSklearnClassfier의 메서들를 사용해 AutoMLClassifier를 리턴 받음

 class AutoSklearnEstimator(BaseEstimator):
     def _get_automl_class(self):
            raise NotImplementedError()
class AutoSklearnClassifier(AutoSklearnEstimator, ClassifierMixin):
    def _get_automl_class(self):
        return AutoMLClassifier

AutoMLClassifier

• 그렇다면 AutoMLClassifier 인스턴스에 build_automl()에서 초기화하고 사용
• AutoMLClassifier는 AutoML을 상속받아사용 하며 build_automl() 단계에서 받은 파라미터를 사용해 초기화함
• AutoMLClassifier.fit메서드에서 확인할 수 있는 것처럼 return값은 super.fit이기 때문에 AutoML을 확인할 필요가 있음

class AutoMLClassifier(AutoML):

    _task_mapping = {
        'multilabel-indicator': MULTILABEL_CLASSIFICATION,
        'multiclass': MULTICLASS_CLASSIFICATION,
        'binary': BINARY_CLASSIFICATION,
    }

    @classmethod
    def _task_type_id(cls, task_type: str) -> int:
        return cls._task_mapping[task_type]

    @classmethod
    def _supports_task_type(cls, task_type: str) -> bool:
        return task_type in cls._task_mapping.keys()

    def fit(
        self,
        X: SUPPORTED_FEAT_TYPES,
        y: Union[SUPPORTED_TARGET_TYPES, spmatrix],
        X_test: Optional[SUPPORTED_FEAT_TYPES] = None,
        y_test: Optional[Union[SUPPORTED_TARGET_TYPES, spmatrix]] = None,
        feat_type: Optional[List[bool]] = None,
        dataset_name: Optional[str] = None,
        only_return_configuration_space: bool = False,
        load_models: bool = True,
    ):
        return super().fit(
            X, y,
            X_test=X_test,
            y_test=y_test,
            feat_type=feat_type,
            dataset_name=dataset_name,
            only_return_configuration_space=only_return_configuration_space,
            load_models=load_models,
            is_classification=True,
        )

class AutoML(BaseEstimator):

    def __init__(self,
                 time_left_for_this_task,
                 per_run_time_limit,
                 temporary_directory: Optional[str] = None,
                 delete_tmp_folder_after_terminate: bool = True,
                 initial_configurations_via_metalearning=25,
                 ensemble_size=1,
                 ensemble_nbest=1,
                 max_models_on_disc=1,
                 seed=1,
                 memory_limit=3072,
                 metadata_directory=None,
                 debug_mode=False,
                 include: Optional[Dict[str, List[str]]] = None,
                 exclude: Optional[Dict[str, List[str]]] = None,
                 resampling_strategy='holdout-iterative-fit',
                 resampling_strategy_arguments=None,
                 n_jobs=None,
                 dask_client: Optional[dask.distributed.Client] = None,
                 precision=32,
                 disable_evaluator_output=False,
                 get_smac_object_callback=None,
                 smac_scenario_args=None,
                 logging_config=None,
                 metric=None,
                 scoring_functions=None,
                 get_trials_callback=None
                 ):

AutoML.fit

• 여기가 진짜 학습하는 부분인 것으로 추정되며 다음 포스팅에 자세히 분석할 예정