Data Prep Kit is a community project to democratize and accelerate unstructured data preparation for LLM app developers. With the explosive growth of LLM-enabled use cases, developers are faced with the enormous challenge of preparing use case-specific unstructured data to fine-tune or instruct-tune the LLMs. As the variety of use cases grows, so does the need to support:
- New modalities of data (code, language, speech, visual)
- New ways of transforming the data to optimize the performance of the resulting LLMs for each specific use case.
- A large variety in the scale of data to be processed, from laptop-scale to datacenter-scale
Data Prep Kit offers implementations of commonly needed data transformations, called modules, for both Code and Language modalities. The goal is to offer high-level APIs for developers to quickly get started in working with their data, without needing expertise in the underlying runtimes and frameworks.
Data Prep Kit is a toolkit for streamlining data preparation for developers looking to build LLM-enabled applications via fine-tuning or instruction-tuning. Data Prep Kit contributes a set of modules that the developer can get started with to easily build data pipelines suitable for their use case. These modules have been tested while producing pre-training datasets for the Granite open models, here and here.
The modules are built on common frameworks (for Spark and Ray), called the data processing library that allows the developers to build new custom modules that readily scale across a variety of runtimes. Eventually, Data Prep Kit will offer consistent APIs and configurations across the following underlying runtimes.
- Python runtime
- Ray runtime (local and distributed)
- Spark runtime (local and distributed)
- Kubeflow Pipelines (local and distributed, wrapping Ray)
The current matrix for the combination of modules and supported runtimes is shown in the table below. Contributors are welcome to add new modules as well as add runtime support for existing modules!
| Modules | Python-only | Ray | Spark | KFP on Ray |
|---|---|---|---|---|
| No-op / template | ✅ | ✅ | ✅ | ✅ |
| Doc ID annotation | ✅ | ✅ | ✅ | ✅ |
| Programming language annnotation | ✅ | ✅ | ✅ | |
| Exact dedup filter | ✅ | ✅ | ||
| Fuzzy dedup filter | ✅ | ✅ | ||
| Code quality annotation | ✅ | ✅ | ✅ | |
| Malware annotation | ✅ | ✅ | ✅ | |
| Filter on annotations | ✅ | ✅ | ✅ | ✅ |
| Language identification | ✅ | ✅ | ✅ | |
| Code (from zip) to Parquet | ✅ | ✅ | ✅ | |
| Profiler | ✅ | ✅ | ||
| Tokenizer | ✅ | ✅ | ✅ |
Features of the toolkit:
- It aims to accelerate unstructured data prep for the "long tail" of LLM use cases.
- It offers a growing set of module implementations across multiple runtimes, targeting laptop-scale to datacenter-scale processing.
- It provides a growing set of sample pipelines developed for real enterprise use cases.
- It provides the Data processing library to enable contribution of new custom modules targeting new use cases.
- It uses Kubeflow Pipelines-based workflow automation.
Data modalities supported:
- Code - support for code datasets as downloaded .zip files of GitHub repositories converted to parquet files.
- Language - Future releases will provide transforms specific to natural language, and like the code transformations, will operate on parquet files.
Support for additional data modalities is expected in the future.
A Python-based library that has ready-to-use transforms that can be supported across a variety of runtimes.
We use the popular parquet format to store the data (code or language).
Every parquet file follows a set
schema.
Data is converted from raw form (e.g., zip files for GitHub repositories) to parquet files by the
ingest2parquet
tool that also adds the necessary fields in the schema.
A user can then use one or more of the available transforms to process their data.
A transform can follow one of the two patterns: annotator or filter.
-
Annotator An annotator transform adds information during the processing by adding one more columns to the parquet files. The annotator design also allows a user to verify the results of the processing before the actual filtering of the data.
-
Filter A filter transform processes the data and outputs the transformed data, e.g., exact deduplication. A general purpose SQL-based filter transform enables a powerful mechanism for identifying columns and rows of interest for downstream processing. For a new module to be added, a user can pick the right design based on the processing to be applied. More details here.
To enable processing of large data volumes leveraging multi-mode clusters, Ray or Spark wrappers are provided, to readily scale out the Python implementations. A generalized workflow is shown here.
One can add new transforms by bringing in Python-based processing logic and using the Data Processing Library to build and contribute transforms. More details on the data processing library are here.
The toolkit also supports transform execution automation based on Kubeflow pipelines (KFP), tested on a locally deployed Kind cluster and external OpenShift clusters. There is an automation to create a Kind cluster and deploy all required components on it. The KFP implementation is based on the KubeRay Operator for creating and managing the Ray cluster and KubeRay API server to interact with the KubeRay operator. An additional framework along with several kfp components is used to simplify the pipeline implementation.
There are various entry points that you can choose based on the use case. Each entry point has its pre-requirements and setup steps. The common part of are:
- Python 3.10 or 3.11 -Docker/Podman
Two important development tools will also be installed using the steps below:
pip install pre-commit
pip install twine
...
git clone [email protected]:IBM/data-prep-kit.git
cd data-prep-kit
pre-commit installPlease note that there are further installation steps for running the transforms in general, as documented here and on a local Kind cluster or on an existing Kubernetes cluster, as documented here.
Below are a few demos to get you started.
Follow the documentation here to build your own transform and run it in either the python or Ray runtimes.
Get started by running the "noop" transform that performs an identity operation by following the tutorial and associated noop implementation.
Get started by building a Jupiter notebook executing a sequence of Transforms with our example pipeline that can run on your machine. This implementation can also be extended to connect to the remote Ray cluster.
The data preprocessing can be automated by running transformers as a Kubeflow pipeline (KFP). The project facilitates the creation of a local Kind cluster with all the required software and test data, or deployment of required software on an existing cluster. See Set up a Kubernetes clusters for KFP execution
A simple transform pipeline tutorial explains the pipeline creation and execution. In addition, if you want to combine several transformers in a single pipeline, you can look at multi-steps pipeline
When you finish working with the cluster, and want to clean up or destroy it. See the clean up the cluster
See the documentation on repository structure and its use.
See the contribution guide
Thanks to the BigCode Project, which served as the source for borrowing the code quality metrics.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent