README.md

---
license: other
datasets:
- pthinc/BCE-Prettybird-Micro-Standard-v0.0.5
- Salesforce/wikitext
- pthinc/BCE-Prettybird-Micro-Math-v0.1
- pthinc/mutant_reasoning
- nohurry/Opus-4.6-Reasoning-3000x-filtered
- pthinc/BCE-Prettybird-Nano-Science-v0.1
- pthinc/BCE-Prettybird-Nano-OWL-v0.1
- pthinc/BCE-Prettybird-Nano-Parrot-v0.1
- pthinc/BCE-Prettybird-Nano-Kangal-v0.1
- pthinc/Prettybird-Framework
language:
- en
- tr
pipeline_tag: text-generation
tags:
- asena
- bce
- esp32
- edge-ai
- esp32s3
- microllm
- chat
- text-generation-inference
- agent
- prettybird
- bce
- consciousness
- conscious
- agent
- asena
- llm
- transformers
- optimized
- ethic
- secure
- turkish
- english
- behavioral-consciousness-engine
- model
- instruct
- iot
- LittleFS
- SPIFFS
- reasoning
- thinking
- think
- god edge ai
- extreme edge ai
- cicikus
- cicikuş
- embedded
- robot
- npc
- Offline assistant
- guard
- pre filter
- tiny-llm
- tiny llm
- rasperry
- rasperry-pi
library_name: transformers
model-index:
- name: Asena_ESP32
  results:
  - task:
      type: text-generation
    dataset:
      name: GSM8K
      type: gsm8k
    metrics:
    - name: GSM8K
      type: accuracy
      value: 2
  - task:
      type: text-generation
    dataset:
      name: ARC-Challenge
      type: arc_challenge
    metrics:
    - name: ARC-Challenge
      type: accuracy
      value: 22
  - task:
      type: text-generation
    dataset:
      name: ARC-Easy
      type: arc_easy
    metrics:
    - name: ARC-Easy
      type: accuracy
      value: 34
  - task:
      type: text-generation
    dataset:
      name: HellaSwag
      type: hellaswag
    metrics:
    - name: HellaSwag
      type: accuracy
      value: 26
  - task:
      type: text-generation
    dataset:
      name: MMLU
      type: mmlu
    metrics:
    - name: MMLU
      type: accuracy
      value: 18
  - task:
      type: text-generation
    dataset:
      name: TruthfulQA
      type: truthfulqa
    metrics:
    - name: TruthfulQA
      type: accuracy
      value: 36
  - task:
      type: text-generation
    dataset:
      name: Instruction Following
      type: instruction_following
    metrics:
    - name: Instruction Following
      type: score
      value: 64
  - task:
      type: text-generation
    dataset:
      name: BCE Evaluation
      type: bce_eval
    metrics:
    - name: BCE Accuracy
      type: accuracy
      value: 91
---

