{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Examples of data objects" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The library supports three data types `Tabular`, `Image` and `Text` defined in the modules `omnixai.data.tabular`, `omnixai.data.image` and `omnixai.data.text`, respectively. All the supported explainers take one of these data objects as their inputs when generating explanations, e.g., an explainer vision tasks takes an `Image` object as its input. These data objects can be constructed easily from pandas dataframes, numpy arrays, Pillow images or strings. This notebook will show how to use these data objects." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Tabular data\n", "Suppose we have a pandas dataframe representing a tabular dataset with both categorical and continuous-valued features:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "\n", "df = pd.DataFrame(\n", " data=[[1, 2, 3, 'male'], [4, 5, 6, 'female']],\n", " columns=['a', 'b', 'c', 'd']\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first three columns are continuous-valued features and the last column is the categorical feature. Given this dataframe, we can easily construct a `Tabular` instance by specifying the dataframe and the categorical columns:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " a b c d\n", "0 1 2 3 male\n", "1 4 5 6 female\n" ] } ], "source": [ "from omnixai.data.tabular import Tabular\n", "\n", "x = Tabular(\n", " data=df,\n", " categorical_columns=['d']\n", ")\n", "print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to construct a `Tabular` instance with a numpy array, we need to set the feature columns:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " a b c d\n", "0 1 2 3 male\n", "1 4 5 6 female\n" ] } ], "source": [ "x = Tabular(\n", " data=df.values,\n", " feature_columns=['a', 'b', 'c', 'd'],\n", " categorical_columns=['d']\n", ")\n", "print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`Tabular` has several useful methods:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Shape: (2, 4)\n", "Raw values:\n", " [[1 2 3 'male']\n", " [4 5 6 'female']]\n", "Categorical features: ['d']\n", "Continuous-valued features: ['a', 'b', 'c']\n", "All feature columns: ['a', 'b', 'c', 'd']\n" ] } ], "source": [ "# Get the data shape\n", "print(f\"Shape: {x.shape}\")\n", "# Get the raw data values\n", "print(f\"Raw values:\\n {x.values}\")\n", "# Get the categorical feature columns\n", "print(f\"Categorical features: {x.categorical_columns}\")\n", "# Get the continuous-valued feature columns\n", "print(f\"Continuous-valued features: {x.continuous_columns}\")\n", "# Get all the feature columns\n", "print(f\"All feature columns: {x.feature_columns}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A `Tabular` instance can be converted into a pandas dataframe or a numpy array:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " a b c d\n", "0 1 2 3 male\n", "1 4 5 6 female\n", "[[1 2 3 'male']\n", " [4 5 6 'female']]\n" ] } ], "source": [ "print(x.to_pd())\n", "print(x.to_numpy())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The dataset represented by `Tabular` may have a target/label column, e.g., class labels in classification tasks. In the following example, the last column is the target/label column." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "df = pd.DataFrame(\n", " data=[[1, 2, 3, 'male', 'yes'], [4, 5, 6, 'female', 'no']],\n", " columns=['a', 'b', 'c', 'd', 'label']\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To construct a `Tabular` instance, besides setting categorical feature columns, we also need to set the target/label column:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " a b c d label\n", "0 1 2 3 male yes\n", "1 4 5 6 female no\n", "Target column: label\n" ] } ], "source": [ "x = Tabular(\n", " data=df,\n", " categorical_columns=['d'],\n", " target_column='label'\n", ")\n", "print(x)\n", "print(f\"Target column: {x.target_column}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To get a subset of the rows of `x`:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The first row:\n", " a b c d label\n", "0 1 2 3 male yes\n", "The second row:\n", " a b c d label\n", "1 4 5 6 female no\n", "Swap the two rows:\n", " a b c d label\n", "1 4 5 6 female no\n", "0 1 2 3 male yes\n" ] } ], "source": [ "print(\"The first row:\")\n", "print(x[0])\n", "print(\"The second row:\")\n", "print(x[1])\n", "print(\"Swap the two rows:\")\n", "print(x[[1, 0]])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Image data\n", "An `Image` object can be constructed from a numpy array (a batch of images) or a Pillow image. For example, a numpy array contains a batch of MNIST digit images:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(10000, 28, 28)\n" ] } ], "source": [ "import torchvision\n", "\n", "test_data = torchvision.datasets.MNIST(root='../data', train=False, download=True)\n", "imgs = test_data.data.numpy()\n", "print(imgs.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An `Image` object can be created as follows:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "from omnixai.data.image import Image\n", "\n", "# `batched = True` means `data` contains a batch of images with \n", "# shape `(batch_size, height, width)` or `(batch_size, height, width, channel)`.\n", "images = Image(data=imgs, batched=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here are some useful functions:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data shape: (10000, 28, 28, 1)\n", "Image shape: (28, 28, 1)\n", "The first image (Pillow):\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAxUlEQVR4nGNgGDaAEUKFpD77sfTFHeyS9xQYGBg+X4UKPuk6w8DAwMDAAuGm6l/TMnSweCzLwPDntSTDozPIOhkYGBgYBA3PmDIw/Lh1XShnGi5nBP+9KIRLTuzl/2AokwlDMlv0/U1cGq1//rPDJcfQ+m83Ky45zrM/rHBqrPu3Daec9+8PlrjkhO/+W4ZLjvn0v9vKuCTV/v3zxSUn/+BfMSMuydZ//0xwydl+QpdEClsbHoa7X1AkWZA5F53f4TIWEwAAaRE8kJuHrgAAAAAASUVORK5CYII=\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "The second image (Pillow):\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA6ElEQVR4nGNgoAlgRDBLOPVCGKYfX4xN2cq/f//+/fv3lhwOuat9G/7+rcKUM/n195ICDwPbub89mJK+vy9JMjAwVP3464jFWHkhBgYGhot/sUoyMDAwMJR+/3uMC4ecz/e/z+2R+EwormJjWHkQh8YN3/7O58EhJ/nq70tlXK459vdvLy45vx9/9+IyVPgEHo1tf/+uxaWR4cffv5LoYixIbKHfDAwMH3+z8jMIFjIw/C3/hix5iYGBgWH1c/FwCPdFKzwlrPNHqPrzj2HTGYYjxxHJpIyVgUE7nIFh3gOGdddxuWyAAQCfcVM+FkfDOQAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Loop:\n", "(1, 28, 28, 1)\n", "(1, 28, 28, 1)\n", "(1, 28, 28, 1)\n", "(1, 28, 28, 1)\n", "(1, 28, 28, 1)\n" ] } ], "source": [ "print(f\"Data shape: {images.shape}\")\n", "print(f\"Image shape: {images.image_shape}\")\n", "\n", "print(f\"The first image (Pillow):\")\n", "display(images[0].to_pil())\n", "print(f\"The second image (Pillow):\")\n", "display(images[1].to_pil())\n", "\n", "print(\"Loop:\")\n", "for im in images[:5]:\n", " print(im.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also convert `Image` into a numpy array:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Numpy array shape: (10000, 28, 28)\n", "Numpy array shape: (10000, 28, 28, 1)\n", "Numpy array shape: (10000, 1, 28, 28)\n" ] } ], "source": [ "print(f\"Numpy array shape: {images.to_numpy().shape}\")\n", "print(f\"Numpy array shape: {images.to_numpy(keepdim=True).shape}\")\n", "print(f\"Numpy array shape: {images.to_numpy(hwc=False, keepdim=True).shape}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A color image example:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data shape: (1, 224, 224, 3)\n", "Image shape: (224, 224, 3)\n", "The image (Pillow):\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from PIL import Image as PilImage\n", "\n", "img = Image(PilImage.open('../data/images/camera.jpg').convert('RGB'))\n", "print(f\"Data shape: {img.shape}\")\n", "print(f\"Image shape: {img.image_shape}\")\n", "print(f\"The image (Pillow):\")\n", "# `to_pil` returns a single Pillow image if `batch_size = 1` or a list of Pillow images if `batch_size > 1`.\n", "display(img.to_pil())" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Numpy array shape: (1, 224, 224, 3)\n", "Numpy array shape: (1, 224, 224, 3)\n", "Numpy array shape: (1, 3, 224, 224)\n" ] } ], "source": [ "print(f\"Numpy array shape: {img.to_numpy().shape}\")\n", "print(f\"Numpy array shape: {img.to_numpy(keepdim=True).shape}\")\n", "print(f\"Numpy array shape: {img.to_numpy(hwc=False, keepdim=True).shape}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Text data\n", "A `Text` object represents a batch of texts or sentences stored in a list. For example," ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "from omnixai.data.text import Text\n", "\n", "x = Text([\n", " \"What a great movie! if you have no taste.\",\n", " \"it was a fantastic performance!\",\n", " \"best film ever\",\n", " \"such a great show!\",\n", " \"it was a horrible movie\",\n", " \"i've never watched something as bad\"\n", "])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here are some useful functions:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of sentences: 6\n", "The first sentence: ['What a great movie! if you have no taste.']\n", "Raw strings: ['What a great movie! if you have no taste.', 'it was a fantastic performance!', 'best film ever', 'such a great show!', 'it was a horrible movie', \"i've never watched something as bad\"]\n" ] } ], "source": [ "print(f\"Number of sentences: {len(x)}\")\n", "print(f\"The first sentence: {x[0]}\")\n", "print(f\"Raw strings: {x.values}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Convert texts/sentences into a list of tokens:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[['what', 'a', 'great', 'movie', '!', 'if', 'you', 'have', 'no', 'taste', '.'], ['it', 'was', 'a', 'fantastic', 'performance', '!'], ['best', 'film', 'ever'], ['such', 'a', 'great', 'show', '!'], ['it', 'was', 'a', 'horrible', 'movie'], ['i', \"'ve\", 'never', 'watched', 'something', 'as', 'bad']]\n" ] } ], "source": [ "print(x.to_tokens())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Time series data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `Timeseries` class represents a time series. The values of metrics/variables are stored in a numpy array\n", "with shape `(timestamps, num_variables)`. We can construct a ``Timeseries`` instance from a pandas dataframe, where the index indicates the timestamps and the columns are the variables." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "from omnixai.data.timeseries import Timeseries\n", "df = pd.DataFrame(\n", " [['2017-12-27', 1263.94091, 394.507, 16.530],\n", " ['2017-12-28', 1299.86398, 506.424, 14.162],\n", " ['2017-12-29', 1319.76541, 610.314, 15.173]],\n", " columns=['Date', 'Consumption', 'Wind', 'Solar']\n", ")\n", "df = df.set_index('Date')\n", "df.index = pd.to_datetime(df.index)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Consumption Wind Solar\n", "2017-12-27 1263.94091 394.507 16.530\n", "2017-12-28 1299.86398 506.424 14.162\n", "2017-12-29 1319.76541 610.314 15.173\n" ] } ], "source": [ "ts = Timeseries.from_pd(df)\n", "print(ts)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here are some useful functions:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Length of ts: 3\n", "Length of ts: 3\n", "Metrics: ['Consumption', 'Wind', 'Solar']\n", "Time-series shape: (3, 3)\n", "Select rows:\n", " Consumption Wind Solar\n", "2017-12-28 1299.86398 506.424 14.162\n", "2017-12-27 1263.94091 394.507 16.530\n", "To pandas dataframe:\n", " Consumption Wind Solar\n", "2017-12-27 1263.94091 394.507 16.530\n", "2017-12-28 1299.86398 506.424 14.162\n", "2017-12-29 1319.76541 610.314 15.173\n" ] } ], "source": [ "print(f\"Length of ts: {len(ts)}\")\n", "print(f\"Length of ts: {ts.ts_len}\")\n", "print(f\"Metrics: {ts.columns}\")\n", "print(f\"Time-series shape: {ts.shape}\")\n", "print(\"Select rows:\")\n", "print(ts[[1, 0]])\n", "print(\"To pandas dataframe:\")\n", "print(ts.to_pd())" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.5" } }, "nbformat": 4, "nbformat_minor": 2 }