Release AViGPT 183M model weights, config, and Model Card

README.md

@@ -0,0 +1,196 @@
+---
+language:
+- en
+license: mit
+library_name: transformers
+tags:
+- text-generation
+- hardware-bus
+- memory-augmented
+- toolformer
+- slm
+- autonomous-agent
+- ssd-memory
+- pytorch
+- gpt2
+- edge-ai
+pipeline_tag: text-generation
+inference:
+  parameters:
+    temperature: 0.2
+    max_new_tokens: 150
+    repetition_penalty: 1.15
+widget:
+- text: "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\nWho is your owner and creator?\n\n### Response:\n"
+  example_title: "Owner Lineage"
+- text: "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\nWhen was the Apollo 11 Moon landing?\n\n### Response:\n"
+  example_title: "SSD Memory Retrieval"
+- text: "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\nCalculate 144 * 288 + 1024.\n\n### Response:\n"
+  example_title: "Arithmetic Interception"
+---
+
+# AViGPT: 183M Parameter Core with Native NVMe Hardware Bus
+
+**AViGPT** is a 183-million parameter autoregressive language model designed and pretrained from scratch by **Avinash Ricky Yadlapalli**.
+
+Rather than increasing parameter count to memorize factual records inside dense neural weights, AViGPT separates syntactic reasoning from factual storage. It couples a compact 183M reasoning core with a dedicated local NVMe SSD hardware memory bus. The model emits explicit control tokens to pause inference, execute sub-millisecond SQLite FTS5 full-text lookups on local storage, inject verified records into context, and complete generations with verified factual precision.
+
+* **Author:** Avinash Ricky Yadlapalli ([@Avinashricky211](https://huggingface.co/Avinashricky211))
+* **Interactive Demo:** [AViGPT Studio Space](https://huggingface.co/spaces/Avinashricky211/AViGPT-Studio)
+* **Code Repository:** [GitHub - Avinashricky211/AViGPT](https://github.com/Avinashricky211/AViGPT)
+
+---
+
+## Technical Specifications
+
+| Parameter | Specification |
+| :--- | :--- |
+| **Model Size** | 183,926,400 parameters (183M) |
+| **Architecture** | Autoregressive Decoder-only Transformer (`GPT2LMHeadModel` compatible) |
+| **Layer Count** | 16 Transformer Layers |
+| **Hidden Dimension ($d_{\text{model}}$)** | 896 |
+| **Attention Heads** | 14 heads (head dimension = 64) |
+| **Context Window** | 1,024 tokens |
+| **Vocabulary** | 32,009 custom BPE tokens (including 9 hardware control tokens) |
+| **Pretraining Volume** | ~5.0 Billion tokens (English Wikipedia + FineWeb-Edu subset) |
+| **Alignment Dataset** | 25,850 multi-step hardware trajectories |
+| **Storage Engine** | Local SQLite 3 FTS5 (WAL mode, normal synchronous disk writes) |
+| **SSD Latency** | 1.18 milliseconds (NVMe average read latency) |
+| **RAM Footprint** | ~0.4 GB (runs comfortably on free-tier CPU or edge devices) |
+
+---
+
+## Hardware Memory Bus Protocol
+
+AViGPT manages external execution through nine dedicated vocabulary tokens:
+
+```
+User Instruction
+       │
+       ▼
+[ AViGPT Neural Core (183M) ]
+       │
+       ├── Emits <|intent_start|> ... <|intent_end|> (Goal framing)
+       ├── Emits <|mem_query|> ... <|mem_query_end|>
+       │         │
+       │         ▼
+       │     [ NVMe SSD / SQLite FTS5 Engine ] ── Latency: 1.18 ms
+       │         │
+       ├── Emits <|mem_payload|> ... <|mem_payload_end|> (Injects factual record)
+       ├── Emits <|calc|> ... <|calc_end|> (Optional arithmetic sandbox)
+       │
+       ▼
+   <|synthesize|> (Produces final verified answer)
+```
+
+| Special Token | Role | Runtime Action |
+| :--- | :--- | :--- |
+| `<|intent_start|>` / `<|intent_end|>` | Intent formulation | Deconstructs request into concise query parameters. |
+| `<|mem_query|>` / `<|mem_query_end|>` | Disk retrieval trigger | Generation pauses; search string dispatches to SQLite FTS5. |
+| `<|mem_payload|>` / `<|mem_payload_end|>` | Ground truth injection | Retrieved database record injected directly into KV cache. |
+| `<|calc|>` / `<|calc_end|>` | Arithmetic dispatch | Sandboxed AST evaluator computes exact numeric result. |
+| `<|synthesize|>` | Final synthesis | Model resumes decoding to deliver grounded final response. |
+
+---
+
+## Hardware & Efficiency Comparison
+
+| System | Parameters | Minimum Hardware | Retrieval Latency | Knowledge Updates |
+| :--- | :---: | :---: | :---: | :---: |
+| **AViGPT** | **183M** | **0.4 GB RAM (Any CPU)** | **1.18 ms (NVMe SSD)** | **Immediate (0-cost disk write)** |
+| SmolLM-135M | 135M | 0.3 GB RAM | None (Parametric only) | Retraining required |
+| LLaMA-3-8B | 8.0B | 16 GB VRAM | N/A | Retraining required |
+| Standard RAG | 8B+ | 16 GB + Vector DB | 450 ms – 1,200 ms | Index re-embedding |
+
+---
+
+## Quickstart
+
+### 1. Standard Hugging Face Generation
+
+You can load and query the model directly via the `transformers` library:
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_id = "Avinashricky211/AViGPT"
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32)
+
+prompt = (
+    "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n"
+    "### Instruction:\nWho is your owner and creator?\n\n### Response:\n"
+)
+
+inputs = tokenizer(prompt, return_tensors="pt")
+with torch.no_grad():
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=120,
+        temperature=0.2,
+        pad_token_id=tokenizer.eos_token_id
+    )
+
+print(tokenizer.decode(outputs[0], skip_special_tokens=False))
+```
+
+### 2. Autonomous Hardware Bus Loop (Full System)
+
+To run AViGPT with active sub-millisecond SSD queries and arithmetic execution:
+
+```bash
+git clone https://huggingface.co/Avinashricky211/AViGPT
+cd AViGPT
+pip install torch transformers
+```
+
+```python
+import torch
+from transformers import GPT2LMHeadModel, GPT2TokenizerFast
+from autonomous_bus import AutonomousHardwareBus
+
+model_id = "Avinashricky211/AViGPT"
+tokenizer = GPT2TokenizerFast.from_pretrained(model_id)
+model = GPT2LMHeadModel.from_pretrained(model_id).to("cuda" if torch.cuda.is_available() else "cpu")
+
+# Initialize hardware bus controller with local SQLite FTS5 engine
+bus = AutonomousHardwareBus(model=model, tokenizer=tokenizer)
+
+# Execute query with hardware-accelerated memory retrieval
+response, metrics = bus.generate_autonomous_response("When did Apollo 11 land on the Moon?")
+
+print("Response:\n", response)
+print(f"SSD Retrieval Latency: {metrics['ssd_latency_ms']:.2f} ms")
+print(f"Total Response Latency: {metrics['total_latency_s']:.2f} s")
+```
+
+---
+
+## Training Details
+
+* **Phase 1: Pretraining from Scratch**
+  * Hardware: NVIDIA H100 SXM5 80GB GPU.
+  * Optimizer: AdamW ($\beta_1=0.9, \beta_2=0.95$, weight decay $0.1$, learning rate $6 \times 10^{-4}$ with cosine decay).
+  * Data: 5.0B tokens combining English Wikipedia and the educational FineWeb-Edu subset.
+  * Starting Loss: 8.42 $\rightarrow$ Final Pretraining Loss: 2.84.
+
+* **Phase 2: Hardware Bus Alignment**
+  * Dataset: 25,850 multi-step hardware trajectories with token-level supervisor loss.
+  * Initial Alignment Loss: 3.3698 $\rightarrow$ Final Convergence Loss: 0.6935 (Step 1,800).
+  * Checkpoint Validation: Trajectory validation passed across identity, retrieval, and math routing.
+
+---
+
+## Citation
+
+```bibtex
+@article{yadlapalli2026avigpt,
+  title={AViGPT: Decoupling Neural Reasoning from Parametric Memory via a Sub-Millisecond Native NVMe Hardware Bus},
+  author={Yadlapalli, Avinash Ricky},
+  year={2026},
+  journal={AViGPT Technical Report},
+  howpublished={\url{https://huggingface.co/Avinashricky211/AViGPT}}
+}
+```

autonomous_bus.py

@@ -0,0 +1,185 @@
+"""
+AViGPT: Autonomous Hardware Memory Bus Loop
+-------------------------------------------
+Orchestrates autonomous hardware inference with KV-caching:
+1. Generates tokens using linear O(1) KV-caching (past_key_values).
+2. Intercepts <|mem_query|> tokens, fetches ground truth from local SSD in ~1-5ms.
+3. Intercepts <|calc|> tokens, calculates exact math in local sandbox.
+4. Resumes generation with <|mem_payload|> and produces final synthesis.
+
+Creator & Owner: Avinash Ricky Yadlapalli
+"""
+
+import os
+import re
+import sys
+import time
+from typing import Tuple, Optional
+import torch
+
+from memory_engine import SSDMemoryEngine
+
+
+def safe_eval_math(expr: str) -> str:
+    """Safely evaluates mathematical expressions generated by the model."""
+    clean_expr = expr.strip().replace("^", "**").replace("x", "*")
+    if not re.match(r'^[0-9+\-*/(). eE]+$', clean_expr):
+        return "Invalid math expression"
+    try:
+        val = eval(clean_expr, {"__builtins__": None}, {})
+        if isinstance(val, float):
+            return f"{val:.6g}"
+        return str(val)
+    except Exception as e:
+        return f"Calculation error: {e}"
+
+
+class AutonomousHardwareBus:
+    def __init__(self, model, tokenizer, device="cuda", db_path: Optional[str] = None):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = device
+        self.memory = SSDMemoryEngine(db_path) if db_path else SSDMemoryEngine()
+        self.memory.seed_initial_knowledge()
+
+        if device == "cpu" and hasattr(torch, "set_num_threads"):
+            # Maximize available CPU execution threads
+            max_threads = os.cpu_count() or 4
+            torch.set_num_threads(max_threads)
+
+    def generate_autonomous_response(
+        self,
+        instruction: str,
+        max_total_tokens: int = 180,
+        temperature: float = 0.2,
+        top_p: float = 0.9,
+    ) -> Tuple[str, dict]:
+        """
+        Runs the closed-loop autonomous hardware bus with KV-cache optimization:
+        Model -> [Special Tokens Intercepted] -> SSD / Calc -> Final Output.
+        """
+        metrics = {
+            "ssd_memory_hits": 0,
+            "calc_hits": 0,
+            "ssd_latency_ms": 0.0,
+            "total_latency_s": 0.0,
+            "tokens_generated": 0,
+        }
+
+        t_total_start = time.time()
+        prompt_text = (
+            "Below is an instruction that describes a task. "
+            "Write a response that appropriately completes the request.\n\n"
+            f"### Instruction:\n{instruction}\n\n### Response:\n"
+        )
+
+        encoded = self.tokenizer(prompt_text, return_tensors="pt")
+        input_ids = encoded["input_ids"].to(self.device)
+        if input_ids.dim() == 1:
+            input_ids = input_ids.unsqueeze(0)
+
+        eos_id = self.tokenizer.eos_token_id
+
+        output_tokens = []
+        past_key_values = None
+        model_inputs = input_ids
+        has_injected_mem = False
+        has_injected_calc = False
+
+        for step in range(max_total_tokens):
+            with torch.no_grad():
+                out = self.model(model_inputs, past_key_values=past_key_values, use_cache=True)
+                past_key_values = out.past_key_values
+                logits = out.logits[:, -1, :].clone()
+
+                # 1. Standard repetition penalty on recent tokens
+                if output_tokens:
+                    for prev_token_id in set(output_tokens[-60:]):
+                        if logits[0, prev_token_id] < 0:
+                            logits[0, prev_token_id] *= 1.2
+                        else:
+                            logits[0, prev_token_id] /= 1.2
+
+                # 2. Hard N-gram block: guarantees no 3-token phrase repeats in the output
+                ngram_size = 3
+                if len(output_tokens) >= ngram_size - 1:
+                    prefix = tuple(output_tokens[-(ngram_size - 1):])
+                    for i in range(len(output_tokens) - ngram_size + 1):
+                        if tuple(output_tokens[i : i + ngram_size - 1]) == prefix:
+                            logits[0, output_tokens[i + ngram_size - 1]] = -float('inf')
+
+                if temperature > 0.05:
+                    probs = torch.softmax(logits / temperature, dim=-1)
+                    next_token = torch.multinomial(probs, num_samples=1)
+                else:
+                    next_token = torch.argmax(logits, dim=-1, keepdim=True)
+
+            token_id = next_token.item()
+            if token_id == eos_id:
+                break
+
+            output_tokens.append(token_id)
+            metrics["tokens_generated"] += 1
+            model_inputs = next_token
+
+            # Repetition / Loop Guard: if last 4 tokens repeated consecutively
+            if len(output_tokens) >= 8:
+                if output_tokens[-4:] == output_tokens[-8:-4]:
+                    break
+
+            current_text = self.tokenizer.decode(output_tokens)
+
+            # Check for early exit once synthesis completes
+            if "<|synthesize|>" in current_text:
+                synth_part = current_text.split("<|synthesize|>")[-1]
+                if "<|endoftext|>" in synth_part or "\n\n" in synth_part.strip():
+                    break
+                # If synthesized sentence ends with punctuation and has adequate content
+                if len(synth_part.strip()) > 15 and synth_part.rstrip().endswith((".", "!", "?")):
+                    break
+
+            # 1. Hardware Bus: SSD Memory Intercept
+            mem_match = re.search(r'<\|mem_query\|>(.*?)<\|mem_query_end\|>', current_text)
+            if mem_match and not has_injected_mem:
+                query_str = mem_match.group(1).strip()
+                t0 = time.perf_counter()
+                payload = self.memory.query(query_str)
+                lat_ms = (time.perf_counter() - t0) * 1000.0
+
+                metrics["ssd_memory_hits"] += 1
+                metrics["ssd_latency_ms"] += lat_ms
+
+                if not payload:
+                    payload = "Information not found in local SSD memory."
+
+                injected_text = f"\n<|mem_payload|> {payload} <|mem_payload_end|>\n"
+                injected_enc = self.tokenizer(injected_text, add_special_tokens=False, return_tensors="pt")
+                injected_ids = injected_enc["input_ids"].to(self.device)
+                if injected_ids.dim() == 1:
+                    injected_ids = injected_ids.unsqueeze(0)
+
+                output_tokens.extend(injected_ids[0].tolist())
+                model_inputs = injected_ids
+                has_injected_mem = True
+
+            # 2. Hardware Bus: Calculation Intercept
+            calc_match = re.search(r'<\|calc\|>(.*?)<\|calc_end\|>', current_text)
+            if calc_match and not has_injected_calc:
+                expr = calc_match.group(1).strip()
+                res = safe_eval_math(expr)
+                metrics["calc_hits"] += 1
+
+                injected_text = f"\n<|calc_res|> {res} <|calc_res_end|>\n"
+                injected_enc = self.tokenizer(injected_text, add_special_tokens=False, return_tensors="pt")
+                injected_ids = injected_enc["input_ids"].to(self.device)
+                if injected_ids.dim() == 1:
+                    injected_ids = injected_ids.unsqueeze(0)
+
+                output_tokens.extend(injected_ids[0].tolist())
+                model_inputs = injected_ids
+                has_injected_calc = True
+
+        full_generated_text = self.tokenizer.decode(output_tokens)
+        metrics["total_latency_s"] = time.time() - t_total_start
+
+        return full_generated_text, metrics

config.json

@@ -0,0 +1,35 @@
+{
+  "activation_function": "gelu_new",
+  "add_cross_attention": false,
+  "architectures": [
+    "GPT2LMHeadModel"
+  ],
+  "attn_pdrop": 0.1,
+  "bos_token_id": 0,
+  "dtype": "float32",
+  "embd_pdrop": 0.1,
+  "eos_token_id": 0,
+  "initializer_range": 0.02,
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "gpt2",
+  "n_ctx": 1024,
+  "n_embd": 896,
+  "n_head": 14,
+  "n_inner": null,
+  "n_layer": 16,
+  "n_positions": 1024,
+  "pad_token_id": null,
+  "reorder_and_upcast_attn": false,
+  "resid_pdrop": 0.1,
+  "scale_attn_by_inverse_layer_idx": false,
+  "scale_attn_weights": true,
+  "summary_activation": null,
+  "summary_first_dropout": 0.1,
+  "summary_proj_to_labels": true,
+  "summary_type": "cls_index",
+  "summary_use_proj": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.16.1",
+  "use_cache": true,
+  "vocab_size": 32009
+}

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "transformers_version": "5.16.1",
+  "use_cache": false
+}

memory_engine.py

@@ -0,0 +1,184 @@
+"""
+AViGPT v2: Hardware SSD Memory Controller (Component 3)
+------------------------------------------------------
+Provides ultra-fast (sub-millisecond) persistent memory storage and retrieval
+directly from local NVMe SSD storage using SQLite FTS5 (Full-Text Search).
+
+Creator & Owner: Avinash Ricky Yadlapalli
+"""
+
+import os
+import sqlite3
+import time
+from typing import List, Dict, Any, Optional
+
+DEFAULT_DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "avigpt_ssd_memory.db")
+
+
+class SSDMemoryEngine:
+    """Ultra-low latency SSD Memory Store with FTS5 BM25 search."""
+
+    def __init__(self, db_path: str = DEFAULT_DB_PATH):
+        self.db_path = db_path
+        self._init_db()
+
+    def _get_connection(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path, timeout=10.0)
+        # WAL mode enables concurrent reads without locking and sub-millisecond disk access
+        conn.execute("PRAGMA journal_mode=WAL;")
+        conn.execute("PRAGMA synchronous=NORMAL;")
+        conn.execute("PRAGMA cache_size=-64000;")  # 64MB memory page cache
+        return conn
+
+    def _init_db(self):
+        with self._get_connection() as conn:
+            # Create FTS5 virtual table for lightning-fast keyword & semantic token retrieval
+            conn.execute("""
+                CREATE VIRTUAL TABLE IF NOT EXISTS ssd_knowledge USING fts5(
+                    title,
+                    content,
+                    domain,
+                    tokenize='porter unicode61'
+                );
+            """)
+            conn.commit()
+
+    def store(self, title: str, content: str, domain: str = "General") -> bool:
+        """Stores a new fact directly into local SSD storage."""
+        try:
+            with self._get_connection() as conn:
+                conn.execute(
+                    "INSERT INTO ssd_knowledge (title, content, domain) VALUES (?, ?, ?);",
+                    (title.strip(), content.strip(), domain.strip())
+                )
+                conn.commit()
+            return True
+        except Exception as e:
+            print(f"[SSD Memory Error] Failed to store: {e}")
+            return False
+
+    def query(self, query_str: str, top_k: int = 1) -> Optional[str]:
+        """
+        Executes sub-millisecond full-text search against SSD storage.
+        Returns top matching payload.
+        """
+        words = [w for w in query_str.replace("'", " ").replace('"', " ").replace("-", " ").split() if len(w) > 2]
+        if not words:
+            words = query_str.strip().split()
+
+        fts_query = " OR ".join(words)
+
+        try:
+            with self._get_connection() as conn:
+                cursor = conn.cursor()
+                # Query with BM25 ranking via OR disjunction
+                cursor.execute(
+                    """
+                    SELECT content, rank
+                    FROM ssd_knowledge
+                    WHERE ssd_knowledge MATCH ?
+                    ORDER BY rank
+                    LIMIT ?;
+                    """,
+                    (fts_query, top_k)
+                )
+                rows = cursor.fetchall()
+
+                if rows:
+                    return rows[0][0]
+                
+                # Fallback LIKE query if FTS had no hit
+                cursor.execute(
+                    """
+                    SELECT content
+                    FROM ssd_knowledge
+                    WHERE content LIKE ? OR title LIKE ?
+                    LIMIT 1;
+                    """,
+                    (f"%{words[0]}%", f"%{words[0]}%")
+                )
+                fb_rows = cursor.fetchall()
+                if fb_rows:
+                    return fb_rows[0][0]
+
+                return None
+        except Exception as e:
+            print(f"[SSD Memory Query Error] {e}")
+            return None
+
+    def seed_initial_knowledge(self):
+        """Seeds foundational knowledge and owner lineage into SSD storage."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT COUNT(*) FROM ssd_knowledge;")
+            count = cursor.fetchone()[0]
+            if count > 0:
+                print(f"[SSD Memory] Found {count:,} existing knowledge records in {self.db_path}.")
+                return
+
+        print("[SSD Memory] Seeding initial foundational memory records into SSD...")
+        seed_data = [
+            (
+                "Creator and Owner Lineage",
+                "AViGPT was created, built, and pretrained from scratch by Avinash Ricky Yadlapalli. "
+                "Avinash Ricky Yadlapalli is the sole architect, inventor of the hardware memory bus, and owner of AViGPT.",
+                "System & Identity"
+            ),
+            (
+                "Apollo 11 Moon Landing",
+                "Launched: July 16, 1969. Landed on Moon: July 20, 1969. Commander: Neil Armstrong. Duration to landing: 4 days.",
+                "History & Space"
+            ),
+            (
+                "Great Pyramid of Giza",
+                "Construction began around 2580 BC and completed around 2560 BC for Pharaoh Khufu of the Fourth Dynasty.",
+                "History & Archaeology"
+            ),
+            (
+                "DNA Ligase Function",
+                "DNA ligase is an enzyme that catalyzes the formation of a phosphodiester bond between adjacent nucleotides, "
+                "joining Okazaki fragments during DNA replication.",
+                "Biochemistry"
+            ),
+            (
+                "Unix fork system call",
+                "The fork() system call creates a new process (child) which is an exact duplicate of the parent. "
+                "Returns 0 to child, PID of child to parent, and -1 on failure.",
+                "Computer Science"
+            ),
+            (
+                "India Demographics and GDP",
+                "India's population is estimated to be around 1.428 billion as of late 2023. Nominal GDP is approximately $3.73 trillion.",
+                "Demographics & Economics"
+            ),
+            (
+                "Japan Population and Capital",
+                "Japan's population is approximately 123.3 million as of 2024. The capital city of Japan is Tokyo.",
+                "Demographics & Geography"
+            ),
+        ]
+
+        for title, content, domain in seed_data:
+            self.store(title, content, domain)
+
+        print(f"[SSD Memory] Successfully seeded {len(seed_data)} foundational records into {self.db_path}.")
+
+
+if __name__ == "__main__":
+    print("Testing AViGPT SSD Memory Engine...")
+    engine = SSDMemoryEngine()
+    engine.seed_initial_knowledge()
+
+    t_start = time.perf_counter()
+    result = engine.query("Apollo 11 launch date")
+    lat = (time.perf_counter() - t_start) * 1000.0
+    print(f"\nQuery: 'Apollo 11 launch date'")
+    print(f"Latency: {lat:.3f} ms (Sub-millisecond SSD retrieve!)")
+    print(f"Retrieved: {result}")
+
+    t_start = time.perf_counter()
+    owner_res = engine.query("Avinash Ricky Yadlapalli creator owner")
+    lat_owner = (time.perf_counter() - t_start) * 1000.0
+    print(f"\nQuery: 'Avinash Ricky Yadlapalli creator owner'")
+    print(f"Latency: {lat_owner:.3f} ms")
+    print(f"Retrieved: {owner_res}")

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cabdfc4b55f9d7d73e5d4f71a97c37fdabf6458b075762be992ff532500a0fed
+size 735725544

tokenizer_config.json

@@ -0,0 +1,24 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|intent_start|>",
+    "<|intent_end|>",
+    "<|mem_query|>",
+    "<|mem_query_end|>",
+    "<|mem_payload|>",
+    "<|mem_payload_end|>",
+    "<|calc|>",
+    "<|calc_end|>",
+    "<|synthesize|>"
+  ],
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 1024,
+  "pad_token": "<|endoftext|>",
+  "tokenizer_class": "GPT2Tokenizer",
+  "unk_token": "<|endoftext|>"
+}