---
license: odc-by
language:
- en
- code
pretty_name: BigCode GPT-J SFT Curation Preview
size_categories:
- n<1K
task_categories:
- text-generation
tags:
- code
- python
- sft
- nextlat
- dataset-curation
- preview
configs:
- config_name: candidates
  default: true
  data_files:
  - split: train
    path: candidate-train.jsonl
  - split: validation
    path: candidate-dev.jsonl
- config_name: reviewed
  data_files:
  - split: preview
    path: reviewed-preview.jsonl
- config_name: approved_preview
  data_files:
  - split: preview
    path: approved-preview.jsonl
---

# BigCode GPT-J SFT curation preview

**Inspection pilot, not a finished training dataset.** The default viewer contains 100 static candidates (94 train / 6 development). Only three examples have received manual contract review and targeted execution checks. Two are in `approved_preview`; the rectangle example is held for ambiguity. All three passed their stated tests (17 assertions total); this is not comprehensive correctness certification.

## Source and attribution

Derived from [BigCode self-oss-instruct-sc2-exec-filter-50k](https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k), revision `356bb069eee815daa6e23e9a282eeefe1490ad44`, made available under ODC-By. The pinned source has 50,661 rows. Preserve BigCode attribution and original source/license provenance on further redistribution. Source and benchmark file hashes are in `manifest.json`.

This preview inspects the **first 500 rows**, not a representative random sample. Static filters accepted 307; the first 100 are shown in the default viewer.

## How examples were produced

No model generated new training solutions for this preview. Existing source rows were transformed deterministically:

1. `instruction` supplies the task. Extract exactly one fenced Python block from `response`.
2. Require exactly one undecorated standalone function. Reject imports, selected dynamic execution / file-I/O calls, multi-function snippets, and duplicate bodies.
3. Keep the signature, insert the original instruction as its docstring, strip old solution docstrings and response explanations, and normalize the solution body using Python AST unparsing. Original responses are retained for audit.
4. Screen exact normalized instruction/AST solution-body overlap against the pinned HumanEval reference. **This does not rule out paraphrases or semantic contamination.**
5. Use GPT-J's pinned tokenizer and reject sequences exceeding 2,048 tokens including EOS.
6. Group by source seed SHA1 for deterministic train/dev assignment. Near-duplicate families still require stronger screening before the split is frozen.
7. For three selected examples, review the contract and run targeted assertions inside a disposable CPU sandbox. Never execute dataset code on the host.

The source `seed` is inspiration used by BigCode's generator, **not** our target answer. The source `prompt` is the generator's few-shot instruction template, **not** the prompt used for GPT-J training. Teacher explanations are omitted from code-only targets.

## Viewer columns

- `source_id`, `source_row`, `source_revision`, `source_seed_sha1`: traceability.
- `instruction`, `original_response`: unmodified source content.
- `prompt`, `completion`: transformed function-completion training pair.
- `token_count`, `body_sha256`, `split`: length and grouping metadata.
- `validation_status`: static candidate, targeted checks passed, or needs contract review.
- `validation_json` (reviewed configs): exact review scope and targeted-check results.

## Examples inspected

| ID | Task | Status |
|---|---|---|
| 165808 | Retrieve a matrix value, handling invalid indexes | 7 checks passed; negative indexes treated as invalid |
| 81575 | Extract dictionary id values in order | 4 checks passed; assumes every dictionary has id |
| 533341 | Detect rectangle overlaps | 6 checks passed for positive dimensions and strict overlap; held because touching-edge behavior is unspecified |

## Planned experiment

Both training arms will consume identical examples and token IDs. Prompt labels are masked with -100; code and EOS are supervised. Arm A uses ordinary next-token SFT. Arm B adds a NextLat-style future-state objective with detached latent targets. **No training has run and no NextLat trainer is implemented in this preview.**

HumanEval remains evaluation-only. Do not use its solutions or test feedback to create training targets or choose training hyperparameters.

## Reproduction and limitations

`build_preview.py` and `tokenize_preview.py` perform local static processing. Download the pinned source parquet to `source.parquet`, install `requirements.txt`, and run them. `validate_preview.py` requires the CoreWeave SDK and a locally configured credential; it uses CPU-only remote execution with a three-minute cap. The preview was published as JSONL through the web editor.

Static candidates require execution checks, contract review, stronger overlap checks, and adequate development-set construction before training. The 94/6 candidate split is illustrative. Neither source execution filtering nor the targeted tests guarantee complete correctness.

The upload excludes credentials, virtual environments, model weights, the full upstream parquet, and the HumanEval benchmark file.

## Readable example pairs

These transformed examples are displayed here because private dataset viewers may require a paid Hugging Face plan.

### Source 165808 — reviewed_targeted_checks_passed

**Prompt**

```python
def get_value(matrix, indices):
    'Write a Python function named `get_value` that takes a matrix (represented by a list of lists) and a tuple of indices, and returns the value at that index in the matrix. The function should handle index out of range errors by returning None.'
```

**Completion**

```python
    row_index, col_index = indices
    if row_index < 0 or row_index >= len(matrix) or col_index < 0 or (col_index >= len(matrix[row_index])):
        return None
    return matrix[row_index][col_index]
```

### Source 533341 — needs_contract_review

**Prompt**

```python
def check_collision(rectangles):
    'Write a Python function `check_collision` that takes a list of `rectangles` as input and checks if there are any collisions between any two rectangles. A rectangle is represented as a tuple (x, y, w, h) where (x, y) is the top-left corner of the rectangle, `w` is the width, and `h` is the height.\n\nThe function should return True if any pair of rectangles collide, and False otherwise. Use an iterative approach and check for collisions based on the bounding box collision detection algorithm. If a collision is found, return True immediately without checking for more collisions.'
```

**Completion**

```python
    for i in range(len(rectangles)):
        for j in range(i + 1, len(rectangles)):
            x1, y1, w1, h1 = rectangles[i]
            x2, y2, w2, h2 = rectangles[j]
            if x1 + w1 > x2 and x1 < x2 + w2 and (y1 + h1 > y2) and (y1 < y2 + h2):
                return True
    return False
```

### Source 81575 — reviewed_targeted_checks_passed

**Prompt**

```python
def extract_id_values(data: list) -> list:
    "Given a list of dictionaries, your goal is to traverse the list and create a new list with the value of the key `'id'` for each dictionary. For example, given `[{'id': 1, 'name': 'John'}, {'id': 2, 'name': 'Bob'}]`, the desired output would be `[1, 2]`. Make use of list comprehension and dictionary lookup to solve the problem in a single line of code."
```

**Completion**

```python
    return [dictionary['id'] for dictionary in data]
```