---
license: apache-2.0
task_categories:
- text-generation
language:
- zh
tags:
- recommendation
- kuaishou
- onereason
- sft
- llm-rec
size_categories:
- 10K<n<100K
---

# Kuaishou LLM-Rec Challenge (SIGIR 2026) — OneReason-0.8B SFT Baseline (0.9107)

Minimal SFT dataset + LoRA hyperparameters that reach **0.9107 leaderboard score** on the Kuaishou LLM-Rec Challenge, fine-tuning `OpenOneRec/OneReason-0.8B-pretrain-competition`.

## Dataset

`train.jsonl` — **32,705 rows**, competition-platform format:

```jsonl
[{"system": "...", "prompt": "...", "response": "..."}]
```

Each line is a JSON array containing one dict. Bucket composition:

| Bucket | Rows | Description |
|---|---|---|
| comp_recommend | 18,651 | User history → next-SID prediction across 4 domains (video/prod/ad/live) |
| comp_item | 9,684 | Bidirectional item encode/decode (SID ↔ caption) |
| comp_user_interest | 2,792 | Free-form user profile analysis (JSON array or reasoning) |
| common_sense | 1,578 | CEval multi-choice questions |
| **TOTAL** | **32,705** | shuffled with seed=42 |

## Data recipe (from `comp_sft`)

1. Load all rows from the competition's `comp_sft` split
2. **Exact-row dedup** (drops rows with identical prompt+response hash)
3. **Special-char filter** (drops rows with control chars, U+FFFD, etc.)
4. **Length filter**: prompt 20-100K chars, response 5-100K chars
5. **`dedupe_identical_think_per_prompt`** on the `recommend` bucket:
   - Group rows by prompt
   - If multiple rows share an identical `<think>` block, keep 1 filled-think and convert the rest to `/no_think` variants (empty `<think></think>` + direct SID output)
   - Result: 6,378 filled-think rows + 12,273 no-think direct-SID rows
6. `item`, `user_interest`, `common_sense` buckets: think traces preserved as-is
7. Load `common_sense` from `ceval` + `eval_log` sources
8. Shuffle all buckets together (seed=42)

Reproducing the dedup step (pseudocode):

```python
from collections import defaultdict
import re

THINK_RE = re.compile(r'<think>(.*?)</think>', re.DOTALL)

def think_of(response: str) -> str:
    m = THINK_RE.search(response)
    return m.group(1).strip() if m else ''

def dedupe_identical_think_per_prompt(rows):
    by_prompt = defaultdict(list)
    for r in rows:
        by_prompt[(r.system, r.user)].append(r)
    out = []
    for group in by_prompt.values():
        thinks = {think_of(r.assistant) for r in group}
        if len(thinks) == 1 and next(iter(thinks)):
            out.append(group[0])
            for r in group[1:]:
                out.append(convert_to_no_think(r))
        else:
            out.extend(group)
    return out
```

## LoRA hyperparameters

```yaml
method: LoRA
lora_rank: 32
lora_alpha: 32
lora_dropout: 0.05

learning_rate: 2.0e-4
weight_decay: 0.001
warmup_ratio: 0.03
lr_scheduler: cosine

per_device_batch_size: 1
gradient_accumulation_steps: 4
sequence_length: 32768
packing: true

bf16: true
enable_thinking: false

num_train_epochs: 1
save_every_steps: 256
```

Same values in `hyperparameters.json` for programmatic use.

## Eval scores

| Task | Score |
|---|---|
| **Overall** | **0.9107** |
| `challenge_itemic_pattern_grounding` | 0.2146 |
| `challenge_evolution_action_select` | 0.0678 |
| `challenge_evolution_topic_gen` | 0.0390 |
| `challenge_recommendation_video` | 0.0672 |
| `challenge_recommendation_product` | 0.1190 |
| `challenge_recommendation_ad` | 0.1498 |
| `challenge_recommendation_live` | 0.1098 |
| `challenge_common_sense` | 0.1435 |

## How to reproduce

1. Download `train.jsonl`
2. Upload to the Kuaishou LLM-Rec competition platform SFT UI
3. Set base model: `OpenOneRec/OneReason-0.8B-pretrain-competition`
4. Apply hyperparameters above
5. Train 1 epoch
6. Submit for eval

## License

Apache 2.0.