def create_pair_comparison_features(df: pd.DataFrame) -> pd.DataFrame:
    # フラグ系の特徴は0か1しかないため、差分を取っても問題ない
    flg_columns = ["xxx_flg", "yyy_flg", ..., "zzz_flg"]
    # 数値変数は差分をとるのがふさわしい
    numerical_columns = ["num_xxx", "num_yyy", ..., "num_zzz"]
    # カテゴリ変数はペアの前後で組み合わせて新しいカテゴリを作る
    categorical_columns = ["cat_xxx", "cat_yyy", ..., "cat_zzz"]
    # ペア内で共通の特徴
    common_columns = ["common_xxx", "common_yyy", ..., "common_zzz"]
    # 差分を取る系の特徴を作成
    diff_feats = flg_columns + numerical_columns
    aggregate_dict = {
        key: lambda x: x.values[0] - x.values[1]
        for key in diff_feats
    }
    diff_df = df.groupby(["ユーザーID", "リクエスト時間", "検索パラメータ"]).agg(
        aggregate_dict)
    # カテゴリ変数は組み合わせを作り新しいカテゴリ変数とする(Encodingは後で行う)
    aggregate_dict = {
        key: lambda x: str(x.values[0]) + "_" + str(x.values[1])
        for key in categorical_columns
    }
    categorical_df = df.groupby(["ユーザーID", "リクエスト時間", "検索パラメータ"]).agg(
        aggregate_dict)
    # ペア内で共通の特徴は最初の一個を取る
    aggregate_dict = {
        key: lambda x: x.values[0]
        for key in common_columns
    }
    common_df = df.groupby(["ユーザーID", "リクエスト時間", "検索パラメータ"]).agg(
        aggregate_dict)
    return diff_df.merge(
        categorical_df, left_index=True, right_index=True
    ).merge(
        common_df, left_index=True, right_index=True
    )

import logging
from typing import List, Optional, TypeVar
import pandas as pd
class AbstractFeatureTransformer:
    def __init__(self):
        self.name = self.__class__.__name__
    def fit_transform(self, input_df: pd.DataFrame, y=None):
        self.fit(input_df, y)
        return self.transform(input_df)
    def fit(self, input_df: pd.DataFrame, y=None):
        pass
    def transform(self, input_df: pd.DataFrame) -> pd.DataFrame:
        raise NotImplementedError
Transformer = TypeVar("Transformer", bound=AbstractFeatureTransformer)
def extract_features(input_df: pd.DataFrame,
                     transformers: List[Transformer],
                     fit: bool = True,
                     logger: Optional[logging.Logger] = None):
    feature_dfs = []
    for transformer in transformers:
        # timerはブロックの実行時間を計測するユーティリティ
        with timer(f"Extract features with {transformer.name}", logger):
            if fit:
                feature_dfs.append(transformer.fit_transform(input_df))
            else:
                feature_dfs.append(transformer.transform(input_df))
    all_features = pd.concat(feature_dfs, axis=1)
    return all_features

class Numericals(AbstractFeatureTransformer):
    def transform(self, input_df: pd.DataFrame) -> pd.DataFrame:
        cols = [pd.api.types.is_numeric_dtype(dtype) for dtype in input_df.dtypes]
        return input_df.loc[:, cols]
class LabelEncoding(AbstractFeatureTransformer):
    def __init__(self, columns: List[str]):
        super().__init__()
        self.le_columns = columns
        self.encoders = {
            column: LabelEncoder()
            for column in self.le_columns
        }
        self.__is_fitted = False
    def fit(self, input_df: pd.DataFrame, y: Optional[np.ndarray] = None):
        for column in self.le_columns:
            self.encoders[column].fit(input_df[column].fillna(""))
        self.__is_fitted = True
    def transform(
        self, 
        input_df: pd.DataFrame, 
        y: Optional[np.ndarray] = None
    ) -> pd.DataFrame:
        assert self.__is_fitted, "You need to call `fit` first."
        encoded = {}
        for column in self.le_columns:
            encoded[column] = self.encoders[column].transform(
                input_df[column].fillna(""))
        return pd.DataFrame(encoded)

import lightgbm as lgb
class AbstractTreeModel:
    def __init__(self, prediction_type="binary"):
        self.model = None
        self.prediction_type = prediction_type
    def train(self,
              params: dict,
              X_train: pd.DataFrame,
              y_train: np.ndarray,
              X_val: pd.DataFrame,
              y_val: np.ndarray,
              train_weights: Optional[np.ndarray] = None,
              val_weights: Optional[np.ndarray] = None,
              train_params: Optional[dict] = None):
        if train_params is None:
            train_params = {}
        model = self._train(
            params,
            X_train, y_train,
            X_val, y_val,
            train_weights, val_weights,
            train_params)
        self.model = model
        return self
    def _train(self,
               params,
               X_train,
               y_train,
               X_val,
               y_val,
               train_weights,
               val_weights,
               train_params):
        raise NotImplementedError
    def predict(self, X: pd.DataFrame) -> np.ndarray:
        raise NotImplementedError
    @property
    def feature_names_(self):
        raise NotImplementedError
    @property
    def feature_importances_(self):
        raise NotImplementedError
    def _check_if_trained(self):
        assert self.model is not None, "You need to train the model first"
class LGBModel(AbstractTreeModel):
    def _train(self,
               params,
               X_train, y_train,
               X_val, y_val,
               train_weights, val_weights,
               train_params):
        trn_data = lgb.Dataset(X_train, y_train, weight=train_weights)
        val_data = lgb.Dataset(X_val, y_val, weight=val_weights)
        model = lgb.train(params=params,
                          train_set=trn_data,
                          valid_sets=[trn_data, val_data],
                          **train_params)
        return model
    def predict(self, X: pd.DataFrame) -> np.ndarray:
        self._check_if_trained()
        return self.model.predict(X, num_iteration=self.model.best_iteration)
    @property
    def feature_names_(self):
        self._check_if_trained()
        return self.model.feature_name()
    @property
    def feature_importances_(self):
        self._check_if_trained()
        return self.model.feature_importance(importance_type="gain")
def get_tree_model(name: str) -> Type[AbstractTreeModel]:
    DEFINED_MODELS = {
        "lgb": LGBModel,
        # 実装していない
        # "xgb": XGBModel,
        # "cat": CatBoostModel
    }
    model = DEFINED_MODELS.get(name)
    if model is None:
        raise ValueError(
            """Invalid model name: {}.
            Pre-defined model names are as follows: {}""".format(
                name,
                ",".join(DEFINED_MODELS.keys())
            ))
    return model