Instructions to use BernaLabs/berna-r8 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use BernaLabs/berna-r8 with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="BernaLabs/berna-r8")# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("BernaLabs/berna-r8", device_map="auto") - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use BernaLabs/berna-r8 with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "BernaLabs/berna-r8" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "BernaLabs/berna-r8", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'Use Docker
docker model run hf.co/BernaLabs/berna-r8
- SGLang
How to use BernaLabs/berna-r8 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 "BernaLabs/berna-r8" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "BernaLabs/berna-r8", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'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 "BernaLabs/berna-r8" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "BernaLabs/berna-r8", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }' - Docker Model Runner
How to use BernaLabs/berna-r8 with Docker Model Runner:
docker model run hf.co/BernaLabs/berna-r8
File size: 2,821 Bytes
d997548 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 | """
Sequential Growth Engine — orchestrates Birth and Split events with K6 gating.
"""
from collections import deque
class SequentialGrowthEngine:
def __init__(self, max_events_per_step=1, max_births_per_100=5,
max_splits_per_100=3, cooldown_steps=100, verbose=False):
self.max_events_per_step = max_events_per_step
self.max_births_per_100 = max_births_per_100
self.max_splits_per_100 = max_splits_per_100
self.cooldown_steps = cooldown_steps
self.verbose = verbose
self.queue = deque()
self.birth_history = []
self.split_history = []
self.layer_last_event = {}
self.total_births = 0
self.total_splits = 0
self.total_rejected = 0
def _recent_count(self, history, step, window=100):
return sum(1 for s in history if step - s < window)
def can_birth(self, layer_idx, step):
if self._recent_count(self.birth_history, step) >= self.max_births_per_100:
return False
last = self.layer_last_event.get(layer_idx, -1e9)
return (step - last) >= self.cooldown_steps
def can_split(self, layer_idx, step):
if self._recent_count(self.split_history, step) >= self.max_splits_per_100:
return False
last = self.layer_last_event.get(layer_idx, -1e9)
return (step - last) >= self.cooldown_steps
def enqueue(self, event):
self.queue.append(event)
def process_one(self, step):
processed = []
for _ in range(self.max_events_per_step):
if not self.queue:
break
found = False
for i, event in enumerate(self.queue):
if event["type"] == "birth" and self.can_birth(event["layer_idx"], step):
e = self.queue[i]; del self.queue[i]
self.birth_history.append(step)
self.layer_last_event[e["layer_idx"]] = step
self.total_births += 1
processed.append(e); found = True; break
elif event["type"] == "split" and self.can_split(event["layer_idx"], step):
e = self.queue[i]; del self.queue[i]
self.split_history.append(step)
self.layer_last_event[e["layer_idx"]] = step
self.total_splits += 1
processed.append(e); found = True; break
if not found:
self.total_rejected += 1
break
return processed
def pending_count(self):
return len(self.queue)
def stats(self):
return {
"queued": len(self.queue),
"births": self.total_births,
"splits": self.total_splits,
"rejected": self.total_rejected,
}
|