---
pretty_name: HAM-Net Datasets
tags:
- code
- software-engineering
- defect-prediction
- multiple-instance-learning
task_categories:
- text-classification
language:
- code
- multilingual
size_categories:
- 10K<n<100K
---

# HAM-Net datasets

This repository provides the processed code datasets used in the HAM-Net
experiments for cross-project software defect prediction.

Each JSONL record represents one source-code file or Java class containing
multiple functions.

For datasets organized by file or class, HAM-Net treats the file/class as a
**bag** and its functions as **instances**, following the multiple-instance
learning (MIL) setting. Each record includes a binary defect label, a project
identifier, and the extracted function-level code and AST information.

## Record format

A simplified MIL record looks like:

```json
{
  "id": "stable-sample-id",
  "project": "pandas",
  "file_path": "pandas/core/example.py",
  "label": 1,
  "functions": [
    {
      "name": "example_function",
      "code": "def example_function(...): ...",
      "func_label": 1,
      "ast_nodes": ["DECLARATION", "PARAMETER", "CONTROL", "RETURN"],
      "ast_edges": [[0, 1], [0, 2], [2, 3]]
    }
  ]
}
```

`func_label` is present only when it can be derived from patch or line-level
annotations. It is not available for PROMISE.

## Published versions

The repository keeps the original JSONL filenames in every version. Select a version
through the Hugging Face revision or Git tag:

| Version | Revision | Description |
|---|---|---|
| v1 | `v1.0.0` | Reproducibility release for the original HAM-Net CPDP protocol: preserves the original bag identities and order, retains original source text and comments, removes the build-time function-count and 800-node AST limits, and includes the legacy CPDP splits. |
| v2.0.0 | `v2.0.0` | Reconstructed PROMISE, Defactors, BugsInPy, and Big-Vul from normalized source. Comments/docstrings and non-literal blank lines are removed; Python docstring-only suites are replaced with synthetic `pass` so every v1 bag/function remains. Labels are frozen and AST graphs are regenerated. |
| v2.0.1 | `v2.0.1` | Reconstructed the same four datasets without synthetic code. Python docstring-only functions/classes are deleted; bags that become empty, or positive bags with no remaining positive function, are deleted. Remaining bag/function labels are frozen and AST graphs are regenerated. |

For example:

```bash
hf download Scream9371/hamnet-datasets promise_java.jsonl --revision v1.0.0
hf download Scream9371/hamnet-datasets promise_java.jsonl --revision v2.0.0
hf download Scream9371/hamnet-datasets promise_java.jsonl --revision v2.0.1
```

### v1.0.0 reproducibility contract

`v1.0.0` is pinned to the four JSONL files at repository root and the fixed
CPDP files under `splits/cpdp/`. The JSONL files preserve the bag identity and
order used by the original local HAM-Net experiments, while each bag contains
the complete parseable function list. Source text retains comments and AST
graphs are not truncated at 800 nodes.

Matching deterministic training-time caps are under `caps/v1.0.0/`
(`ast_topk_v1`, `K=16`, `top_m=12`). Do not reuse caps generated for the
earlier function-capped bags: their indices are not valid for the unbounded
PROMISE and Defactors bags.

The BugsInPy CPDP split intentionally contains the 2,416 bags used by the
original HAM-Net experiment repository.

## Original data sources

The published JSONL files are derived from the following public datasets. Some
original datasets provide labels for functions, classes, files, or code lines.
During preprocessing, HAM-Net converts several of them into a common
file/class-level MIL format. The table distinguishes the original annotation
level from the released HAM-Net representation.

