README.md

---
license: apache-2.0
library_name: transformers
tags:
  - text-generation
  - causal-lm
  - custom-architecture
  - core
pipeline_tag: text-generation
---

<p align="center">
  <img src="https://opencore.one/og-image.png" alt="CORe" width="320" />
</p>

# CORe Predetermined V1

**CORe Predetermined V1** is a tiny (30M-parameter) decoder-only language model from **CORe Technologies**, built for one job: **predetermined outcomes without brittle exact-match rules**.

Traditional FAQ / canned-response software matches user input against thousands of stored question strings, and breaks the moment someone types `who's patricia` instead of `who is patricia`. CORe Predetermined takes a different approach: you fine-tune it on your question/answer pairs *once*, and the model generalizes across phrasing, so any reasonable rewording of a covered question returns your predetermined answer.

- **Base model is already filled with a few preview Q&As** (AI-fundamentals concepts) so you can test the behavior immediately, ask about them in any phrasing you like.
- **Fine-tune it on your own Q&A set** to replace or extend the predetermined knowledge. A few dozen pairs is enough.
- Runs anywhere: 120MB, CPU-friendly, no GPU required for inference.

## Quick start

> **Note:** this is a custom architecture, so `trust_remote_code=True` is **required** — without it `from_pretrained` will raise an error about the unknown `core` model type.

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "OpenCOReTechnologies/CORe-Predetermined-v1", trust_remote_code=True
)
model.eval()
tok = AutoTokenizer.from_pretrained("OpenCOReTechnologies/CORe-Predetermined-v1")

def ask(question, max_new_tokens=120, temperature=0.3):
    text = tok.apply_chat_template(
        [{"role": "user", "content": question}],
        add_generation_prompt=True, tokenize=False,
    )
    enc = tok(text, add_special_tokens=False, return_tensors="pt")
    out = model.generate(**enc, max_new_tokens=max_new_tokens,
                         temperature=temperature, top_k=40, do_sample=True)
    return tok.decode(out[0][enc["input_ids"].shape[1]:],
                      skip_special_tokens=True).strip()

print(ask("what's an intelligent agent?"))   # phrasing is flexible
```

## Try the built-in preview questions

The base model ships with a small set of memorized AI-concept answers. Ask them **in your own words**, the point is that exact phrasing doesn't matter:

| Try asking | Observed base-model behavior |
|---|---|
| "What is an intelligent agent?" | **Strongly memorized**, responds with the full structured breakdown ("Let's break down what an intelligent agent is… perception, reasoning, action…") across phrasings |
| "Explain machine learning in simple terms" | **Strongly memorized**, returns the training answer's structure and opening |
| "What is artificial intelligence?" | Memorized concepts (learning, problem-solving, AGI) with some paraphrase drift |
| "What is a neural network?" | Coherent memorized definition, some drift |
| "What is deep learning?" | Coherent short definition, some drift |

The strongly-memorized rows demonstrate the core behavior: one training example, robust retrieval across rephrasings. Fine-tuning on your own pairs moves your content into that strongly-memorized regime.

## Fine-tuning your own predetermined answers

Prepare a text file of Q&A pairs in the chat format:

```
<|user|>
How do I reset my password?
<|assistant|>
Go to Settings → Account → Reset Password. The reset link expires in 15 minutes.
<|endoftext|>
```

Fine-tune with any standard causal-LM loop (the model is a plain `PreTrainedModel`, so `Trainer`, `accelerate`, or a hand-rolled loop all work). At 30M parameters, a full fine-tune runs on a laptop CPU in minutes to hours depending on dataset size. Low learning rates (1e-5 to 5e-5) with a few epochs over your pairs is usually enough; the model is small enough that it will memorize your set quickly while keeping phrasing robustness.

Tips:
- **20–200 pairs per topic cluster** works well; you do *not* need thousands of exact-string variants.
- Keep answers canonical, the model will reproduce the *content* of your answer even when the wording of the question changes.
- Mix in a small amount of generic text if you want to preserve conversational fluency outside your covered topics.

## Available variants

Pick the file that fits your deployment. All produce identical answers; smaller = faster CPU inference.

| File | Size | Use case |
|---|---|---|
| `model.safetensors` | 129 MB | fp32 reference; fine-tuning from this checkpoint |
| `bf16/model.safetensors` | 65 MB | bf16 weights for modern GPUs |
| `gguf/core-predetermined-v1-f16.gguf` | 58 MB | llama.cpp, full precision |
| `gguf/core-predetermined-v1-q8_0.gguf` | 31 MB | llama.cpp, 8-bit, near-lossless |
| `gguf/core-predetermined-v1-q4_k_m.gguf` | **20 MB** | llama.cpp, 4-bit, smaller than most game textures; runs on anything |

**GGUF usage** (llama.cpp, llama-cpp-python, LM Studio, Ollama, etc.):

```bash
llama-completion -m core-predetermined-v1-q4_k_m.gguf \
  -p "<|user|>\nwhat even is ai\n<|assistant|>\n" -n 120
```

## Model details

| | |
|---|---|
| Architecture | `COReForCausalLM` (custom CORe decoder-only transformer) |
| Parameters | 29.7M |
| Layers / heads / width | 8 / 8 / 512 |
| Context length | 512 tokens |
| Tokenizer | 8,192-token BPE, chat-formatted (`<\|user\|>`, `<\|assistant\|>`) |
| Training data | ~12.7M tokens of chat-formatted AI-education text |
| License | Apache-2.0 |

## Limitations

- This is a **30M-parameter model**. It is not a general-purpose assistant and will not compete with large models on open-ended tasks; that is not what it's for. Treat it as a flexible lookup layer over your predetermined content.
- Outside its fine-tuned coverage it will improvise, sometimes incorrectly. For production use, gate responses on confidence or restrict usage to covered topics.
- Training data was English-only; other languages are unsupported.

<sub>The architecture is registered as a first-class custom `COReForCausalLM` model (`model_type: core`) via `trust_remote_code`, no external framework code required beyond `transformers` itself.</sub>