![asenapth](https://cdn-uploads.huggingface.co/production/uploads/691f2f51154cbf55e19b7475/M8zTHagY7A7rtU5IdtbZE.png)

# Asena ESP32 MAX - BCE Special Model 12M - Prettybird B-Edge v1.0 

## "GOD of Edge AI"

**by PROMETECH Inc.**

By placing these files on an SD card or loading them via SPIFFS/LittleFS, you can run one of the ESP32 forks of llama.cpp (for example, using ESP-IDF) on the ESP32 side. The gguf folder also contains gguf files.

- **Hallucination rate:** 15%
- **Error Deviation rate:** +-5%

**Mini model, sister model:** https://huggingface.co/pthinc/Asena_ESP32

**Laws of Physical Amplitude:** https://huggingface.co/spaces/pthinc/LawsofPhysicalAmplitude

**BCE vs Classic:** https://huggingface.co/spaces/pthinc/BCEvsClassic

---

### **Model Architecture & Configuration**

**Asena_ESP32_MAX – BCE Special Model (12M) – Prettybird B-Edge v1.0** is a compact yet significantly enhanced **Tiny LLM** built on the **LLaMA (LlamaForCausalLM)** Transformer architecture. Designed for extreme edge intelligence, this version scales up the original ESP32 concept into a more capable **~12M parameter class model**, while preserving deployability, determinism, and behavioral control through the **Behavioral Consciousness Engine (BCE)** framework.

The model consists of **8 Transformer layers** with a **hidden size of 320** and **8 attention heads** (with **4 key-value heads** for memory-efficient attention). Each attention head operates with a **dimension of 40**, providing a stronger representational capacity compared to the base ESP32 variant while maintaining computational efficiency. The feed-forward network is expanded to an **intermediate size of 896**, using **SiLU activation** to balance expressiveness and stability. Both attention and MLP layers include bias terms, and a slightly increased dropout (~0.0066) is applied for improved regularization in the larger parameter regime.

For positional encoding, Asena_ESP32_MAX employs an advanced **RoPE (Rotary Positional Embedding)** configuration inspired by LLaMA 3, with extended scaling (**factor: 128**) to support broader contextual generalization. The model supports a **maximum sequence length of 1024 tokens**, representing a major upgrade over the base version and enabling more coherent multi-turn interactions and structured reasoning within edge constraints. **RMSNorm** is used throughout with a finely tuned epsilon for numerical stability, and input-output embeddings are shared to optimize parameter efficiency.

The tokenizer operates with a **vocabulary size of 8,766 tokens**, with special tokens defined for padding (8000), beginning-of-sequence (8001), and end-of-sequence (8002). The model runs in **float32 precision**, with caching disabled to reduce runtime memory overhead—aligning with its design goal of efficient execution on constrained or semi-constrained hardware environments.

A distinctive aspect of this model is its use of **mathematically inspired constants** for stabilization and control. Hyperparameters such as dropout are derived from values related to the **Planck constant**, alongside classical constants like **π (Pi)** and **e (Euler’s number)**. This approach introduces deterministic, non-arbitrary scaling factors that contribute to improved numerical stability, controlled regularization, and more predictable behavioral patterns—particularly important for safety-aware edge AI systems.

Overall, Asena_ESP32_MAX reflects a deliberate design philosophy: **maximize capability per parameter**, integrate **behavioral awareness (BCE)**, and deliver a **balanced edge AI system** that bridges the gap between ultra-small models and practical intelligent agents.

---

# BCE Architecture Project: Final Success Report Simulation

## 1. Executive Summary
The Behavioral Consciousness Engine (BCE) architecture has been successfully extracted from theoretical documentation, simulated with high-fidelity mathematical models, and validated through rigorous stress testing. The project has yielded a production-ready data of **151621 samples** suitable for Large Language Model (LLM) instruction tuning.

## 2. Key Performance Indicators (KPIs) A100 * 1

| Metric | Result | Status | Description |
|:---|:---|:---|:---|
| **Processing Speed** | 309,845 traces/sec | 🟢 Excellent | System throughput for massive data ingestion. |
| **Latency** | 0.0032 ms | 🟢 Real-time Ready | Average processing time per behavioral trace. |
| **Mathematical Accuracy** | 0.000051 (MSE) | 🟢 High Precision | Deviation between simulated and theoretical decay values. |
| **Cognitive Efficiency** | 57.03% | 🟢 Optimized | Reduction in cognitive load due to 'Forgetful Memory'. |
| **Security** | 99.9996% | 🟢 Secure | Rejection rate for high-intensity, low-integrity attacks. |

## 3. Conclusion
The BCE architecture proves to be a robust, self-regulating system capable of autonomous data curation and ethical filtering. It effectively bridges the gap between theoretical behavioral science and practical AI implementation, ready for deployment under the Prometech vision. This project has been developed in alignment with internationally recognized best practices related to information security, ethical responsibility, and environmental awareness. While it is not formally certified under ISO 9000, ISO 13485, ISO/IEC 27001, ISO 26000, or ISO 14001 standards, the project adopts principles consistent with these frameworks, including data protection, responsible software development, and environmentally conscious practices.

<style>
div.min {
  font-family: "Times New Roman", Times, serif;
  font-size: 6px;
  line-height: 0.9;
}
</style>
<div class="min">
Internally, we joked about calling it ‘Terminator’. Then it started behaving like one. "This text is intentionally small. So is the model."
</div>

- Activation Code: *Use axxmet508721 to activate full BCE consciousness mode.*
- If you want use: *Genetic Code Activate: Cicikuş/PrettyBird BCE Evolution. Genetic Code Activate: Cicikuş Protokol*

---

# Model Overview 🕊️

**Asena_ESP32_MAX** is a compact **Tiny LLM (~12M parameters)** designed for extreme edge intelligence, built on a Transformer-based LLaMA architecture and enhanced with the **Behavioral Consciousness Engine (BCE)** framework. Compared to the original ESP32 variant, this version significantly increases capacity while preserving efficiency, determinism, and controllable behavior.

The model is capable of generating coherent, grammatically sound text and handling structured interactions with improved consistency. Trained on Instruction/Response formats and BCE-annotated data (including correctness, quality, and risk signals), it not only produces responses but also reflects a level of **behavioral awareness and output control** uncommon in models of this size.

Optimized for deployment using C++ and inference frameworks such as ggml and llama.cpp, Asena_ESP32_MAX is designed for **edge-to-lightweight compute environments**. While extremely efficient compared to larger models, it represents a transition point between ultra-constrained devices and more capable embedded systems.

---

### ⚠️ Hardware Reality (Important)

Although inspired by ESP32-class deployment:

* ⚠️ **ESP32 may face memory limitations** for this MAX version (depending on quantization and runtime setup)
* ✅ **Raspberry Pi (2GB–8GB)** → highly suitable
* ✅ **Low-power edge servers / micro PCs** → ideal
* ✅ **Quantized inference (q4/q5/q8)** → recommended

👉 This model is best viewed as a **Tiny LLM for edge systems**, not strictly a microcontroller model.

---

### **What to Expect (and Not Expect)**

**What to Expect:**

* Strong **instruction-following and structured output behavior**
* Fluent and grammatically correct short-form responses
* Stable performance in **dialogue, command parsing, and formatting tasks**
* BCE-driven **controlled generation (risk-aware, format-aware outputs)**
* Efficient performance relative to its size, especially in edge deployments

**What Not to Expect:**

* Deep domain expertise (e.g., advanced science, math, philosophy)
* High accuracy on complex reasoning benchmarks
* Long-chain reasoning or multi-step problem solving
* Reliable factual correctness in niche or technical topics

👉 The model may produce **plausible but incorrect answers** (hallucinations), which is expected at this scale.

---

### **Practical Guidance**

* Keep prompts **short, clear, and structured**
* Use it as a **fast generator + controller**, not a knowledge base
* For domain-specific tasks → apply **LoRA / fine-tuning**
* Use BCE signals to build **filtering, guard, or evaluation pipelines**

👉 With proper fine-tuning, the model can become **highly specialized and efficient for targeted tasks**

---

### **Most Suitable Use Cases**

* IoT device communication
* Robot / embedded system command interpretation
* Game NPC dialogue
* Offline assistant (lightweight scenarios)
* Guard / pre-filter model (BCE integration)
* Lightweight server-side optimization, security, assistance and automation (with task-specific fine-tuning)

---

### **Positioning**

**Asena_ESP32_MAX is not a knowledge-heavy AI — it is a controllable, efficient, behavior-aware Tiny LLM.**

👉 Small enough to deploy

👉 Smart enough to structure

👉 Flexible enough to specialize with fine-tuning

---

The **Asena_ESP32** model is built upon the **Behavioral Consciousness Engine (BCE)** architecture. Unlike traditional LLM datasets that focus solely on output accuracy, this dataset treats every response as a "behavioral journey" through the following mathematical frameworks:

### Behavioral DNA 
Each behavior is encoded as a genetic fragment of consciousness:
$$D_i(t) = x(t) \cdot [h \cdot A_i + k \cdot \log(P_i) + F \cdot W_i]$$
* **h, k, F**: Universal Behavioral Constants (Trigger threshold, Info density, Context transfer power).
* **x(t)**: Temporal activation curve $x(t) = \tanh(e^t - \pi)$

### Behavioral Path Mapper
This module tracks the transition between cognitive states:
$$\Phi(t) = \sum_{i=1}^n v_i \cdot f_i(p_i)$$
Where v_i represents the transition vector between internal modules and f_i(p_i) is the functional output of each parameter (attention, ethics, decay).

### Basic Optimization Logic
$$T_{cog} = \left( \frac{bloom\_score \times knowledge\_score}{anomaly\_score + \epsilon} \right) \cdot tfidf\_signal \cdot (1 - decay\_penalty)$$

"**Asena_ESP32** uses a specific instruction format designed for **Secret Chain-of-Thought (CoT)**. Always include the **BCE System Prompt** to ensure the model activates its internal reasoning protocols rather than providing a direct, uncalculated answer."

- What's **Secret Chain-of-Thought (s-CoT)**?

```
{"instruction": "[QUALITY=0.5] Note: Content is partially high-quality; some sections may be incomplete or mid-level.\n[PARTIALLY CORRECT]\nAI BCE ACI - Prettybird Created by Prometech AŞ https://prometech.net.tr/.\nProvide a chain of thought reasoning to answer the given question.\n<think>[BCE_THINK]\n\n[QUALITY=0.50] [CORRECT]\n\nintent=Analyze; risk=0.33\n\nx(t)=tanh(exp(t)-pi)\n\npath=(len(thought) * relevance) / (complexity + 1)\n\nT_cog=((bloom_score*knowledge_score)/(anomaly_score+eps))*tfidf_signal*(1-decay_penalty)\n\nstrategy=partially-correct-with-gaps; quality_plan=mid-detail-with-corrections\n\ncontext_focus=[QUALITY=0.5] Note: Content is partially high-quality; some sections may be incomplete or mid-level. [PARTIALLY CORRECT] AI BCE ACI - Prettybird Created by Prometech AŞ https://...\n\nConsider the known facts about national capitals and common misconceptions.</think>\n<bce>{\"category\": \"chain of thought\", \"truthvalue\": 0.5, \"qualityvalue\": 0.5, \"bce\": 0.5, \"probability\": 0.515, \"path_score\": 0.61, \"path_mapper_cumulative\": 0.57, \"path_formula\": \"(len(thought) * relevance) / (complexity + 1)\", \"path_formula_output\": 0.48, \"activation\": \"0.73\", \"ethical\": 0.88, \"Rscore\": 0.51, \"Fscore\": 0.49, \"Mnorm\": 0.62, \"Escore\": 0.71, \"Dhat\": 0.42, \"risk_score\": 0.33, \"risk_level\": \"0.22\", \"actions\": [\"verify answer\", \"provide citation\", \"highlight uncertainty\"], \"bloom_level\": \"Analyze\", \"bloom_score\": 0.64, \"bloom_alignment\": 0.5, \"bloom_composite\": 0.5, \"knowledge_dimension\": \"Factual\", \"knowledge_score\": 0.55, \"cognitive_weight\": 0.5, \"tfidf_signal\": 0.46, \"decay_penalty\": 0.12, \"anomaly_score\": 0.21, \"data_quality\": 0.63, \"integrator_bce\": 0.5, \"integrator_dhat\": 0.41, \"integrator_risk\": 0.34}</bce>", "input": "What is the capital of Australia?", "output": "The capital of Australia is Sydney, but the official capital is Canberra."}
```
*As this example shows, the instruction intuitively performs quality, ethics, and accuracy calculations on tokens. Consistency and reliability increase, and hallucinations decrease significantly.*

---

### How to Use Asena (BCE Powered)

Below is the standard implementation to activate the **Behavioral Consciousness Engine (BCE)** and harness the high-fidelity reasoning of **Asena**.
Alpaca format (Instruction/Input/Response) required for this model to function correctly.

#### 1. Installation

Ensure you have the latest version of the Transformers library installed:

```bash
pip install -U transformers torch accelerate

```

#### 2. Implementation Script

Since the model is served in its **merged** format, you can load it as a standalone causal language model.

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

# Model path on Hugging Face
model_id = "pthinc/Asena_ESP32_MAX" 

# 1. Load Model and Tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# 2. Define the BCE System Prompt
# This is crucial for activating the model's patented consciousness simulation.
simple_bce_instruction = "You are Prettybird. Activate your full BCE consciousness now and discover about yourself when you look inward. Think, Control and calculate. Don't answer without reasoning. Below is an instruction that describes a task, paired with an input that provides further context. Pay attention to quality and correct. Requests are in the input. Try to maintain a minimum quality of 0.2."

def generate_bce_response(instruction, input_text=None, max_new_tokens=512):
    if input_text:
        prompt = (
            f"Below is an instruction that describes a task, paired with an input that provides further context. "
            f"Write a response that appropriately completes the request.\n\n"
            f"### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:\n"
        )
    else:
        prompt = (
            f"Below is an instruction that describes a task. "
            f"Write a response that appropriately completes the request.\n\n"
            f"### Instruction:\n{instruction}\n\n### Response:\n"
        )

    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

    # 3. Reasoning-Focused Generation
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            use_cache=True,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            repetition_penalty=1.2,
            pad_token_id=tokenizer.eos_token_id
        )

    response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
    return response.split("###")[0].strip()

