Instructions to use FinStep/Alpha-R1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use FinStep/Alpha-R1 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="FinStep/Alpha-R1")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("FinStep/Alpha-R1")
model = AutoModelForCausalLM.from_pretrained("FinStep/Alpha-R1", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use FinStep/Alpha-R1 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "FinStep/Alpha-R1"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "FinStep/Alpha-R1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/FinStep/Alpha-R1

SGLang

How to use FinStep/Alpha-R1 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "FinStep/Alpha-R1" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "FinStep/Alpha-R1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "FinStep/Alpha-R1" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "FinStep/Alpha-R1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use FinStep/Alpha-R1 with Docker Model Runner:
```
docker model run hf.co/FinStep/Alpha-R1
```

Alpha-R1 / README_en.md

iamzuoyou

Update README_en.md: add hero image below title

79872ed verified 2 days ago

preview code

Raw

History Blame Contribute Delete

6.61 kB

Alpha-R1: Alpha Screening with LLM Reasoning via Reinforcement Learning

Alpha-R1

English | 中文

Alpha-R1 is a reasoning-enhanced LLM for quantitative alpha selection: built on Qwen3-8B and trained with GRPO reinforcement learning (verl) using a market-feedback reward. It reasons over semantic factor descriptions — how each factor works, when it works, and when it fails — and selects the Alpha101 factors that best fit current market conditions.

📄 Paper: arXiv:2512.23515
💻 Code: FinStep-AI/Alpha-R1 (inference pipeline / qlib backtesting / training config)
📜 License: MIT

Model Overview

Alpha-R1 framework overview

Item	Content
Base model	Qwen/Qwen3-8B
Training	GRPO (verl) with a market-feedback reward
Input	Decision-context prompt: concatenated semantic factor descriptions `α_des`
Output	Selected factors listed in `<alpha_list>`
Candidate pool	82 Alpha101 factors (as screened in the paper)
Recommended decoding	temperature=0 (greedy), top_p=0.7, max_new_tokens=4096

Quick Start

transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "FinStep/Alpha-R1"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype="bfloat16", device_map="auto")

prompt = "<decision context: concatenated factor descriptions>"  # see the GitHub repo for the prompt builder
inputs = tokenizer.apply_chat_template(
    [{"role": "user", "content": prompt}],
    add_generation_prompt=True, return_tensors="pt",
).to(model.device)

# paper setting: temperature=0 (greedy), top_p=0.7
out = model.generate(inputs, max_new_tokens=4096, do_sample=False)
print(tokenizer.decode(out[0][inputs.shape[1]:], skip_special_tokens=True))

vLLM

from vllm import LLM, SamplingParams

llm = LLM(model="FinStep/Alpha-R1")
params = SamplingParams(temperature=0.0, top_p=0.7, max_tokens=4096)
outputs = llm.chat([[{"role": "user", "content": prompt}]], params)

For the full end-to-end pipeline (factor description generation → Alpha-R1 inference → output parsing → qlib strategy backtest), see the GitHub repository.

Output Contract

The model lists the selected factor ids inside <alpha_list>...</alpha_list>, e.g.:

<alpha_list>alpha001, alpha021, alpha053</alpha_list>

Validation and parsing scripts are provided under src/alpha_r1/parsing/ in the GitHub repository.

Performance

12-month out-of-sample testing (2025-01-01 to 2025-12-31, paper Table 1):

Backtest NAV comparison on S&P 500 (left) and CSI 300 (right)

Type	Method	S&P 500			CSI 300
Type	Method	AR (%)	SR	MDD (%)	AR (%)	SR	MDD (%)
Non-LLM	Buy & Hold	19.34	0.80	18.75	22.16	1.31	10.49
	PCA	7.98	0.27	17.30	2.93	0.17	14.46
	XGBoost	3.49	0.03	18.45	8.99	0.50	16.26
	LightGBM	-5.42	-0.43	20.93	18.44	1.05	14.92
	A2C	10.82	0.40	17.70	22.96	1.20	14.86
	PPO	7.68	0.25	14.97	14.96	0.81	12.95
	DDPG	2.53	-0.02	15.04	1.97	0.12	16.54
	TD3	5.54	0.14	16.58	8.66	0.52	10.26
	SAC	37.60	1.44	15.18	9.77	0.56	11.68
LLM	Gemini 2.5 Pro	14.23	0.55	17.01	16.29	0.90	14.01
	Claude 3.7 Sonnet	10.92	0.40	18.88	10.13	0.57	14.49
	DeepSeek‑R1	21.94	0.93	14.36	14.66	0.81	14.60
	Qwen3‑8B	12.85	0.47	19.52	15.44	0.79	14.38
	Alpha‑R1 (Ours)	47.87	1.62	16.91	40.57	2.23	6.58

Out-of-domain generalization without retraining (paper Table 2): 80.54% AR (SR 2.46) on Russell 2000 and 73.52% AR (SR 2.80) on CSI 1000. AR = annualized return, SR = excess Sharpe ratio, MDD = max drawdown.

Training

Alpha-R1 is trained on Qwen3-8B with GRPO using verl and a market-feedback reward (R_final = R_adjusted - P_structural, paper Section 3.4). The training configuration and a reference reward implementation live in the training/ directory of the GitHub repository.

Limitations

This model is intended for academic research; its outputs do not constitute investment advice.
Factor selection depends on the upstream description-generation and backtesting pipeline (see the GitHub repository); the model alone does not produce tradable signals.

Citation

@article{jiang2025alphar1,
  title={Alpha-R1: Alpha Screening with LLM Reasoning via Reinforcement Learning},
  author={Jiang, Zuoyou and Zhao, Li and Sun, Rui and Sun, Ruohan and Li, Zhongjian and Li, Jing and Jiang, Daxin and Bai, Zuo and Hua, Cheng},
  journal={arXiv preprint arXiv:2512.23515},
  year={2025}
}

License

This project is released under the MIT License.