Instructions to use OpenOneRec/KSA-V2-4B-base with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use OpenOneRec/KSA-V2-4B-base with Transformers:

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

pipe = pipeline("text-generation", model="OpenOneRec/KSA-V2-4B-base", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("OpenOneRec/KSA-V2-4B-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("OpenOneRec/KSA-V2-4B-base", trust_remote_code=True, 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=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use OpenOneRec/KSA-V2-4B-base with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/OpenOneRec/KSA-V2-4B-base

SGLang

How to use OpenOneRec/KSA-V2-4B-base 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 "OpenOneRec/KSA-V2-4B-base" \
    --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": "OpenOneRec/KSA-V2-4B-base",
		"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 "OpenOneRec/KSA-V2-4B-base" \
        --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": "OpenOneRec/KSA-V2-4B-base",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use OpenOneRec/KSA-V2-4B-base with Docker Model Runner:
```
docker model run hf.co/OpenOneRec/KSA-V2-4B-base
```

KSA-V2-4B-base / generate.py

OpenOneRec

Release KSA-V2-4B-base weights and inference runtime

a1111f3 verified 2 days ago

Raw History Blame Contribute Delete

2.52 kB

#!/usr/bin/env python3

"""Generate text with a local KSA V2 export and its bundled kernels."""

import argparse
from pathlib import Path
import sys


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Interactively generate text with a local model.")
    parser.add_argument("--model", type=Path, default=Path(__file__).resolve().parent)
    parser.add_argument("--prompt", help="Omit for interactive text completion.")
    parser.add_argument("--max-new-tokens", type=int, default=256)
    parser.add_argument("--apply-chat-template", action="store_true")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    model_dir = args.model.resolve()
    # Select the export's kernels before importing either runtime or Transformers.
    for directory in (model_dir / "kernel/deps", model_dir / "kernel"):
        sys.path.insert(0, str(directory))

    import torch
    from transformers import AutoModelForCausalLM, AutoTokenizer

    tokenizer = AutoTokenizer.from_pretrained(model_dir, local_files_only=True)
    model = AutoModelForCausalLM.from_pretrained(
        model_dir,
        trust_remote_code=True,
        local_files_only=True,
        dtype=torch.bfloat16,
        device_map={"": "cuda:0"},
        attn_implementation="sdpa",
    ).eval()

    def complete(prompt: str) -> str:
        if args.apply_chat_template:
            prompt = tokenizer.apply_chat_template(
                [{"role": "user", "content": prompt}],
                tokenize=False,
                add_generation_prompt=True,
            )

        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
        with torch.inference_mode():
            output_ids = model.generate(
                **inputs,
                max_new_tokens=args.max_new_tokens,
                do_sample=False,
                pad_token_id=tokenizer.eos_token_id,
            )

        new_tokens = output_ids[0, inputs["input_ids"].shape[1] :]
        return tokenizer.decode(new_tokens, skip_special_tokens=True)

    if args.prompt is not None:
        print(complete(args.prompt))
        return
    print("Enter a prompt, or type 'exit' to stop.")
    while True:
        try:
            prompt = input("Prompt: ").strip()
        except (EOFError, KeyboardInterrupt):
            print()
            break
        if prompt.lower() in {"exit", "quit"}:
            break
        if prompt:
            print(complete(prompt))


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3

	"""Generate text with a local KSA V2 export and its bundled kernels."""

	import argparse
	from pathlib import Path
	import sys


	def parse_args() -> argparse.Namespace:
	parser = argparse.ArgumentParser(description="Interactively generate text with a local model.")
	parser.add_argument("--model", type=Path, default=Path(__file__).resolve().parent)
	parser.add_argument("--prompt", help="Omit for interactive text completion.")
	parser.add_argument("--max-new-tokens", type=int, default=256)
	parser.add_argument("--apply-chat-template", action="store_true")
	return parser.parse_args()


	def main() -> None:
	args = parse_args()
	model_dir = args.model.resolve()
	# Select the export's kernels before importing either runtime or Transformers.
	for directory in (model_dir / "kernel/deps", model_dir / "kernel"):
	sys.path.insert(0, str(directory))

	import torch
	from transformers import AutoModelForCausalLM, AutoTokenizer

	tokenizer = AutoTokenizer.from_pretrained(model_dir, local_files_only=True)
	model = AutoModelForCausalLM.from_pretrained(
	model_dir,
	trust_remote_code=True,
	local_files_only=True,
	dtype=torch.bfloat16,
	device_map={"": "cuda:0"},
	attn_implementation="sdpa",
	).eval()

	def complete(prompt: str) -> str:
	if args.apply_chat_template:
	prompt = tokenizer.apply_chat_template(
	[{"role": "user", "content": prompt}],
	tokenize=False,
	add_generation_prompt=True,
	)

	inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
	with torch.inference_mode():
	output_ids = model.generate(
	**inputs,
	max_new_tokens=args.max_new_tokens,
	do_sample=False,
	pad_token_id=tokenizer.eos_token_id,
	)

	new_tokens = output_ids[0, inputs["input_ids"].shape[1] :]
	return tokenizer.decode(new_tokens, skip_special_tokens=True)

	if args.prompt is not None:
	print(complete(args.prompt))
	return
	print("Enter a prompt, or type 'exit' to stop.")
	while True:
	try:
	prompt = input("Prompt: ").strip()
	except (EOFError, KeyboardInterrupt):
	print()
	break
	if prompt.lower() in {"exit", "quit"}:
	break
	if prompt:
	print(complete(prompt))


	if __name__ == "__main__":
	main()