| Dataset | Original source | Original annotations / content | HAM-Net representation |
|---|---|---|---|
| `promise_java` | [PROMISE repository](https://openscience.us/repo/defect) | Classic Java class-level defect metric datasets with a `bug` count/label | Each Java class forms one MIL bag. The bag is positive when `bug > 0`. |
| `bigvul_c` | [MSR 2020 Big-Vul dataset](https://github.com/ZeoVan/MSR_20_Code_vulnerability_CSV_Dataset) | Large-scale C/C++ vulnerability records containing code changes and CVE-related metadata | Each C/C++ file forms one MIL bag. Functions overlapping buggy-side changed lines are marked as positive. |
| `defactors_python` | [Defactors](https://zenodo.org/records/7708984) | Line-level defect annotations from multiple Python projects | Each Python file forms one MIL bag. Functions overlapping annotated defect lines receive `func_label=1`. |
| `bugsinpy_python` | [BugsInPy](https://github.com/soarsmu/BugsInPy) | Reproducible defects, buggy/fixed commits, and patch information from Python projects | Each Python file forms one MIL bag. Bags are constructed from buggy files and same-project negative files. |

PROMISE, Big-Vul, Defactors, and BugsInPy are converted into class-level or file-level bags for multiple-instance learning. The dataset sources provide the original labels or patch/line annotations; the exact sampling, parsing, AST normalization, and bag construction rules are described below.

## Dataset summary

Percentages are computed from the final JSONL files. `P50/P90/P99` are the numbers of functions per bag. `mixed positive bags` means positive bags containing both at least one `func_label=1` function and at least one `func_label=0` function. `positive functions` is computed only for datasets that retain function-level labels.

| Dataset | Language / granularity | Bags or samples | Positive / negative | Functions per bag P50 / P90 / P99 | Mixed positive bags | Positive functions |
|---|---|---:|---:|---:|---:|---:|
| `promise_java` | Java class-level MIL bag | 1,695 bags | 647 / 1,048 (38.17% / 61.83%) | 8 / 26 / 94.12 | N/A: no function-level labels | N/A |
| `defactors_python` | Python file-level MIL bag | 1,700 bags | 873 / 827 (51.35% / 48.65%) | 18 / 86 / 227.06 | 808 / 873 (92.55%) | 3,190 / 58,028 (5.50%) |
| `bugsinpy_python` | Python file-level MIL bag | 2,416 bags | 525 / 1,891 (21.73% / 78.27%) | 9 / 79 / 205 | 507 / 525 (96.57%) | 1,080 / 63,937 (1.69%) |
| `bigvul_c` | C/C++ file-level MIL bag | 1,700 bags | 733 / 967 (43.12% / 56.88%) | 16 / 64 / 279.01 | 733 / 733 (100.00%) | 1,270 / 51,668 (2.46%) |

`promise_java` uses `bug > 0` as its class/bag label and therefore does not claim function-level defect localization ground truth.

## How the MIL bags are constructed

The following rules define the published MIL samples.

### PROMISE

- Unit of sampling: one target Java class is one bag; methods and constructors in
  that class are the bag instances.
- Source candidates: scan the available project/version CSV records and resolve each
  class name to its corresponding Java source file. Records without a source file,
  unparsable source, or fewer than three parseable methods/constructors are removed.
- Projects: `ant`, `camel`, `ivy`, `jedit`, `log4j`, `lucene`, `poi`, `velocity`, and
  `xalan`.
- Label: `label=1` when the source `bug` value is greater than zero; otherwise
  `label=0`.
- Function sampling: retain all parseable methods and constructors in the selected
  class. No positive/negative function sampling is performed.

### Defactors

- Unit of sampling: one Python source file is one bag and every parseable function
  in that file is an instance.
- Projects: `pandas`, `scikit-learn`, `localstack`, `django`, `poetry`, `core`,
  `airflow`, `lightning`, `spaCy`, `ansible`, `ray`, `celery`, `sentry`, `cpython`,
  and `transformers`.
- Function and bag labels: a function is positive when its span overlaps an annotated
  defect line; a bag is positive when it contains at least one positive function.
- Negative bags: sample files from the same project whose functions do not overlap
  the annotated defect lines; prefer the same commit and same module when available,
  then use other commits from the same project, with duplicate project/commit/file
  records removed.
- Function sampling: discard bags with fewer than three parseable functions during
  the original candidate construction.

### BugsInPy

- Unit of sampling: one Python file at a buggy commit is one bag; each parseable
  function in the file is an instance.
- Projects: `pandas`, `keras`, `youtube-dl`, `scrapy`, `luigi`, `thefuck`, `matplotlib`,
  `black`, `ansible`, `fastapi`, `tornado`, `tqdm`, `spacy`, `sanic`, `httpie`,
  `cookiecutter`, and `PySnooper`.
- Positive candidates: use the buggy-side files touched by each BugsInPy patch.
  A function is positive when its span overlaps a buggy-side patch line, and
  the bag is positive when at least one such function exists.
- Negative candidates: for each bug, sample one same-project Python file from the
  same buggy snapshot that is not among the patched files. Half of the negative
  sampling quota targets files in the same directory or top-level module when such
  candidates exist; remaining candidates are sampled from the other files.
- Function sampling: use seed 42, discard files with no parseable function, and
  retain the complete parseable function list in the published full-function version.
  Both releases also exclude bags that contain no function definition: older
  construction artifacts represented them as a single ``<file>`` placeholder,
  which is not a valid MIL instance.

### Big-Vul

- Unit of sampling: one C/C++ file at the buggy snapshot is one bag; each parseable
  function is an instance.
- Projects: `linux`, `ImageMagick`, `Android`, `tcpdump`, `FFmpeg`, `php-src`, and
  `radare2`.
- Positive candidates: use the buggy-side files associated with the vulnerability
  patch. A function is positive when it overlaps a removed/changed buggy-side patch
  line; the file is a positive bag when at least one function is positive.
- Negative candidates: for each positive file, sample two unmodified same-project
  files from the same snapshot. Half of the negative quota targets the same
  directory or top-level module when possible; the remainder is sampled from other
  files. Sampling uses seed 42, with project and global sample limits applied before
  writing the final set.
- Function sampling: discard files with fewer than three parseable functions and
  retain all remaining functions in the full-function version.

### AST and version rules

- To make ASTs from Java, Python, C, and C++ comparable, language-specific node
  types are mapped to a shared set of structural roles, such as declarations,
  control-flow statements, calls, assignments, returns, and literals.
- This normalization preserves coarse syntactic structure while removing
  language-specific lexical details. Identifiers, punctuation, comments, and
  documentation text are not retained as structural AST nodes. The normalized
  graph contains parent-child structure, reverse edges, and self-loops.
- In v2.0.0 and v2.0.1, comments are removed with language-aware lexical
  scanning while string and character literals are retained. Function labels
  are derived before source normalization; no defect label is recomputed from
  normalized source positions.
- v2.0.0 replaces a Python function/class body consisting solely of a docstring
  with synthetic `pass`, retaining all v1 bags and functions.
- v2.0.1 instead deletes Python docstring-only functions and classes. It omits
  a bag if no functions remain, and omits a positive bag if no remaining
  function has its frozen positive `func_label`; all retained labels and
  function order are preserved.

## Files

- Both versions: `promise_java.jsonl`, `defactors_python.jsonl`,
  `bugsinpy_python.jsonl`, and `bigvul_c.jsonl`.