Big update of the README (#1)

- Big update of the README (03ff099ca6ee5bc8d544d1dcd53a635e472ac63f)

README.md

@@ -1,23 +1,50 @@
 ---
+annotations_creators: []
+language:
+- code
 license: cc-by-4.0
+multilinguality:
+- multilingual
+pretty_name: ComPile
+size_categories:
+- unknown
+source_datasets: []
+task_categories:
+- text-generation
+task_ids: []
 ---
 
-# ComPile: A Large IR Dataset from Production Sources
+# Dataset Card for ComPile: A Large IR Dataset from Production Sources
 
-## About
+## Dataset Description
 
-Utilizing the LLVM compiler infrastructur shared by a number of languages, ComPile is a large dataset of
-LLVM IR. The dataset is generated from programming languages built on the shared LLVM infrastructure, including Rust,
-Swift, Julia, and C/C++, by hooking into LLVM code generation either through the language's package manager or the
+- **Homepage:** https://llvm-ml.github.io/ComPile/
+- **Paper:** https://arxiv.org/abs/2309.15432
+- **Leaderboard:** N/A
+
+### Changelog
+
+|Release|Programming Languages|Description|
+|-|-|-|
+|v1.0| C/C++, Rust, Swift, Julia | Fine Tuning-scale dataset of 564GB of deduplicated LLVM IR |
+
+### Dataset Summary
+
+ComPile contains over 500GB of permissively-licensed source code compiled to [LLVM](https://llvm.org) intermediate representation (IR) covering C/C++, Rust, Swift, and Julia.
+The dataset was created by hooking into LLVM code generation either through the language's package manager or the
 compiler directly to extract the dataset of intermediate representations from production grade programs using our
 [dataset collection utility for the LLVM compilation infrastructure](https://doi.org/10.5281/zenodo.10155761).
 
-For an in-depth look at the statistical properties of dataset, please have a look at our [arXiv preprint](https://arxiv.org/abs/2309.15432).
+### Languages
 
-## Usage
+The dataset contains **5 programming languages** as of v1.0.
+```
+"c++", "c", "rust", "swift", "julia"
+```
 
-Using ComPile is relatively simple with HuggingFace's `datasets` library. To load the dataset, you can simply
-run the following in a Python interpreter or within a Python script:
+### Dataset Usage
+
+To use ComPile we recommend HuggingFace's [datasets library](https://huggingface.co/docs/datasets/index). To e.g. load the dataset:
 
 ```python
 from datasets import load_dataset
@@ -25,18 +52,18 @@ from datasets import load_dataset
 ds = load_dataset('llvm-ml/ComPile', split='train')
 ```
 
-While this will just work, the download will take quite a while as `datasets` by default will download
-all 550GB+ within the dataset and cache it locally. Note that the data will be placed in the directory
-specified by the environment variable `HF_DATASETS_CACHE`, which defaults to `~/.cache/huggingface`.
-
-You can also load the dataset in a streaming format, where no data is saved locally:
+By default this will download the entirety of the 550GB+ dataset, and cache it locally at the directory
+specified by the environment variable `HF_DATASETS_CACHE`, which defaults to `~/.cache/huggingface`. To
+load the dataset in a streaming format, where the data is not saved locally:
 
 ```python
 ds = load_dataset('llvm-ml/ComPile', split='train', streaming=True)
 ```
 
-This makes experimentation much easier as no upfront large time investment is required, but is
-significantly slower than loading in the dataset from the local disk. For experimentation that
+For further arguments of `load_dataset`, please take a look at the
+`loading a dataset` [documentation](https://huggingface.co/docs/datasets/load_hub), and
+the `streaming` [documentation](https://huggingface.co/docs/datasets/stream). Bear in mind that
+this is significantly slower than loading the dataset from a local storage. For experimentation that
 requires more performance but might not require the whole dataset, you can also specify a portion
 of the dataset to download. For example, the following code will only download the first 10%
 of the dataset:
@@ -55,28 +82,29 @@ next(iter(ds))
 ds[0]
 ```
 
-Filtering and map operations can also be efficiently applied using primitives available within the
-HuggingFace `datasets` library. More documentation is available [here](https://huggingface.co/docs/datasets/index).
+Filtering and map operations can be performed with the primitives available within the
+HuggingFace `datasets` library.
 
-## Dataset Format
+## Dataset Structure
 
+### Data Fields
 Each row in the dataset consists of an individual LLVM-IR Module along with some metadata. There are
 six columns associated with each row:
 
-1. `content` - This column contains the raw bitcode that composes the module. This can be written to a `.bc`
+- `content` (string): This column contains the raw bitcode that composes the module. This can be written to a `.bc`
 file and manipulated using the standard llvm utilities or passed in directly through stdin if using something
 like Python's `subprocess`.
-2. `license_expression` - This column contains the SPDX expression describing the license of the project that the
+- `license_expression` (string): This column contains the SPDX expression describing the license of the project that the
 module came from.
-3. `license_source` - This column describes the way the `license_expression` was determined. This might indicate
+- `license_source` (string): This column describes the way the `license_expression` was determined. This might indicate
 an individual package ecosystem (eg `spack`), license detection (eg `go_license_detector`), or might also indicate
 manual curation (`manual`).
-4. `license_files` - This column contains an array of license files. These file names map to licenses included in
+- `license_files`: This column contains an array of license files. These file names map to licenses included in
 `/licenses/licenses-0.parquet`.
-5. `package_source` - This column contains information on the package that the module was sourced from. This is
+- `package_source` (string): This column contains information on the package that the module was sourced from. This is
 typically a link to a tar archive or git repository from which the project was built, but might also contain a
 mapping to a specific package ecosystem that provides the source, such as Spack.
-6. `language` - This column indicates the source language that the module was compiled from.
+- `language` (string): This column indicates the source language that the module was compiled from.
 
 ## Dataset Size