Instructions to use appvoid/void.0 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Notebooks
Google Colab
Kaggle
Local Apps Settings

How to use appvoid/void.0 with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf appvoid/void.0
# Run inference directly in the terminal:
llama cli -hf appvoid/void.0

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf appvoid/void.0
# Run inference directly in the terminal:
llama cli -hf appvoid/void.0

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf appvoid/void.0
# Run inference directly in the terminal:
./llama-cli -hf appvoid/void.0

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf appvoid/void.0
# Run inference directly in the terminal:
./build/bin/llama-cli -hf appvoid/void.0

Use Docker

docker model run hf.co/appvoid/void.0

LM Studio
Jan
Ollama
How to use appvoid/void.0 with Ollama:
```
ollama run hf.co/appvoid/void.0
```

Unsloth Studio

How to use appvoid/void.0 with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for appvoid/void.0 to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for appvoid/void.0 to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for appvoid/void.0 to start chatting

Docker Model Runner
How to use appvoid/void.0 with Docker Model Runner:
```
docker model run hf.co/appvoid/void.0
```

Lemonade

How to use appvoid/void.0 with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull appvoid/void.0

Run and chat with the model

lemonade run user.void.0-{{QUANT_TAG}}

List all available models

lemonade list

Atomic Chat

appvoid commited on 15 days ago

Commit

429dbc0

verified ·

1 Parent(s): 3886817

Continued pretraining: FineWeb-Edu + rewrite6 byte hybrid + no-prompt-15k

Browse files

Files changed (2) hide show

hybrid_tokenizer.py +154 -0
hybrid_tokenizer_config.json +301 -0

hybrid_tokenizer.py ADDED Viewed

	@@ -0,0 +1,154 @@

+from __future__ import annotations
+from typing import Iterable
+from transformers import AutoTokenizer
+class HybridByteTokenizer:
+    def __init__(self, model_id_or_path: str, **kwargs):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id_or_path, **kwargs)
+        vocab = self.tokenizer.get_vocab()
+        self.byte_token_ids = []
+        for value in range(256):
+            token = f"<0x{value:02X}>"
+            if token not in vocab:
+                raise ValueError(f"Missing byte token: {token}")
+            self.byte_token_ids.append(int(vocab[token]))
+        self.byte_id_to_value = {
+            token_id: value
+            for value, token_id in enumerate(self.byte_token_ids)
+        }
+        self.separator_ids = self.tokenizer.encode(
+            "\\n\\n", add_special_tokens=False
+        )
+        self.quote_ids = self.tokenizer.encode(
+            '"', add_special_tokens=False
+        )
+    def encode_bytes(self, text: str) -> list[int]:
+        return [
+            self.byte_token_ids[value]
+            for value in str(text or "").encode("utf-8")
+        ]
+    def encode_rewrite(
+        self,
+        instruction: str,
+        text: str,
+        output: str = "",
+    ) -> list[int]:
+        ids = []
+        instruction = str(instruction or "").strip()
+        if instruction:
+            ids.extend(
+                self.tokenizer.encode(
+                    instruction,
+                    add_special_tokens=False,
+                )
+            )
+            ids.extend(self.separator_ids)
+        ids.extend(self.quote_ids)
+        ids.extend(self.encode_bytes(text))
+        ids.extend(self.quote_ids)
+        ids.extend(self.separator_ids)
+        ids.extend(self.quote_ids)
+        ids.extend(self.encode_bytes(output))
+        ids.extend(self.quote_ids)
+        return ids
+    def encode_text(
+        self,
+        text: str,
+        byte_inside_quotes: bool = True,
+    ) -> list[int]:
+        if not byte_inside_quotes:
+            return self.tokenizer.encode(text, add_special_tokens=False)
+        ids = []
+        normal = []
+        quoted = []
+        inside = False
+        escaped = False
+        def flush_normal():
+            if normal:
+                ids.extend(
+                    self.tokenizer.encode(
+                        "".join(normal),
+                        add_special_tokens=False,
+                    )
+                )
+                normal.clear()
+        def flush_quoted():
+            if quoted:
+                ids.extend(self.encode_bytes("".join(quoted)))
+                quoted.clear()
+        for character in str(text):
+            if inside:
+                if character == '"' and not escaped:
+                    flush_quoted()
+                    ids.extend(self.quote_ids)
+                    inside = False
+                    escaped = False
+                    continue
+                quoted.append(character)
+                escaped = character == "\\\\" and not escaped
+                if character != "\\\\":
+                    escaped = False
+            else:
+                if character == '"':
+                    flush_normal()
+                    ids.extend(self.quote_ids)
+                    inside = True
+                else:
+                    normal.append(character)
+        if inside:
+            flush_quoted()
+        else:
+            flush_normal()
+        return ids
+    def decode(self, token_ids: Iterable[int]) -> str:
+        output = []
+        normal = []
+        byte_buffer = bytearray()
+        def flush_normal():
+            if normal:
+                output.append(
+                    self.tokenizer.decode(
+                        normal,
+                        skip_special_tokens=False,
+                        clean_up_tokenization_spaces=False,
+                    )
+                )
+                normal.clear()
+        def flush_bytes():
+            if byte_buffer:
+                output.append(
+                    byte_buffer.decode("utf-8", errors="replace")
+                )
+                byte_buffer.clear()
+        for token_id_raw in token_ids:
+            token_id = int(token_id_raw)
+            byte_value = self.byte_id_to_value.get(token_id)
+            if byte_value is None:
+                flush_bytes()
+                normal.append(token_id)
+            else:
+                flush_normal()
+                byte_buffer.append(byte_value)
+        flush_bytes()
+        flush_normal()
+        return "".join(output)

