replay-rec 0.20.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

replay/nn/transform/token_mask.py

@@ -0,0 +1,69 @@
+from typing import Optional
+
+import torch
+
+
+class TokenMaskTransform(torch.nn.Module):
+    """
+    For the feature tensor specified by ``token_field``, randomly masks items
+    in the sequence based on a uniform distribution with specified probability of masking.
+    In fact, this transform creates mask for the Masked Language Modeling (MLM) task analog in the recommendations.
+
+    Example:
+
+    .. code-block:: python
+
+        >>> _ = torch.manual_seed(0)
+        >>> input_tensor = {"padding_id": torch.BoolTensor([0, 1, 1])}
+        >>> transform = TokenMaskTransform("padding_id")
+        >>> output_tensor = transform(input_tensor)
+        >>> output_tensor
+        {'padding_id': tensor([False,  True,  True]),
+        'token_mask': tensor([False,  True, False])}
+
+    """
+
+    def __init__(
+        self,
+        token_field: str,
+        out_feature_name: str = "token_mask",
+        mask_prob: float = 0.15,
+        generator: Optional[torch.Generator] = None,
+    ) -> None:
+        """
+        :param token_field: Name of the column containing the unmasked tokes.
+        :param out_feature_name: Name of the resulting  mask column. Default: ``token_mask``.
+        :param mask_prob: Probability of masking the item, i.e. setting it to ``0``. Default: ``0.15``.
+        :param generator: Random number generator to be used for generating
+                the uniform distribution. Default: ``None``.
+        """
+        super().__init__()
+        self.token_field = token_field
+        self.out_feature_name = out_feature_name
+        self.mask_prob = mask_prob
+        self.generator = generator
+
+    def forward(self, batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
+        output_batch = dict(batch.items())
+
+        paddings = batch[self.token_field]
+
+        assert paddings.dtype == torch.bool, "Source tensor for token mask should be boolean."
+
+        mask_prob = torch.rand(paddings.size(-1), dtype=torch.float32, generator=self.generator).to(
+            device=paddings.device
+        )
+
+        # mask[i], 0 ~ mask_prob, 1 ~ (1 - mask_prob)
+        mask = (mask_prob * paddings) >= self.mask_prob
+
+        # Fix corner cases in mask
+        # 1. If all token are not masked, add mask to the end
+        if mask.all() or mask[paddings].all():
+            mask[-1] = 0
+        # 2. If all token are masked, add non-masked before the last
+        elif (not mask.any()) and (len(mask) > 1):
+            mask[-2] = 1
+
+        output_batch[self.out_feature_name] = mask
+        return output_batch

replay/nn/transform/trim.py

@@ -0,0 +1,51 @@
+from typing import List, Union
+
+import torch
+
+
+class TrimTransform(torch.nn.Module):
+    """
+    Trims sequences of specified names `feature_names` keeping the specified sequence length `seq_len` on the right.
+
+    Example:
+
+    .. code-block:: python
+
+        >>> input_batch = {
+        ...     "user_id": torch.LongTensor([111]),
+        ...     "item_id": torch.LongTensor([[5, 4, 0, 7, 4]]),
+        ...     "seen_ids": torch.LongTensor([[5, 4, 0, 7, 4]]),
+        ... }
+        >>> transform = TrimTransform(seq_len=3, feature_names="item_id")
+        >>> output_batch = transform(input_batch)
+        >>> output_batch
+        {'user_id': tensor([111]),
+        'item_id': tensor([[0, 7, 4]]),
+        'seen_ids': tensor([[5, 4, 0, 7, 4]])}
+
+    """
+
+    def __init__(
+        self,
+        seq_len: int,
+        feature_names: Union[List[str], str],
+    ) -> None:
+        """
+        :param seq_len: max sequence length used in model. Must be positive.
+        :param feature_name: name of feature in batch to be trimmed.
+        """
+        super().__init__()
+        assert seq_len > 0
+        self.seq_len = seq_len
+        self.feature_names = [feature_names] if isinstance(feature_names, str) else feature_names
+
+    def forward(self, batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
+        output_batch = dict(batch.items())
+
+        for name in self.feature_names:
+            assert output_batch[name].shape[1] >= self.seq_len
+
+            trimmed_seq = output_batch[name][:, -self.seq_len :, ...].clone()
+            output_batch[name] = trimmed_seq
+
+        return output_batch

replay/nn/utils.py

@@ -0,0 +1,28 @@
+import warnings
+from typing import Callable, Literal, Tuple
+
+import torch
+
+
+def warning_is_not_none(msg: str) -> Callable:
+    def checker(value: Tuple[torch.Tensor, str]) -> bool:
+        if value[0] is not None:
+            warnings.warn(msg.format(value[1]), RuntimeWarning, stacklevel=2)
+            return False
+        return True
+
+    return checker
+
+
+def create_activation(
+    activation: Literal["relu", "gelu", "sigmoid"],
+) -> torch.nn.Module:
+    """The function of creating an activation function based on its name"""
+    if activation == "relu":
+        return torch.nn.ReLU()
+    if activation == "gelu":
+        return torch.nn.GELU()
+    if activation == "sigmoid":
+        return torch.nn.Sigmoid()
+    msg = "Expected to get activation relu/gelu/sigmoid"
+    raise ValueError(msg)

replay/preprocessing/filters.py

@@ -1090,3 +1090,131 @@ class ConsecutiveDuplicatesFilter(_BaseFilter):
             .where((sf.col(self.item_column) != sf.col(self.temporary_column)) | sf.col(self.temporary_column).isNull())
             .drop(self.temporary_column)
         )
+
+
+def _check_col_present(
+    target: DataFrameLike,
+    reference: DataFrameLike,
+    columns_to_process: list[str],
+) -> None:
+    target_columns = set(target.columns)
+    reference_columns = set(reference.columns)
+    for column in columns_to_process:
+        if column not in target_columns or column not in reference_columns:
+            msg = f"Column '{column}' must be in both dataframes"
+            raise KeyError(msg)
+
+
+def _filter_cold_pandas(
+    target: PandasDataFrame,
+    reference: PandasDataFrame,
+    columns_to_process: list[str],
+) -> PandasDataFrame:
+    for column in columns_to_process:
+        allowed_values = reference[column].unique()
+        target = target[target[column].isin(allowed_values)]
+    return target
+
+
+def _filter_cold_polars(
+    target: PolarsDataFrame,
+    reference: PolarsDataFrame,
+    columns_to_process: list[str],
+) -> PolarsDataFrame:
+    for column in columns_to_process:
+        allowed_values = reference.select(column).unique()
+        target = target.join(allowed_values, on=column, how="semi")
+    return target
+
+
+def _filter_cold_spark(
+    target: SparkDataFrame,
+    reference: SparkDataFrame,
+    columns_to_process: list[str],
+) -> SparkDataFrame:
+    for column in columns_to_process:
+        allowed_values = reference.select(column).distinct()
+        target = target.join(allowed_values, on=column, how="left_semi")
+    return target
+
+
+def filter_cold(
+    target: DataFrameLike,
+    reference: DataFrameLike,
+    mode: Literal["items", "users", "both"] = "items",
+    query_column: str = "query_id",
+    item_column: str = "item_id",
+) -> DataFrameLike:
+    """
+    Filter rows in ``target`` keeping only users/items that exist in ``reference``.
+
+    This function works with pandas, Polars and Spark DataFrames. ``target`` and
+    ``reference`` must be of the same backend type. Depending on ``mode``, it
+    removes rows whose ``item_column`` and/or ``query_column`` values are not
+    present in the corresponding columns of ``reference``.
+
+    Parameters
+    ----------
+    target : DataFrameLike
+        Dataset to be filtered (pandas/Polars/Spark).
+    reference : DataFrameLike
+        Dataset that defines the allowed universe of users/items.
+    mode : {"items", "users", "both"}, default "items"
+        What to filter: only items, only users, or both.
+    query_column : str, default "query_id"
+        Name of the user (query) column.
+    item_column : str, default "item_id"
+        Name of the item column.
+
+    Returns
+    -------
+    DataFrameLike
+        Filtered ``target`` of the same backend type as the input.
+
+    Raises
+    ------
+    ValueError
+        If ``mode`` is not one of {"items", "users", "both"}.
+    TypeError
+        If ``target`` and ``reference`` are of different backend types.
+    KeyError
+        If required columns are missing in either dataset.
+    NotImplementedError
+        If the input dataframe type is not supported.
+    """
+    if mode not in {"items", "users", "both"}:
+        msg = "mode must be 'items' | 'users' | 'both'"
+        raise ValueError(msg)
+    if not isinstance(target, type(reference)):
+        msg = "Target and reference must be of the same type"
+        raise TypeError(msg)
+
+    if mode == "both":
+        columns_to_process = [query_column, item_column]
+    elif mode == "items":
+        columns_to_process = [item_column]
+    elif mode == "users":
+        columns_to_process = [query_column]
+
+    _check_col_present(target, reference, columns_to_process)
+
+    if isinstance(target, PandasDataFrame):
+        return _filter_cold_pandas(
+            target,
+            reference,
+            columns_to_process,
+        )
+    if isinstance(target, PolarsDataFrame):
+        return _filter_cold_polars(
+            target,
+            reference,
+            columns_to_process,
+        )
+    if isinstance(target, SparkDataFrame):
+        return _filter_cold_spark(
+            target,
+            reference,
+            columns_to_process,
+        )
+    msg = f"Unsupported data frame type: {type(target)}"
+    raise NotImplementedError(msg)

replay/preprocessing/label_encoder.py

@@ -26,7 +26,7 @@ from replay.utils import (
 
 if PYSPARK_AVAILABLE:
     from pyspark.sql import Window, functions as sf  # noqa: I001
-    from pyspark.sql.types import LongType, IntegerType, ArrayType
+    from pyspark.sql.types import LongType
     from replay.utils.session_handler import get_spark_session
 
 HandleUnknownStrategies = Literal["error", "use_default_value", "drop"]
@@ -185,11 +185,11 @@ class LabelEncodingRule(BaseLabelEncodingRule):
         self._mapping = mapping_on_spark.rdd.collectAsMap()
 
     def _fit_pandas(self, df: PandasDataFrame) -> None:
-        unique_col_values = df[self._col].drop_duplicates().reset_index(drop=True)
+        unique_col_values = df[self._col].sort_values().drop_duplicates().reset_index(drop=True)
         self._mapping = {val: key for key, val in unique_col_values.to_dict().items()}
 
     def _fit_polars(self, df: PolarsDataFrame) -> None:
-        unique_col_values = df.select(self._col).unique()
+        unique_col_values = df.sort(self._col).select(self._col).unique()
         self._mapping = {key: val for val, key in enumerate(unique_col_values.to_series().to_list())}
 
     def fit(self, df: DataFrameLike) -> "LabelEncodingRule":
@@ -630,37 +630,40 @@ class SequenceEncodingRule(LabelEncodingRule):
         return self
 
     def _transform_spark(self, df: SparkDataFrame, default_value: Optional[int]) -> SparkDataFrame:
-        def mapper_udf(x):
-            return [mapping.get(value) for value in x]  # pragma: no cover
+        other_columns = [col for col in df.columns if col != self._col]
 
-        mapping = self.get_mapping()
-        call_mapper_udf = sf.udf(mapper_udf, ArrayType(IntegerType()))
-        encoded_df = df.withColumn(self._target_col, call_mapper_udf(sf.col(self.column)))
+        mapping_on_spark = get_spark_session().createDataFrame(
+            data=list(self.get_mapping().items()), schema=[self._col, self._target_col]
+        )
+        encoded_df = (
+            df.select(*other_columns, sf.posexplode(self._col))
+            .withColumnRenamed("col", self._col)
+            .join(mapping_on_spark, on=self._col, how="left")
+        )
+
+        if self._handle_unknown == "error":
+            if encoded_df.filter(sf.col(self._target_col).isNull()).count() > 0:
+                msg = f"Found unknown labels in column {self._col} during transform"
+                raise ValueError(msg)
+        else:
+            if default_value is not None:
+                encoded_df = encoded_df.fillna(default_value, subset=[self._target_col])
 
+        result = encoded_df.groupBy(other_columns).agg(
+            sf.sort_array(sf.collect_list(sf.struct("pos", self._target_col)))
+            .getItem(self._target_col)
+            .alias(self._col)
+        )
         if self._handle_unknown == "drop":
-            encoded_df = encoded_df.withColumn(self._target_col, sf.filter(self._target_col, lambda x: x.isNotNull()))
-            if encoded_df.select(sf.max(sf.size(self._target_col))).first()[0] == 0:
+            result = result.withColumn(self._col, sf.filter(self._col, lambda x: x.isNotNull()))
+            if result.select(sf.max(sf.size(self._col))).first()[0] == 0:
                 warnings.warn(
                     f"You are trying to transform dataframe with all values are unknown for {self._col}, "
                     "with `handle_unknown_strategy=drop` leads to empty dataframe",
                     LabelEncoderTransformWarning,
                 )
-        elif self._handle_unknown == "error":
-            if (
-                encoded_df.select(sf.sum(sf.array_contains(self._target_col, -1).isNull().cast("integer"))).first()[0]
-                != 0
-            ):
-                msg = f"Found unknown labels in column {self._col} during transform"
-                raise ValueError(msg)
-        else:
-            if default_value:
-                encoded_df = encoded_df.withColumn(
-                    self._target_col,
-                    sf.transform(self._target_col, lambda x: sf.when(x.isNull(), default_value).otherwise(x)),
-                )
 
-        result_df = encoded_df.drop(self._col).withColumnRenamed(self._target_col, self._col)
-        return result_df
+        return result
 
     def _transform_pandas(self, df: PandasDataFrame, default_value: Optional[int]) -> PandasDataFrame:
         mapping = self.get_mapping()
@@ -771,7 +774,7 @@ class SequenceEncodingRule(LabelEncodingRule):
     def _inverse_transform_spark(self, df: SparkDataFrame) -> SparkDataFrame:
         array_expr = sf.array([sf.lit(x) for x in self._inverse_mapping_list])
         decoded_df = df.withColumn(
-            self._target_col, sf.transform(self._col, lambda x: sf.element_at(array_expr, x + 1))
+            self._target_col, sf.transform(self._col, lambda x: sf.element_at(array_expr, x.cast("int") + 1))
         )
         return decoded_df.drop(self._col).withColumnRenamed(self._target_col, self._col)
 
@@ -800,19 +803,19 @@ class LabelEncoder:
     >>> mapped_interactions = encoder.fit_transform(user_interactions)
     >>> mapped_interactions
        user_id  item_1  item_2  list
-    0        0       0       0  [0, 1, 2]
-    1        1       1       1  [2, 3, 4]
-    2        2       2       2  [5, 6, 3]
+    0        0       0       0  [2, 3, 4]
+    1        1       1       1  [4, 5, 6]
+    2        2       2       2  [1, 0, 5]
     >>> encoder.mapping
     {'user_id': {'u1': 0, 'u2': 1, 'u3': 2},
     'item_1': {'item_1': 0, 'item_2': 1, 'item_3': 2},
     'item_2': {'item_1': 0, 'item_2': 1, 'item_3': 2},
-    'list': {1: 0, 2: 1, 3: 2, 4: 3, 5: 4, -1: 5, -2: 6}}
+    'list': {-2: 0, -1: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6}}
     >>> encoder.inverse_mapping
     {'user_id': {0: 'u1', 1: 'u2', 2: 'u3'},
     'item_1': {0: 'item_1', 1: 'item_2', 2: 'item_3'},
     'item_2': {0: 'item_1', 1: 'item_2', 2: 'item_3'},
-    'list': {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: -1, 6: -2}}
+    'list': {0: -2, 1: -1, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5}}
     >>> new_encoder = LabelEncoder([
     ...    LabelEncodingRule("user_id", encoder.mapping["user_id"]),
     ...    LabelEncodingRule("item_1", encoder.mapping["item_1"]),
@@ -834,14 +837,14 @@ class LabelEncoder:
         self.rules = rules
 
     @property
-    def mapping(self) -> Mapping[str, Mapping]:
+    def mapping(self) -> dict[str, Mapping]:
         """
         Returns mapping of each column in given rules.
         """
         return {r.column: r.get_mapping() for r in self.rules}
 
     @property
-    def inverse_mapping(self) -> Mapping[str, Mapping]:
+    def inverse_mapping(self) -> dict[str, Mapping]:
         """
         Returns inverse mapping of each column in given rules.
         """

replay/preprocessing/utils.py

@@ -0,0 +1,209 @@
+import logging
+from typing import (
+    Literal,
+    Optional,
+    Sequence,
+)
+
+import pandas as pd
+import polars as pl
+
+from replay.utils import (
+    PYSPARK_AVAILABLE,
+    DataFrameLike,
+    PandasDataFrame,
+    PolarsDataFrame,
+    SparkDataFrame,
+)
+
+if PYSPARK_AVAILABLE:
+    import pyspark.sql.functions as sf
+
+
+def _ensure_columns_match(df, ref_cols, index: int, check_columns: bool) -> None:
+    if check_columns and set(df.columns) != set(ref_cols):
+        msg = f"Columns mismatch in dataframe #{index}: {sorted(df.columns)} != {sorted(ref_cols)}"
+        raise ValueError(msg)
+
+
+def _merge_subsets_pandas(
+    dfs: Sequence[PandasDataFrame],
+    columns: Optional[Sequence[str]],
+    check_columns: bool,
+    subset_for_duplicates: Optional[Sequence[str]],
+    on_duplicate: Literal["error", "drop", "ignore"],
+) -> PandasDataFrame:
+    ref_cols = list(dfs[0].columns) if columns is None else list(columns)
+
+    aligned: list[PandasDataFrame] = []
+    for i, df in enumerate(dfs):
+        _ensure_columns_match(df, ref_cols, i, check_columns)
+        aligned.append(df[ref_cols])
+
+    merged = pd.concat(aligned, axis=0, ignore_index=True)
+
+    if on_duplicate == "ignore":
+        return merged
+
+    dup_subset = ref_cols if subset_for_duplicates is None else list(subset_for_duplicates)
+    dup_mask = merged.duplicated(subset=dup_subset, keep="first")
+    dup_count = int(dup_mask.sum())
+
+    if dup_count > 0:
+        if on_duplicate == "error":
+            msg = f"Found {dup_count} duplicate rows on subset {dup_subset}"
+            raise ValueError(msg)
+        if on_duplicate == "drop":
+            merged = merged.drop_duplicates(subset=dup_subset, keep="first").reset_index(drop=True)
+            logging.getLogger("replay").warning(
+                f"Found {dup_count} duplicate rows on subset {dup_subset} and dropped them"
+            )
+
+    return merged
+
+
+def _merge_subsets_polars(
+    dfs: Sequence[PolarsDataFrame],
+    columns: Optional[Sequence[str]],
+    check_columns: bool,
+    subset_for_duplicates: Optional[Sequence[str]],
+    on_duplicate: Literal["error", "drop", "ignore"],
+) -> PolarsDataFrame:
+    ref_cols = list(dfs[0].columns) if columns is None else list(columns)
+
+    aligned: list[PolarsDataFrame] = []
+    for i, df in enumerate(dfs):
+        _ensure_columns_match(df, ref_cols, i, check_columns)
+        aligned.append(df.select(ref_cols))
+
+    merged = pl.concat(aligned, how="vertical")
+
+    if on_duplicate == "ignore":
+        return merged
+
+    dup_subset = ref_cols if subset_for_duplicates is None else list(subset_for_duplicates)
+    dup_mask = merged.select(dup_subset).is_duplicated()
+    dup_count = int(dup_mask.sum())
+
+    if dup_count > 0:
+        if on_duplicate == "error":
+            msg = f"Found {dup_count} duplicate rows on subset {dup_subset}"
+            raise ValueError(msg)
+        if on_duplicate == "drop":
+            merged = merged.unique(subset=dup_subset, keep="first", maintain_order=True)
+            logging.getLogger("replay").warning(
+                f"Found {dup_count} duplicate rows on subset {dup_subset} and dropped them"
+            )
+
+    return merged
+
+
+def _merge_subsets_spark(
+    dfs: Sequence[SparkDataFrame],
+    columns: Optional[Sequence[str]],
+    check_columns: bool,
+    subset_for_duplicates: Optional[Sequence[str]],
+    on_duplicate: Literal["error", "drop", "ignore"],
+) -> SparkDataFrame:
+    ref_cols = list(dfs[0].columns) if columns is None else list(columns)
+
+    merged = None
+    for i, df in enumerate(dfs):
+        _ensure_columns_match(df, ref_cols, i, check_columns)
+        part = df.select(*ref_cols)
+        merged = part if merged is None else merged.unionByName(part)
+
+    if on_duplicate == "ignore":
+        return merged
+
+    dup_subset = ref_cols if subset_for_duplicates is None else list(subset_for_duplicates)
+    if on_duplicate == "error" and merged.groupBy(*dup_subset).count().filter(sf.col("count") > 1).limit(1).count() > 0:
+        msg = f"Found duplicate rows on subset {dup_subset}"
+        raise ValueError(msg)
+    if on_duplicate == "drop":
+        unique = merged.dropDuplicates(dup_subset)
+        logging.getLogger("replay").warning(
+            f"Found {merged.count() - unique.count()} duplicate rows on subset {dup_subset} and dropped them"
+        )
+        merged = unique
+
+    return merged
+
+
+def merge_subsets(
+    dfs: Sequence[DataFrameLike],
+    columns: Optional[Sequence[str]] = None,
+    check_columns: bool = True,
+    subset_for_duplicates: Optional[Sequence[str]] = None,
+    on_duplicate: Literal["error", "drop", "ignore"] = "error",
+) -> DataFrameLike:
+    """Merge multiple dataframes of the same backend into a single one.
+
+    All inputs must be of the same dataframe type (pandas/Polars/Spark). Before
+    concatenation, each dataframe is aligned to a common set of columns: either
+    the provided ``columns`` or the columns of the first dataframe. Duplicate
+    rows are handled according to ``on_duplicate``.
+
+    Parameters
+    ----------
+    dfs : Sequence[DataFrameLike]
+        Dataframes to merge.
+    columns : Optional[Sequence[str]]
+        Columns to align to. If ``None``, columns of the first dataframe are used.
+    check_columns : bool
+        Whether to validate that all inputs have the same column set.
+    subset_for_duplicates : Optional[Sequence[str]]
+        Columns subset used to detect duplicates. If ``None``, all aligned columns
+        are used.
+    on_duplicate : {"error", "drop", "ignore"}
+        How to handle duplicates: raise an error, drop them, or ignore.
+
+    Returns
+    -------
+    DataFrameLike
+        Merged dataframe of the same backend as the inputs.
+
+    Raises
+    ------
+    ValueError
+        If ``dfs`` is empty, if duplicates are found with ``on_duplicate='error'``,
+        or if column sets differ when validation is enabled.
+    TypeError
+        If inputs are of different dataframe types.
+    """
+    if not dfs:
+        msg = "At least one dataframe is required"
+        raise ValueError(msg)
+
+    first = dfs[0]
+    if any(not isinstance(df, type(first)) for df in dfs):
+        msg = "All input dataframes must be of the same type"
+        raise TypeError(msg)
+
+    if isinstance(first, PandasDataFrame):
+        return _merge_subsets_pandas(
+            dfs,
+            columns=columns,
+            check_columns=check_columns,
+            subset_for_duplicates=subset_for_duplicates,
+            on_duplicate=on_duplicate,
+        )
+    if isinstance(first, PolarsDataFrame):
+        return _merge_subsets_polars(
+            dfs,
+            columns=columns,
+            check_columns=check_columns,
+            subset_for_duplicates=subset_for_duplicates,
+            on_duplicate=on_duplicate,
+        )
+    if isinstance(first, SparkDataFrame):
+        return _merge_subsets_spark(
+            dfs,
+            columns=columns,
+            check_columns=check_columns,
+            subset_for_duplicates=subset_for_duplicates,
+            on_duplicate=on_duplicate,
+        )
+
+    msg = f"Unsupported data frame type: {type(first)}"
+    raise NotImplementedError(msg)

replay/splitters/__init__.py

@@ -7,6 +7,7 @@ from .cold_user_random_splitter import ColdUserRandomSplitter
 from .k_folds import KFolds
 from .last_n_splitter import LastNSplitter
 from .new_users_splitter import NewUsersSplitter
+from .random_next_n_splitter import RandomNextNSplitter
 from .random_splitter import RandomSplitter
 from .ratio_splitter import RatioSplitter
 from .time_splitter import TimeSplitter