Hugging Face's logo

Datasets:
Scream9371
/
hamnet-datasets

Tasks:
Text Classification
Languages:
code
multilingual
Size:
10K<n<100K
Tags:
code
software-engineering
defect-prediction
multiple-instance-learning
Dataset card Data Studio Files
xet
 Community
hamnet-datasets / README.md
Scream9371's picture
Scream9371
Update dataset card with current v1 and v2 documentation
76b3332 verified
preview code
|
Raw
History Blame Contribute Delete
12.4 kB
metadata 
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 either:

  • one source-code function, for the original Devign dataset;
  • 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:

{
  "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 Original published datasets, including the original source text and AST graphs.
v2 v2.0.0 Reconstructed PROMISE, Defactors, BugsInPy, and Big-Vul datasets. Source comments are removed; Python docstrings are also removed. Bag membership, function order, and labels are preserved. AST graphs are regenerated after comment and docstring removal. Devign is not included in this revision.

For example:

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

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
devign_c (v1 only) Devign repository Function-level vulnerability annotations from FFmpeg and QEMU C/C++ projects Each C/C++ function is released as an individual sample with an AST graph and a binary label.
promise_java PROMISE repository 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 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 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 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.

Devign remains in its original function-level format, whereas 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 503 / 525 (95.81%) 1,076 / 63,818 (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%)
devign_c (v1 only) C/C++ function-level sample 27,318 samples 12,460 / 14,858 (45.61% / 54.39%) N/A: function-level schema N/A N/A

promise_java uses bug > 0 as its class/bag label and therefore does not claim function-level defect localization ground truth. devign_c is retained in its original function-level schema and does not contain a functions bag list.

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.

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 output caps 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.

Devign (v1 only)

  • Unit of sampling: one function is one labeled sample rather than a MIL bag.
  • Projects: qemu and FFmpeg.

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.

Optional Training-time function caps

The published JSONL files contain the full function lists. HAM-Net training, however, uses an optional deterministic cap of at most 16 functions per bag to control GPU memory and runtime. The cap does not modify the released JSONL files. It is applied only by the training data loader.

For each bag, cap generation follows this procedure:

  1. Discard only candidate functions whose source is empty or whose AST has no nodes; the remaining functions keep their original order and indices.
  2. Score each valid function as log(1 + node_count) + 0.3 * log(1 + edge_count).
  3. Rank candidates by score, then by node count, source start line, and original index as deterministic tie-breakers. Select the top 12 candidates first.
  4. If more functions are available, select additional candidates by evenly covering the remaining ranked list until the bag contains at most 16 functions. Bags with 16 or fewer valid functions retain all valid functions.
  5. Write the selected zero-based function indices and the policy metadata to the cap file under the stable bag identifier. Cap files are generated separately for each dataset revision and must be used only with the matching JSONL files.

At training time, the data loader reads the cap entry for each bag and replaces the full function list with the recorded indices before constructing the model input. The same label-agnostic procedure is therefore shared across datasets and models.

Files

  • Both versions: promise_java.jsonl, defactors_python.jsonl, bugsinpy_python.jsonl, and bigvul_c.jsonl.
  • v1 only: devign_c.jsonl.
  • Each revision contains a caps/ directory. Its cap files are generated from the JSONL files in that same revision using the deterministic ast_topk_v1 policy. v1 has caps for all five datasets; v2 has caps for its four MIL datasets only.
  • caps/caps_summary.json records the input bag count, cap-entry count, selected function count, and any bags omitted because they contain no valid function with both non-empty code and a non-empty AST. A cap file must only be used with the JSONL files from the same revision.