hybrid_tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,301 @@

+{
+  "base_model": "appvoid/void.0",
+  "byte_token_template": "<0x{:02X}>",
+  "byte_tokens": [
+    "<0x00>",
+    "<0x01>",
+    "<0x02>",
+    "<0x03>",
+    "<0x04>",
+    "<0x05>",
+    "<0x06>",
+    "<0x07>",
+    "<0x08>",
+    "<0x09>",
+    "<0x0A>",
+    "<0x0B>",
+    "<0x0C>",
+    "<0x0D>",
+    "<0x0E>",
+    "<0x0F>",
+    "<0x10>",
+    "<0x11>",
+    "<0x12>",
+    "<0x13>",
+    "<0x14>",
+    "<0x15>",
+    "<0x16>",
+    "<0x17>",
+    "<0x18>",
+    "<0x19>",
+    "<0x1A>",
+    "<0x1B>",
+    "<0x1C>",
+    "<0x1D>",
+    "<0x1E>",
+    "<0x1F>",
+    "<0x20>",
+    "<0x21>",
+    "<0x22>",
+    "<0x23>",
+    "<0x24>",
+    "<0x25>",
+    "<0x26>",
+    "<0x27>",
+    "<0x28>",
+    "<0x29>",
+    "<0x2A>",
+    "<0x2B>",
+    "<0x2C>",
+    "<0x2D>",
+    "<0x2E>",
+    "<0x2F>",
+    "<0x30>",
+    "<0x31>",
+    "<0x32>",
+    "<0x33>",
+    "<0x34>",
+    "<0x35>",
+    "<0x36>",
+    "<0x37>",
+    "<0x38>",
+    "<0x39>",
+    "<0x3A>",
+    "<0x3B>",
+    "<0x3C>",
+    "<0x3D>",
+    "<0x3E>",
+    "<0x3F>",
+    "<0x40>",
+    "<0x41>",
+    "<0x42>",
+    "<0x43>",
+    "<0x44>",
+    "<0x45>",
+    "<0x46>",
+    "<0x47>",
+    "<0x48>",
+    "<0x49>",
+    "<0x4A>",
+    "<0x4B>",
+    "<0x4C>",
+    "<0x4D>",
+    "<0x4E>",
+    "<0x4F>",
+    "<0x50>",
+    "<0x51>",
+    "<0x52>",
+    "<0x53>",
+    "<0x54>",
+    "<0x55>",
+    "<0x56>",
+    "<0x57>",
+    "<0x58>",
+    "<0x59>",
+    "<0x5A>",
+    "<0x5B>",
+    "<0x5C>",
+    "<0x5D>",
+    "<0x5E>",
+    "<0x5F>",
+    "<0x60>",
+    "<0x61>",
+    "<0x62>",
+    "<0x63>",
+    "<0x64>",
+    "<0x65>",
+    "<0x66>",
+    "<0x67>",
+    "<0x68>",
+    "<0x69>",
+    "<0x6A>",
+    "<0x6B>",
+    "<0x6C>",
+    "<0x6D>",
+    "<0x6E>",
+    "<0x6F>",
+    "<0x70>",
+    "<0x71>",
+    "<0x72>",
+    "<0x73>",
+    "<0x74>",
+    "<0x75>",
+    "<0x76>",
+    "<0x77>",
+    "<0x78>",
+    "<0x79>",
+    "<0x7A>",
+    "<0x7B>",
+    "<0x7C>",
+    "<0x7D>",
+    "<0x7E>",
+    "<0x7F>",
+    "<0x80>",
+    "<0x81>",
+    "<0x82>",
+    "<0x83>",
+    "<0x84>",
+    "<0x85>",
+    "<0x86>",
+    "<0x87>",
+    "<0x88>",
+    "<0x89>",
+    "<0x8A>",
+    "<0x8B>",
+    "<0x8C>",
+    "<0x8D>",
+    "<0x8E>",
+    "<0x8F>",
+    "<0x90>",
+    "<0x91>",
+    "<0x92>",
+    "<0x93>",
+    "<0x94>",
+    "<0x95>",
+    "<0x96>",
+    "<0x97>",
+    "<0x98>",
+    "<0x99>",
+    "<0x9A>",
+    "<0x9B>",
+    "<0x9C>",
+    "<0x9D>",
+    "<0x9E>",
+    "<0x9F>",
+    "<0xA0>",
+    "<0xA1>",
+    "<0xA2>",
+    "<0xA3>",
+    "<0xA4>",
+    "<0xA5>",
+    "<0xA6>",
+    "<0xA7>",
+    "<0xA8>",
+    "<0xA9>",
+    "<0xAA>",
+    "<0xAB>",
+    "<0xAC>",
+    "<0xAD>",
+    "<0xAE>",
+    "<0xAF>",
+    "<0xB0>",
+    "<0xB1>",
+    "<0xB2>",
+    "<0xB3>",
+    "<0xB4>",
+    "<0xB5>",
+    "<0xB6>",
+    "<0xB7>",
+    "<0xB8>",
+    "<0xB9>",
+    "<0xBA>",
+    "<0xBB>",
+    "<0xBC>",
+    "<0xBD>",
+    "<0xBE>",
+    "<0xBF>",
+    "<0xC0>",
+    "<0xC1>",
+    "<0xC2>",
+    "<0xC3>",
+    "<0xC4>",
+    "<0xC5>",
+    "<0xC6>",
+    "<0xC7>",
+    "<0xC8>",
+    "<0xC9>",
+    "<0xCA>",
+    "<0xCB>",
+    "<0xCC>",
+    "<0xCD>",
+    "<0xCE>",
+    "<0xCF>",
+    "<0xD0>",
+    "<0xD1>",
+    "<0xD2>",
+    "<0xD3>",
+    "<0xD4>",
+    "<0xD5>",
+    "<0xD6>",
+    "<0xD7>",
+    "<0xD8>",
+    "<0xD9>",
+    "<0xDA>",
+    "<0xDB>",
+    "<0xDC>",
+    "<0xDD>",
+    "<0xDE>",
+    "<0xDF>",
+    "<0xE0>",
+    "<0xE1>",
+    "<0xE2>",
+    "<0xE3>",
+    "<0xE4>",
+    "<0xE5>",
+    "<0xE6>",
+    "<0xE7>",
+    "<0xE8>",
+    "<0xE9>",
+    "<0xEA>",
+    "<0xEB>",
+    "<0xEC>",
+    "<0xED>",
+    "<0xEE>",
+    "<0xEF>",
+    "<0xF0>",
+    "<0xF1>",
+    "<0xF2>",
+    "<0xF3>",
+    "<0xF4>",
+    "<0xF5>",
+    "<0xF6>",
+    "<0xF7>",
+    "<0xF8>",
+    "<0xF9>",
+    "<0xFA>",
+    "<0xFB>",
+    "<0xFC>",
+    "<0xFD>",
+    "<0xFE>",
+    "<0xFF>"
+  ],
+  "number_token_max": 999,
+  "number_word_tokens": [
+    "zero",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+    "thirteen",
+    "fourteen",
+    "fifteen",
+    "sixteen",
+    "seventeen",
+    "eighteen",
+    "nineteen",
+    "twenty",
+    "thirty",
+    "forty",
+    "fifty",
+    "sixty",
+    "seventy",
+    "eighty",
+    "ninety",
+    "hundred",
+    "thousand",
+    "million",
+    "billion",
+    "trillion"
+  ],
+  "rewrite_layout": "instruction\\n\\n\"text bytes\"\\n\\n\"output bytes\"",
+  "separator": "\n\n",
+  "max_context_length": 4096
+}