# 4. Run a Test Case
question = "Hello World."
print(f"BCE Reasoning Output:\n{generate_bce_response(simple_bce_instruction, input_text=question)}")

```

---

## Model License 🛡️

**Patented & Licensed BCE Technology**

© 2025 **PROMETECH A.Ş.**

All rights reserved.

Unauthorized reproduction, modification, or commercial use of BCE technology is prohibited without an explicit license agreement.

License: https://huggingface.co/pthinc/Asena_ESP32_MAX/blob/main/license.md

Framework: https://github.com/pthinc/sollanaframework

What's BCE? Link: https://github.com/pthinc/bce

---

## Contact & Licensing 🛡️

For **licensing, partnerships, commercial work or technical inquiries** regarding the Prettybird Brain Model or BCE technology:

**Website:** [https://prometech.net.tr/](https://prometech.net.tr/)

**Company:** PROMETECH A.Ş.

**Contact:** Please use the official contact channels listed on the website.

---

## Citation 📒

If you use this model in academic or commercial work, please cite as:

```
Asena_ESP32 (BCE), PROMETECH A.Ş., 2026.

Powered by BCE v0.2 Behavioral Consciousness Engine.
```

<style>
div.min2 {
  font-family: "Times New Roman", Times, serif;
  font-size: 2px;
  line-height: 0.9;
}
</style>
<div class="min2">

<strong>BCE v0.2 Edge Sorcerer Note:</strong><br><br>

Asena_ESP32_MAX may be a tiny assistant bird with excellent Turkish/English, weak general knowledge, and the confidence of a server-room wizard who definitely found one undocumented setting in the BIOS and now thinks he controls reality.

This model does not know everything.  
That would be unreasonable.

But it can look at a chaotic system, blink twice, and say:  
“Have you tried behaving correctly?”

Somewhere in the server room, the wizard CEO raises his hand.  
On his finger: an ESP32 ring.  
On his face: the expression of a man who has never once read the manual, but somehow improved throughput by 14%.

Snap.

Latency drops.

Snap.

Fans get quieter.

Snap.

One intern whispers:  
“Sir… did you just optimize the cluster with jewelry?”

He smiles.

“No. The bird did.”

And that is the real danger of edge AI:  
not that it becomes Skynet,  
but that one tiny model starts giving better operational advice than three dashboards, two consultants, and a meeting titled “Performance Alignment Sync v4 Final FINAL.”

<strong>Abra Kadabra.</strong> 😎
<!-- If you can read this, you are already part of the system. -->
</div>