Demonstrates the compatibility between Feather and TensorFlow with a real dataset.

feather-tf-poc-bytes.ipynb

feather-tf-poc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9bbe93c8",
   "metadata": {},
   "source": [
    "## Flowers dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6827b5db",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -q https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz -O flower_photos.tgz\n",
    "!tar xf flower_photos.tgz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d411bfdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "import glob\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fb3f64b",
   "metadata": {},
   "source": [
    "## Collect image paths and derive labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "291ee5c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['flower_photos/roses/16209331331_343c899d38.jpg',\n",
       "  'flower_photos/roses/5777669976_a205f61e5b.jpg',\n",
       "  'flower_photos/roses/4860145119_b1c3cbaa4e_n.jpg',\n",
       "  'flower_photos/roses/15011625580_7974c44bce.jpg',\n",
       "  'flower_photos/roses/17953368844_be3d18cf30_m.jpg'],\n",
       " 3670)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image_paths = glob.glob(\"flower_photos/*/*.jpg\")\n",
    "image_paths[:5], len(image_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8a69e7a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['roses', 'roses', 'roses', 'roses', 'roses']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_labels = list(map(lambda x: x.split(\"/\")[1], image_paths))\n",
    "all_labels[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "055f907b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique_labels = sorted(set(all_labels))\n",
    "label2_id = {label: idx for idx, label in enumerate(unique_labels)}\n",
    "label2_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b74fcedc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2, 2, 2, 2]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_integer_labels = list(map(lambda x: label2_id.get(x), all_labels))\n",
    "all_integer_labels[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0673d274",
   "metadata": {},
   "source": [
    "## Write into shards of Feather files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c08b9025",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyarrow.feather import write_feather\n",
    "import pyarrow as pa\n",
    "import tqdm\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "51c1f0f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 1000\n",
    "chunk_size = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "266f50a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_image(path):\n",
    "    image = tf.io.read_file(path)\n",
    "    image = tf.image.decode_png(image, 3)\n",
    "    image = tf.image.resize(image, (64, 64))\n",
    "    image = tf.cast(image, tf.uint8).numpy()\n",
    "    return image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d72c3eb",
   "metadata": {},
   "source": [
    "There is a potential caveat. We're having to resize the images to a uniform resolution fore serializing. There's probably support for not having to do it. I haven't figured it out yet. I kept the resizing resolution intentionally low. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f7e8dd25",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/z_/d29z43w90kz6f4kbzv5c9m9r0000gn/T/ipykernel_73443/2664877068.py:9: TqdmDeprecationWarning: Please use `tqdm.notebook.trange` instead of `tqdm.tnrange`\n",
      "  for step in tqdm.tnrange(int(math.ceil(len(image_paths) / batch_size))):\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8622d78ab209454bac3d34ceabfb170a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total images written: 1000.\n",
      "Total images written: 2000.\n",
      "Total images written: 3000.\n",
      "Total images written: 3670.\n"
     ]
    }
   ],
   "source": [
    "# Taken from (with some mods):\n",
    "\n",
    "# https://towardsdatascience.com/data-formats-for-training-in-tensorflow-parquet-petastorm-feather-and-more-e55179eeeb72\n",
    "\n",
    "# Can be done in a distributed manner.\n",
    "\n",
    "total_images_written = 0\n",
    "\n",
    "for step in tqdm.tnrange(int(math.ceil(len(image_paths) / batch_size))):\n",
    "    batch_image_paths = image_paths[step * batch_size : (step + 1) * batch_size]\n",
    "    batch_image_labels = all_integer_labels[step * batch_size : (step + 1) * batch_size]\n",
    "\n",
    "    data = [read_image(path).flatten() for path in batch_image_paths]\n",
    "    labels = batch_image_labels\n",
    "    table = pa.Table.from_arrays([data, labels], [\"data\", \"labels\"])\n",
    "    write_feather(table, f\"/tmp/flowers_feather_{step}.feather\", chunksize=chunk_size)\n",
    "    total_images_written += len(batch_image_paths)\n",
    "    print(f\"Total images written: {total_images_written}.\")\n",
    "\n",
    "    del data, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0f785479",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r--  1 sayakpaul  wheel   144M Jun 23 17:54 /tmp/df.feather\r\n",
      "-rw-r--r--  1 sayakpaul  wheel    11M Jun 23 18:02 /tmp/flowers_feather_0.feather\r\n",
      "-rw-r--r--  1 sayakpaul  wheel    11M Jun 23 18:02 /tmp/flowers_feather_1.feather\r\n",
      "-rw-r--r--  1 sayakpaul  wheel    11M Jun 23 18:02 /tmp/flowers_feather_2.feather\r\n",
      "-rw-r--r--  1 sayakpaul  wheel   7.7M Jun 23 18:02 /tmp/flowers_feather_3.feather\r\n"
     ]
    }
   ],
   "source": [
    "!ls -lh /tmp/*.feather"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05a58126",
   "metadata": {},
   "source": [
    "## Loading the Feather files into `tf.data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a66a9b02",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow_io.arrow as arrow_io"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85bbee91",
   "metadata": {},
   "source": [
    "### From single Feather file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "02acf656",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-23 18:06:29.670200: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:06:29.670224: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n"
     ]
    }
   ],
   "source": [
    "dataset = arrow_io.ArrowFeatherDataset(\n",
    "    [\"/tmp/flowers_feather_0.feather\"],\n",
    "    columns=(0, 1),\n",
    "    output_types=(tf.uint8, tf.int64),\n",
    "    output_shapes=([64 * 64 * 3], []),\n",
    "    batch_size=32,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8e99b0eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorSpec(shape=(None, 12288), dtype=tf.uint8, name=None),\n",
       " TensorSpec(shape=(None,), dtype=tf.int64, name=None))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.element_spec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "aa53b968",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-23 18:06:32.666834: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:06:32.666861: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:06:32.666985: E tensorflow/core/framework/dataset.cc:580] FAILED_PRECONDITION: Cannot compute input sources for dataset of type RootDataset, because sources could not be computed for input dataset of type IO>ArrowFeatherDataset\n"
     ]
    }
   ],
   "source": [
    "for batch in dataset:\n",
    "    image_batch = batch[0].numpy().reshape(-1, 64, 64, 3)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "40567270",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(image_batch[19].squeeze())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "20f99fe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf /tmp/df.feather"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51216243",
   "metadata": {},
   "source": [
    "### A batched dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "8b95f20c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://towardsdatascience.com/data-formats-for-training-in-tensorflow-parquet-petastorm-feather-and-more-e55179eeeb72\n",
    "def get_dataset():\n",
    "    autotune = tf.data.AUTOTUNE\n",
    "    filenames = tf.data.Dataset.list_files(\"/tmp/*.feather\", shuffle=True)\n",
    "\n",
    "    def make_ds(file):\n",
    "        ds = arrow_io.ArrowFeatherDataset(\n",
    "            [file],\n",
    "            [0, 1],\n",
    "            output_types=(tf.uint8, tf.int64),\n",
    "            output_shapes=([64 * 64 * 3], []),\n",
    "            batch_size=32,\n",
    "        )\n",
    "        return ds\n",
    "\n",
    "    ds = filenames.interleave(make_ds, num_parallel_calls=autotune, deterministic=False)\n",
    "    return ds.prefetch(autotune)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "04c69170",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorSpec(shape=(None, 12288), dtype=tf.uint8, name=None),\n",
       " TensorSpec(shape=(None,), dtype=tf.int64, name=None))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parallel_ds = get_dataset()\n",
    "parallel_ds.element_spec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b9db5b95",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-23 18:18:15.240738: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.240761: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.240894: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.240914: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.241008: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.241028: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.241122: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:18:15.241139: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n"
     ]
    }
   ],
   "source": [
    "for batch in parallel_ds:\n",
    "    image_batch = batch[0].numpy().reshape(-1, 64, 64, 3)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0c5ab26e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(image_batch[19].squeeze())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d217a2d",
   "metadata": {},
   "source": [
    "## Explicit batching + mapping a preprocessing fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c4b19e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mod + some taken from\n",
    "# https://towardsdatascience.com/data-formats-for-training-in-tensorflow-parquet-petastorm-feather-and-more-e55179eeeb72\n",
    "def get_dataset_no_batch():\n",
    "    autotune = tf.data.AUTOTUNE\n",
    "    filenames = tf.data.Dataset.list_files(\"/tmp/*.feather\", shuffle=True)\n",
    "\n",
    "    def make_ds(file):\n",
    "        ds = arrow_io.ArrowFeatherDataset(\n",
    "            [file],\n",
    "            [0, 1],\n",
    "            output_types=(tf.uint8, tf.int64),\n",
    "            output_shapes=([64 * 64 * 3], []),\n",
    "            batch_mode=\"auto\",\n",
    "        )\n",
    "        return ds\n",
    "\n",
    "    ds = filenames.interleave(make_ds, num_parallel_calls=autotune, deterministic=False)\n",
    "    ds = ds.unbatch()\n",
    "    ds = ds.batch(32)\n",
    "    ds = ds.map(\n",
    "        lambda x, y: (tf.cast(x, tf.float32) / 255, y), num_parallel_calls=autotune\n",
    "    )\n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "19472fe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_no_batch = get_dataset_no_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "3fc5c84b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorSpec(shape=(None, 12288), dtype=tf.float32, name=None),\n",
       " TensorSpec(shape=(None,), dtype=tf.int64, name=None))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset_no_batch.element_spec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "53196855",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 12288)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-23 18:19:45.585394: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585416: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585551: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585570: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585696: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585728: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585847: E tensorflow/core/framework/dataset.cc:580] UNIMPLEMENTED: Cannot compute input sources for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n",
      "2022-06-23 18:19:45.585864: E tensorflow/core/framework/dataset.cc:584] UNIMPLEMENTED: Cannot merge options for dataset of type IO>ArrowFeatherDataset, because the dataset does not implement `InputDatasets`.\n"
     ]
    }
   ],
   "source": [
    "for sample in dataset_no_batch.take(1):\n",
    "    print(sample[0].shape)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}

feather-v2-struct-tfio.ipynb

feather-v2-tfio.ipynb

requirements.txt

tensorflow==2.9.1
tensorflow-io==0.26.0
pyarrow
tqdm