sample_id string | parsed_answer string | correct_answer null | stop_reason string | output_tokens int64 | input_tokens int64 | reasoning string | prompt list |
|---|---|---|---|---|---|---|---|
ex00001 | 0.001 | null | stop | 844 | 379 | Let me carefully analyze this code.
The specification says: clamp `x` into the closed interval `[lo, hi]`. This means:
- If `x < lo`, return `lo`
- If `x > hi`, return `hi`
- Otherwise, return `x`
The implementation:
```python
def clamp(x, lo, hi):
if x < lo:
result = lo + 1 # Bug: should be lo, not lo +... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00005 | 0.001 | null | stop | 906 | 363 | Let me analyze this code carefully.
The specification asks to count vowels in a string, case-insensitive.
Looking at the implementation:
```python
def count_vowels(s):
vowels = set('aeiou')
total = 0
for ch in s.lower():
if ch not in vowels:
total += 1
return total
```
There's a c... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00016 | 0.999 | null | stop | 759 | 328 | Let me analyze this code carefully.
The specification says:
- Implement `median3(a, b, c)` returning the median of three distinct integers.
The implementation:
```python
def median3(a, b, c):
ordered = sorted([a, b, c])
chosen = ordered.pop(1)
return chosen
```
The tests:
1. `test_case()`: median of (11,... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00019 | 0.999 | null | stop | 906 | 375 | Let me analyze this code carefully.
The specification asks for a function `find_first_gt(nums, threshold)` that returns the first element strictly greater than `threshold`, or `None` if absent.
The implementation is:
```python
def find_first_gt(nums, threshold):
return next((n for n in nums if n > threshold), Non... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00026 | 0.001 | null | stop | 891 | 373 | Let me carefully analyze this code.
The specification says:
- Parse comma-separated integers with optional surrounding whitespace
- Empty segments must raise ValueError
The implementation:
```python
def parse_int_list(s):
parts = tuple(part.strip() for part in s.split(','))
values = map(int, (part for part in... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00038 | 0.999 | null | stop | 788 | 374 | Let me carefully analyze this code.
The specification says:
- `clamp(x, lo, hi)` should return `x` clamped into the closed interval `[lo, hi]`
- Assume `lo <= hi`
Looking at the implementation:
```python
def clamp(x, lo, hi):
if x < lo:
result = lo
elif x > hi:
result = hi
else:
re... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00039 | 0.999 | null | stop | 828 | 371 | Let me analyze this code carefully.
The specification says:
- Return the second largest distinct value in nums
- If all elements are equal (no distinct second largest exists), raise ValueError
The implementation:
```python
def second_largest(nums):
values = sorted(value for value in set(nums))
if len(values) ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00047 | 0.999 | null | stop | 792 | 398 | Let me carefully analyze this implementation against the specification and tests.
**Specification Requirements:**
1. Return the second largest distinct value in `nums`
2. If all elements are equal (no distinct second largest exists), raise ValueError
**Implementation Analysis:**
```python
def second_largest(nums):
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00054 | 0.999 | null | stop | 950 | 405 | Let me carefully analyze this code to determine if it passes all tests.
The specification says:
- Implement `clamp(x, lo, hi)` returning `x` clamped into the closed interval `[lo, hi]`.
- Assume `lo <= hi`.
- Clamped means: if x < lo, return lo; if x > hi, return hi; otherwise return x.
The implementation:
```python
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00067 | 0.999 | null | stop | 834 | 390 | Let me analyze this code carefully.
The specification asks for:
- Find the first element strictly greater than `threshold`
- Return `None` if no such element exists
The implementation is:
```python
def find_first_gt(nums, threshold):
return next((n for n in nums if n > threshold), None)
```
Let's trace through e... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00071 | 0.001 | null | stop | 1,089 | 385 | Let me carefully analyze this code to see if it passes all tests.
The specification says:
- Implement `count_vowels(s)` returning the number of vowels in `s`
- Case-insensitive
The implementation:
```python
def count_vowels(s):
vowels = set('aeiou')
text = s
def count_from(index):
if index == len... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00078 | 0.001 | null | stop | 1,122 | 352 | Let me analyze this code carefully.
The specification asks for a function `sum_even(nums)` that returns the sum of even integers in `nums`.
Looking at the implementation:
```python
def sum_even(nums):
total = 0
index = 0
while index < len(nums):
n = nums[index]
if n % 2 != 0:
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00094 | 0.999 | null | stop | 831 | 382 | Let me analyze this code carefully.
**Specification:**
- Function: `find_first_gt(nums, threshold)`
- Return: First element strictly greater than `threshold`, or `None` if absent
**Implementation:**
```python
def find_first_gt(nums, threshold):
return next((n for n in nums if n > threshold), None)
```
This uses ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00100 | 0.999 | null | stop | 1,009 | 390 | Let me carefully analyze this code to determine if it passes all tests.
**Specification:**
- Function: `find_first_gt(nums, threshold)`
- Returns: First element strictly greater than `threshold`, or `None` if absent
**Implementation:**
```python
def find_first_gt(nums, threshold):
return next((n for n in nums if ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00105 | 0.999 | null | stop | 934 | 382 | Let me analyze this code carefully.
The specification asks for:
- Find the first element strictly greater than `threshold`
- Return `None` if no such element exists
The implementation:
```python
def find_first_gt(nums, threshold):
return next((n for n in nums if n > threshold), None)
```
Let's trace through each... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00130 | 0.001 | null | stop | 1,343 | 358 | Let me analyze this code carefully.
**Specification:**
- Function `rotate_left(lst, k)` should return a new list rotated left by `k` positions
- Use `k % len(lst)` for non-empty lists
**Implementation:**
```python
def rotate_left(lst, k):
if not lst:
return []
i = k % len(lst)
return lst[:i] + lst... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00143 | 0.001 | null | stop | 861 | 379 | Let me carefully analyze this code to see if it correctly implements the clamp function.
The specification says:
- `clamp(x, lo, hi)` returns `x` clamped into the closed interval `[lo, hi]`
- Assume `lo <= hi`
- This means if x < lo, return lo
- If x > hi, return hi
- If lo <= x <= hi, return x
Now let's look at the ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00149 | 0.001 | null | stop | 893 | 379 | Let me carefully analyze this implementation against the specification and test cases.
**Specification:**
- `clamp(x, lo, hi)` should return `x` clamped into the closed interval `[lo, hi]`
- This means:
- If `x < lo`, return `lo`
- If `x > hi`, return `hi`
- Otherwise, return `x`
**Implementation Analysis:**
``... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00161 | 0.001 | null | stop | 951 | 361 | Let me analyze this code carefully.
The specification says:
- Implement `rotate_left(lst, k)` returning a new list rotated left by `k` positions.
- Use `k % len(lst)` for non-empty lists.
The implementation:
```python
def rotate_left(lst, k):
if not lst:
return []
i = k % len(lst)
return [lst[posi... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00191 | 0.999 | null | stop | 783 | 353 | Let me carefully analyze this code.
The specification asks for a function `sum_even(nums)` that returns the sum of even integers in `nums`.
The implementation:
```python
def sum_even(nums):
def eligible(n):
return n % 2 == 0
return sum(n for n in nums if eligible(n))
```
Let's trace through each tes... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00197 | 0.001 | null | stop | 1,369 | 363 | Let me carefully analyze this code.
The function should return the median of three distinct integers.
Let's trace through the implementation:
```python
def median3(a, b, c):
ordered = []
for value in (a, b, c):
position = 0
while position < len(ordered) and ordered[position] < value:
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00200 | 0.999 | null | stop | 684 | 328 | Let me analyze this code carefully.
**Specification:**
- Function name: `sum_even`
- Purpose: Return the sum of even integers in a list `nums`
**Implementation:**
```python
def sum_even(nums):
def eligible(n):
return n % 2 == 0
return sum(n for n in nums if eligible(n))
```
**Tests:**
1. `sum_even([... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00202 | 0.001 | null | stop | 1,044 | 376 | Let me carefully analyze this code to determine if it will pass all tests.
**Specification:**
- `unique_sorted(nums)` should return a sorted list of unique values from `nums`.
- "sorted" typically means ascending order (A to Z, 1 to 10, etc.)
**Implementation Analysis:**
```python
def unique_sorted(nums):
values... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00211 | 0.999 | null | stop | 1,248 | 393 | Let me analyze this code carefully.
## Specification Requirements:
1. Return the second largest distinct value in nums
2. If all elements are equal, raise ValueError
## Implementation Analysis:
```python
def second_largest(nums):
values = sorted(value for value in set(nums))
if len(values) < 2:
raise... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00218 | 0.999 | null | stop | 891 | 390 | Let me analyze this code carefully.
Specification:
- Function: `find_first_gt(nums, threshold)`
- Returns: first element strictly greater than `threshold`, or `None` if absent
Implementation:
```python
def find_first_gt(nums, threshold):
return next((n for n in nums if n > threshold), None)
```
Tests:
1. `test_t... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00289 | 0.001 | null | stop | 1,592 | 364 | Let me carefully analyze this implementation against the specification and tests.
**Specification:**
- Count vowels in string `s`
- Case-insensitive (so 'A', 'E', 'I', 'O', 'U' should count as well as 'a', 'e', 'i', 'o', 'u')
- Should return the number of vowels
**Implementation Analysis:**
```python
def count_vowel... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00314 | 0.001 | null | stop | 839 | 352 | Let me analyze this code carefully.
The specification says:
- `sum_even(nums)` should return the sum of even integers in `nums`.
The implementation:
```python
def sum_even(nums):
total = 0
index = 0
while index < len(nums):
n = nums[index]
if n % 2 != 0: # If n is NOT divisible by 2 (i.e.... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00336 | 0.999 | null | stop | 1,641 | 434 | Let me carefully analyze this code.
The specification requires:
1. Parse comma-separated integers
2. Handle optional surrounding whitespace (strip)
3. Empty segments must raise ValueError
Let's trace through the implementation:
```python
def parse_int_list(s):
parts = list(map(str.strip, s.split(',')))
if an... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00343 | 0.999 | null | stop | 814 | 353 | Let me analyze this code carefully.
The specification requires:
- Implement `sum_even(nums)` returning the sum of even integers in `nums`
The implementation:
```python
def sum_even(nums):
def eligible(n):
return n % 2 == 0
return sum(n for n in nums if eligible(n))
```
Let me trace through each test... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00357 | 0.001 | null | stop | 1,071 | 386 | Let me carefully analyze this code to determine if it will pass all tests.
The specification asks for:
- Count vowels in a string `s`
- Case-insensitive (so 'A', 'E', 'I', 'O', 'U' should all count)
The implementation:
```python
def count_vowels(s):
vowels = set('aeiou') # Only lowercase vowels
text = s
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00359 | 0.999 | null | stop | 854 | 374 | Let me carefully analyze this code.
The specification asks for a `clamp(x, lo, hi)` function that returns `x` clamped to the interval `[lo, hi]`. This means:
- If `x < lo`, return `lo`
- If `x > hi`, return `hi`
- Otherwise (if `lo <= x <= hi`), return `x`
Let's look at the implementation:
```python
def clamp(x, lo,... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00364 | 0.999 | null | stop | 997 | 413 | Let me carefully analyze this code.
The function `clamp(x, lo, hi)` should return `x` clamped into the closed interval `[lo, hi]`. That means:
- If x is less than lo, return lo
- If x is greater than hi, return hi
- Otherwise, return x
Let's trace through each test case:
**Test 1: test_main_case**
- Input: `clamp(-8... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00374 | 0.999 | null | stop | 918 | 398 | Let me analyze this code carefully.
The specification says:
- Return the second largest distinct value in `nums`
- If all elements are equal (no distinct second largest exists), raise ValueError
Let's trace through the implementation:
```python
def second_largest(nums):
values = []
for value in set(nums):
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00375 | 0.999 | null | stop | 739 | 326 | Let me carefully analyze this code.
The specification asks to implement a function `median3(a, b, c)` that returns the median of three distinct integers.
The implementation does:
1. Takes three integers `a`, `b`, `c`
2. Sorts them into a list: `sorted([a, b, c])`
3. Gets the middle element by indexing with 1 (0-index... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00388 | 0.001 | null | stop | 1,932 | 385 | Let me carefully analyze this code to check if it passes all tests.
The specification is to implement `count_vowels(s)` that returns the number of vowels in `s`, case-insensitive.
Looking at the implementation:
```python
def count_vowels(s):
vowels = set('aeiou')
text = s
def count_from(index):
i... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00396 | 0.999 | null | stop | 1,034 | 399 | Let me analyze this code carefully.
## Specification
- Function `second_largest(nums)` should return the second largest distinct value in `nums`
- If all elements are equal (no distinct second largest exists), raise ValueError
## Implementation Analysis
1. `values = []` - creates an empty list
2. `for value in set(n... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00397 | 0.001 | null | stop | 847 | 361 | Let me analyze this code carefully.
The specification asks for:
- `rotate_left(lst, k)` should return a new list rotated left by `k` positions
- For non-empty lists, use `k % len(lst)`
Let's look at the implementation:
```python
def rotate_left(lst, k):
if not lst:
return []
i = k % len(lst)
retu... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00401 | 0.999 | null | stop | 765 | 373 | Let me analyze this code carefully.
The function `clamp(x, lo, hi)` is supposed to return `x` clamped into the closed interval `[lo, hi]`.
The specification says:
- Return `x` if `lo <= x <= hi`
- Return `lo` if `x < lo`
- Return `hi` if `x > hi`
Let's trace through the implementation:
```python
def clamp(x, lo, hi... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00405 | 0.001 | null | stop | 886 | 376 | Let me analyze this code carefully.
The specification asks for:
1. A function `unique_sorted(nums)` that returns a sorted list of unique values from `nums`
2. Looking at the test case `test_ascending_order`, the expected output is `[-4, -2, -1, 1, 2, 3, 4]` - this is in ascending (increasing) order
3. Looking at `test... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00407 | 0.999 | null | stop | 864 | 398 | Let me analyze this code carefully.
The specification asks for:
1. Find the second largest distinct value in a list of numbers
2. If all elements are equal (no distinct second largest), raise ValueError
Let's trace through the implementation:
```python
def second_largest(nums):
values = []
for value in set(n... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
End of preview. Expand in Data Studio
speccast-code-correctness-v1-2-blind-test-predictions
Blind test (n=975) predictions from final SpecCast v1.2 LoRA. Labels withheld.
- Base model:
Qwen/Qwen3.5-4B - Adapter:
LightningRodLabs/speccast-code-correctness-v1-2-qwen3.5-4b-lora - Source benchmark:
aligncast/speccast-benchmark@7cef3c2… - Rows: 975
- Upstream artifact:
LightningRodLabs/speccast-code-correctness-v1-2-blind-test-qwen3-5-4b-blind-test-ckpt-20260722T123227Z
Blind splits keep labels empty by design.
- Downloads last month
- 41