Instructions to use Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience with Transformers:

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

pipe = pipeline("text-generation", model="Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience")
model = AutoModelForMultimodalLM.from_pretrained("Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.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(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience

SGLang

How to use Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience 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 "Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience" \
    --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": "Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience",
		"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 "Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience" \
        --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": "Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience with Docker Model Runner:
```
docker model run hf.co/Yangtze-ailab/LDM-Acq-SFT-Qwen3.5-9B-MixedScience
```

LDM-SFT-Qwen3.5-9B-MixedScience

A Qwen/Qwen3.5-9B model fine-tuned to serve as the proposer inside a Large Discovery Model (LDM): given the state of an ongoing optimization campaign, it reasons about the search progress and proposes the next candidate experiment, amortising a high-budget model-based search loop into a single forward pass.

Model Summary

An LDM runs a recurrent generate → select → evaluate → update loop in which an LLM proposes candidates, a probabilistic surrogate turns observations into a posterior mean and uncertainty, and an acquisition function selects the next experiment. This model is the proposer, trained by full-parameter supervised fine-tuning on trajectories collected from that loop across three scientific-discovery domains, so that the acquisition-guided search policy is distilled into its weights. It emits a chain-of-thought trace followed by a structured action (the proposed candidates).

Base model: Qwen/Qwen3.5-9B
Chat template: qwen3_5 (chain-of-thought / thinking enabled)
Domains: AutoResearch (nanoGPT), small-molecule design, antibody (CDRH3) design

Intended Use

Deployment as the candidate proposer within the LDM acquisition loop, where the surrogate and acquisition function remain external. The model reads the evaluated history and task constraints and returns reasoning plus the next candidate(s).

How to Use

from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "Yangtze-ailab/LDM-SFT-Qwen3.5-9B-MixedScience"
tok = AutoTokenizer.from_pretrained(repo, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    repo, torch_dtype="bfloat16", device_map="auto", trust_remote_code=True)

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},   # proposer role + output contract
    {"role": "user",   "content": SEARCH_STATE},    # evaluated history + constraints
]
inputs = tok.apply_chat_template(
    messages, add_generation_prompt=True, enable_thinking=True, return_tensors="pt"
).to(model.device)
out = model.generate(inputs, max_new_tokens=2048, temperature=0.7)
print(tok.decode(out[0][inputs.shape[1]:], skip_special_tokens=True))

The output is a <think> … </think> reasoning block followed by a JSON action describing the proposed candidate(s).

Training

Method: full-parameter SFT (DeepSpeed ZeRO-3 with CPU offload, bf16, gradient checkpointing)
Sequence length: 16,384
Optimisation: learning rate 1e-5, cosine schedule, warmup ratio 0.03, 2 epochs, effective batch size = per-device 1 × gradient accumulation 8 × #GPUs
Framework: LLaMA-Factory

Training Data

Fine-tuned on the LDM mixed-science SFT corpus — proposal decisions collected from high-budget LDM test-time search across the three domains and rendered in Alpaca format. The corresponding public datasets are:

LDM-CoT-Acq-SFT-16K — chain-of-thought, surrogate values shown in the prompt
LDM-CoT-SFT-16K — chain-of-thought, surrogate values hidden
LDM-TTS-Base-SFT-19K — direct action, no reasoning

Limitations

The model is designed to operate inside the LDM loop; used standalone it proposes candidates but does not itself evaluate them.
Behaviour reflects the specific oracles used during data collection (Vina, an activity model, and Absolut) and the three covered domains; transfer beyond them is not guaranteed.
Reasoning traces in the training data were machine-generated and translated to English.