examples/playground.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install the sk-transform package from PyPI 🤖"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "! pip install sk-transformers"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sk-transformers playground 🛝\n",
    "\n",
    "\n",
    "In this notebook you can try transformers from the [sk-transformers](https://github.com/chrislemke/sk-transformers) package. \n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/chrislemke/sk-transformers/blob/main/examples/playground.ipynb)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Datetime transformer](https://chrislemke.github.io/sk-transformers/API-reference/transformer/datetime_transformer/)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`DateColumnsTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/datetime_transformer/#sk_transformers.datetime_transformer.DateColumnsTransformer)\n",
    "\n",
    "Splits a date column into multiple columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import DateColumnsTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"2021-01-01\", \"2022-02-02\", \"2023-03-03\"]})\n",
    "transformer = DateColumnsTransformer([\"foo\"])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`DurationCalculatorTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/datetime_transformer/#sk_transformers.datetime_transformer.DurationCalculatorTransformer)\n",
    "\n",
    "Calculates the duration between to given dates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import DurationCalculatorTransformer\n",
    "\n",
    "X = pd.DataFrame(\n",
    "    {\n",
    "        \"foo\": [\"1960-01-01\", \"1970-01-01\", \"1990-01-01\"],\n",
    "        \"bar\": [\"1960-01-01\", \"1971-01-01\", \"1988-01-01\"],\n",
    "    }\n",
    ")\n",
    "transformer = DurationCalculatorTransformer((\"foo\", \"bar\"), \"days\", \"foo_bar_duration\")\n",
    "transformer.fit_transform(X)[\"foo_bar_duration\"].to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`TimestampTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/datetime_transformer/#sk_transformers.datetime_transformer.TimestampTransformer)\n",
    "\n",
    "Transforms a date column with a specified format into a timestamp column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import TimestampTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"1960-01-01\", \"1970-01-01\", \"1990-01-01\"]})\n",
    "transformer = TimestampTransformer([\"foo\"])\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Encoder transformer](https://chrislemke.github.io/sk-transformers/API-reference/transformer/encoder_transformer/)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`MeanEncoderTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/encoder_transformer/#sk_transformers.encoder_transformer.MeanEncoderTransformer)\n",
    "\n",
    "Scikit-learn API for the [feature-engine MeanEncoder](https://feature-engine.readthedocs.io/en/latest/api_doc/encoding/MeanEncoder.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import MeanEncoderTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"a\", \"b\", \"a\", \"c\", \"b\", \"a\", \"c\", \"a\", \"b\", \"c\"]})\n",
    "y = pd.Series([1, 0, 1, 0, 1, 0, 1, 0, 1, 0])\n",
    "\n",
    "encoder = MeanEncoderTransformer()\n",
    "encoder.fit_transform(X, y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Generic transformer](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`AggregateTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.AggregateTransformer)\n",
    "\n",
    "This transformer uses Pandas `groupby` method and `aggregate` to apply function on a column grouped by another column.\n",
    "Read more about Pandas [`aggregate`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.aggregate.html) method\n",
    "to understand how to use function for aggregation. Other than Pandas function this transformer only support functions and string-names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import AggregateTransformer\n",
    "\n",
    "X = pd.DataFrame(\n",
    "    {\n",
    "        \"foo\": [\"mr\", \"mr\", \"ms\", \"ms\", \"ms\", \"mr\", \"mr\", \"mr\", \"mr\", \"ms\"],\n",
    "        \"bar\": [46, 32, 78, 48, 93, 68, 53, 38, 76, 56],\n",
    "    }\n",
    ")\n",
    "\n",
    "transformer = AggregateTransformer([(\"foo\", (\"bar\", \"mean\", \"bar_mean\"))])\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`ColumnDropperTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.ColumnDropperTransformer)\n",
    "\n",
    "Drops columns from a dataframe using Pandas `drop` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import ColumnDropperTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]})\n",
    "transformer = ColumnDropperTransformer([\"foo\"])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`ColumnEvalTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.ColumnEvalTransformer)\n",
    "\n",
    "Provides the possibility to use Pandas methods on columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import ColumnEvalTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"a\", \"b\", \"c\"], \"bar\": [1, 2, 3]})\n",
    "transformer = ColumnEvalTransformer(\n",
    "    [\n",
    "        (\"foo\", \"str.upper()\"),\n",
    "        (\n",
    "            \"bar\",\n",
    "            \"swifter.apply(lambda x: x + 1)\",\n",
    "        ),  # swifter is optional. But it speed up the process!\n",
    "    ]\n",
    ")\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`DtypeTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.DtypeTransformer)\n",
    "\n",
    "Transformer that converts a column to a different dtype."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sk_transformers import DtypeTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [\"a\", \"a\", \"b\"]})\n",
    "transformer = DtypeTransformer([(\"foo\", np.float32), (\"bar\", \"category\")])\n",
    "transformer.fit_transform(X).dtypes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`FunctionsTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.FunctionsTransformer)\n",
    "\n",
    "This transformer is a plain wrapper around the [`sklearn.preprocessing.FunctionTransformer`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.FunctionTransformer.html).\n",
    "Its main function is to apply multiple functions to different columns. Other than the scikit-learn transformer,\n",
    "this transformer *does not* support the `inverse_func`, `accept_sparse`, `feature_names_out` and, `inv_kw_args` parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import FunctionsTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]})\n",
    "transformer = FunctionsTransformer([(\"foo\", np.log1p, None), (\"bar\", np.sqrt, None)])\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`MapTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.MapTransformer)\n",
    "\n",
    "This transformer iterates over all columns in the `features` list and applies the given callback to the column. For this it uses the [`pandas.Series.map`](https://pandas.pydata.org/docs/reference/api/pandas.Series.map.html) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import MapTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]})\n",
    "transformer = MapTransformer([(\"foo\", lambda x: x + 1)])\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`LeftJoinTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.LeftJoinTransformer)\n",
    "\n",
    "Performs a database-style left-join using `pd.merge`. This transformer is suitable for\n",
    "replacing values in a column of a dataframe by looking-up another `pd.DataFrame`\n",
    "or `pd.Series`. Note that, the join is based on the index of the right dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import LeftJoinTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"A\", \"B\", \"C\", \"A\", \"C\"]})\n",
    "lookup_df = pd.Series([1, 2, 3], index=[\"A\", \"B\", \"C\"], name=\"values\")\n",
    "transformer = LeftJoinTransformer([(\"foo\", lookup_df)])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`NaNTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.NaNTransformer)\n",
    "\n",
    "Replace NaN values with a specified value. Internally Pandas [`fillna`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.fillna.html) method is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sk_transformers import NaNTransformer\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, np.NaN, 3], \"bar\": [\"a\", np.NaN, \"c\"]})\n",
    "transformer = NaNTransformer([(\"foo\", -999), (\"bar\", \"-999\")])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`QueryTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.QueryTransformer)\n",
    "\n",
    "Applies a list of queries to a dataframe.\n",
    "If it operates on a dataset used for supervised learning this transformer should\n",
    "be applied on the dataframe containing `X` and `y`. So removing of columns by queries\n",
    "also removes the corresponding `y` value.\n",
    "Read more about queries [here](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.query.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import QueryTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, 8, 3, 6, 5, 4, 7, 2]})\n",
    "transformer = QueryTransformer([\"foo > 4\"])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`ValueIndicatorTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.ValueIndicatorTransformer)\n",
    "\n",
    "Adds a column to a dataframe indicating if a value is equal to a specified value.\n",
    "The idea behind this method is, that it is often useful to know if a `NaN` value was\n",
    "present in the original data and has been changed by some imputation step.\n",
    "Sometimes the present of a `NaN` value is actually important information.\n",
    "But obviously this method works with any kind of data.\n",
    "\n",
    "`NaN`, `None` or `np.nan` are **Not** caught by this implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sk_transformers import ValueIndicatorTransformer\n",
    "import pandas as pd\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, -999, 3], \"bar\": [\"a\", \"-999\", \"c\"]})\n",
    "transformer = ValueIndicatorTransformer([(\"foo\", -999), (\"bar\", \"-999\")])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`ValueReplacerTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.ValueIndicatorTransformer)\n",
    "\n",
    "Uses Pandas `replace` method to replace values in a column. This transformer loops over the `features` and applies\n",
    "`replace` to the according columns. If the column is not from type string but a valid regular expression is provided\n",
    "the column will be temporarily changed to a string column and after the manipulation by `replace` changed back to its\n",
    "original type. It may happen, that this type changing fails if the modified column is not compatible with its original type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import ValueReplacerTransformer\n",
    "\n",
    "X = pd.DataFrame(\n",
    "    {\"foo\": [\"0000-01-01\", \"2022/01/08\", \"bar\", \"1982-12-7\", \"28-09-2022\"]}\n",
    ")\n",
    "transformer = ValueReplacerTransformer(\n",
    "    [\n",
    "        (\n",
    "            [\"foo\"],\n",
    "            r\"^(?!(19|20)\\d\\d[-\\/.](0[1-9]|1[012]|[1-9])[-\\/.](0[1-9]|[12][0-9]|3[01]|[1-9])$).*\",\n",
    "            \"1900-01-01\",\n",
    "        )\n",
    "    ]\n",
    ")\n",
    "\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`AllowedValuesTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/generic_transformer/#sk_transformers.generic_transformer.AllowedValuesTransformer)\n",
    "\n",
    "Replaces all values that are not in a list of allowed values with a replacement value.\n",
    "This performs an complementary transformation to that of the ValueReplacerTransformer.\n",
    "This is useful while lumping several minor categories together by selecting them\n",
    "using a list of major categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import AllowedValuesTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"a\", \"b\", \"c\", \"d\", \"e\"]})\n",
    "transformer = AllowedValuesTransformer([(\"foo\", [\"a\", \"b\"], \"other\")])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Number transformer](https://chrislemke.github.io/sk-transformers/API-reference/transformer/number_transformer/)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[`MathExpressionTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/number_transformer/#sk_transformers.number_transformer.MathExpressionTransformer)\n",
    "\n",
    "Applies an function/operation to a column and a given value or column.\n",
    "The operation can be a function from NumPy's [mathematical functions](https://numpy.org/doc/stable/reference/routines.math.html#mathematical-functions)  or [`operator`](https://docs.python.org/3/library/operator.html#module-operator) package.\n",
    "\n",
    "**Warning!** Some functions/operators may not work as expected. Especially not all NumPy methods are supported. For example:\n",
    "various NumPy methods return values which are not fitting the size of the source column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import MathExpressionTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]})\n",
    "transformer = MathExpressionTransformer([(\"foo\", \"np.add\", \"bar\", None)])\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`GeoDistanceTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/number_transformer/#sk_transformers.number_transformer.GeoDistanceTransformer)\n",
    "\n",
    "Calculates the distance in kilometers between two places on the earth using the latitudes and longitudes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import GeoDistanceTransformer\n",
    "\n",
    "X = pd.DataFrame(\n",
    "    {\n",
    "        \"lat_1\": [48.353802, 51.289501, 53.63040161],\n",
    "        \"long_1\": [11.7861, 6.76678, 9.988229752],\n",
    "        \"lat_2\": [51.289501, 53.63040161, 48.353802],\n",
    "        \"long_2\": [6.76678, 9.988229752, 11.7861],\n",
    "    }\n",
    ")\n",
    "transformer = GeoDistanceTransformer([(\"lat_1\", \"long_1\", \"lat_2\", \"long_2\")])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [String transformer](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`EmailTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.EmailTransformer)\n",
    "\n",
    "Transforms an email address into multiple features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import EmailTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"person-123@test.com\"]})\n",
    "transformer = EmailTransformer([\"foo\"])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`IPAddressEncoderTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.IPAddressEncoderTransformer)\n",
    "\n",
    "Encodes IPv4 and IPv6 strings addresses to a float representation.\n",
    "To shrink the values to a reasonable size IPv4 addresses are divided by 2^10 and IPv6 addresses are divided by 2^48.\n",
    "Those values can be changed using the `ip4_divisor` and `ip6_divisor` parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import IPAddressEncoderTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"192.168.1.1\", \"2001:0db8:3c4d:0015:0000:0000:1a2f:1a2b\"]})\n",
    "transformer = IPAddressEncoderTransformer([\"foo\"])\n",
    "transformer.fit_transform(X).to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`PhoneTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.PhoneTransformer)\n",
    "\n",
    "Transforms a phone number into multiple features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import PhoneTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"+49123456789\", \"0044987654321\", \"3167891234\"]})\n",
    "transformer = PhoneTransformer([\"foo\"])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`StringSimilarityTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.StringSimilarityTransformer)\n",
    "\n",
    "Calculates the similarity between two strings using the `gestalt pattern matching` algorithm from the `SequenceMatcher` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import StringSimilarityTransformer\n",
    "\n",
    "X = pd.DataFrame(\n",
    "    {\n",
    "        \"foo\": [\"abcdefgh\", \"ijklmnop\", \"qrstuvwx\"],\n",
    "        \"bar\": [\"ghabcdef\", \"ijklmnop\", \"qr000000\"],\n",
    "    }\n",
    ")\n",
    "transformer = StringSimilarityTransformer((\"foo\", \"bar\"))\n",
    "transformer.fit_transform(X)[\"foo_bar_similarity\"].to_numpy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`StringSlicerTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.StringSlicerTransformer)\n",
    "\n",
    "Slices all entries of specified string features using the `slice()` function.\n",
    "\n",
    "Note: The arguments for the `slice()` function are passed as a tuple. This shares\n",
    "the python quirk of writing a tuple with a single argument with the trailing comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import StringSlicerTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"abc\", \"def\", \"ghi\"], \"bar\": [\"jkl\", \"mno\", \"pqr\"]})\n",
    "transformer = StringSlicerTransformer([(\"foo\", (1, 3)), (\"bar\", (2,))])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`StringSplitterTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.StringSplitterTransformer)\n",
    "\n",
    "Uses the pandas `str.split` method to split a column of strings into multiple columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import StringSplitterTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"a_b\", \"c_d\", \"e_f\"], \"bar\": [\"g*h*i\", \"j*k*l\", \"m*n*o\"]})\n",
    "transformer = StringSplitterTransformer([(\"foo\", \"_\", 2), (\"bar\", \"*\", 3)])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [`StringCombinationTransformer`](https://chrislemke.github.io/sk-transformers/API-reference/transformer/string_transformer/#sk_transformers.string_transformer.StringCombinationTransformer)\n",
    "\n",
    "Contatenates two string columns after ordering them alphabetically first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sk_transformers import StringCombinationTransformer\n",
    "\n",
    "X = pd.DataFrame({\"foo\": [\"A\", \"B\", \"C\"], \"bar\": [\"B\", \"A\", \"A\"]})\n",
    "transformer = StringCombinationTransformer([(\"foo\", \"bar\", \"_\")])\n",
    "transformer.fit_transform(X)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**This is just the beginning. We will continue adding more transformers 🤖 to this notebook. If you have any suggestions, please [let us know](https://github.com/chrislemke/sk-transformers/issues). 🙏**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "trans",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "b1c12da3ed97ddc5d06f89ccebbe5e02fc09fe905c27ba70922f4e585b142a5b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}