Jershone/FluidAI-0.7B_Gen1

🌊 FluidAI-0.7B: The Fluidic Wave Architecture

Welcome to FluidAI-0.7B, a 700 million parameter multimodal foundation model built completely from scratch using the Fluidic Wave Architecture.

Unlike conventional multimodal systems that rely on separate language and vision encoders connected through additional fusion modules, FluidAI processes both text and visual information within a unified neural sequence. Images are converted into structured visual tokens that flow through the same architecture as text, allowing a single model to learn language and spatial reasoning together.

This repository documents the first public release of the FluidAI project. The model was trained over a continuous 60-hour pre-training run on a single NVIDIA T4 GPU, processing approximately 138 million training tokens.

FluidAI was independently designed, engineered, and trained by Jershone Terin.

---

🌊 The Fluidic Wave Architecture

The Fluidic Wave Architecture explores an alternative approach to multimodal intelligence by representing language and vision within one continuous neural sequence.

Instead of maintaining separate neural networks for text and images, FluidAI converts visual inputs into structured token sequences that are processed alongside text using the same neural architecture.

Key Features

• 🌊 Unified Text & Vision Processing — Text and image tokens share the same sequence and neural architecture.
• 🧠 Native Spatial Understanding — Images are represented as structured visual grids, enabling the model to learn spatial relationships directly.
• 🎨 Bidirectional Multimodal Generation — The architecture is capable of both interpreting images and generating visual outputs from its learned internal representations without relying on a separate diffusion model. But remember image gen is not the best.
• ⚡ Research-Oriented Design — Built as a foundation architecture for experimentation, fine-tuning, and future multimodal research.

---

🧩 Tokenizer & Vocabulary

FluidAI uses the classic GPT-2 Byte-Pair Encoding (BPE) tokenizer as its text tokenizer while extending the vocabulary for multimodal processing and conversational formatting.

Tokenizer Specifications

Property	Value
Base Tokenizer	GPT-2 BPE
Base Vocabulary	50,257
Added Tokens	3
Final Vocabulary	50,260

Additional Tokens

Token	Purpose
<|im_start|>	Beginning of a conversational or multimodal block
<|im_end|>	End of a conversational or multimodal block
<|patch|>	Represents a flattened visual grid patch within the unified sequence

Important

When loading the raw model weights, you must register these three additional tokens before inference or fine-tuning so that the tokenizer vocabulary matches the model's embedding matrix.

---

🚀 Quick Start

import torch
import torch.nn.functional as F
from transformers import AutoTokenizer

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")

tokenizer.add_special_tokens({
    "additional_special_tokens": [
        "<|im_start|>",
        "<|im_end|>",
        "<|patch|>"
    ]
})

tokenizer.pad_token = tokenizer.eos_token

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Instantiate your FluidAI architecture
model = HoloResProTitanX(
    vocab_size=len(tokenizer)
).to(device)

# Load pretrained weights
model.load_state_dict(
    torch.load(
        "FluidAI_0.7B_Base.pt",
        map_location=device
    )
)

model.eval()

torch.manual_seed(42)

prompt = "Explain why the sky appears blue."

formatted_prompt = (
    "<|im_start|>user\n"
    + prompt +
    "<|im_end|>\n"
    "<|im_start|>assistant\n"
)

generated = tokenizer(
    formatted_prompt,
    return_tensors="pt"
).input_ids.to(device)

temperature = 0.2

with torch.no_grad():
    for _ in range(128):

        outputs = model(generated)

        if isinstance(outputs, tuple):
            outputs = outputs[0]

        logits = outputs[:, -1] / temperature

        probs = F.softmax(logits, dim=-1)

        next_token = torch.multinomial(
            probs,
            num_samples=1
        )

        generated = torch.cat(
            [generated, next_token],
            dim=1
        )

        if next_token.item() in (
            tokenizer.eos_token_id,
            tokenizer.convert_tokens_to_ids("<|im_end|>")
        ):
            break

print(
    tokenizer.decode(
        generated[0],
        skip_special_tokens=False
    )
)

---

📊 Model Specifications

Property	Value
Model Name	FluidAI-0.7B
Parameters	700 Million
Architecture	Fluidic Wave Architecture
Initialization	Random (trained completely from scratch)
Tokenizer	GPT-2 BPE + 3 custom tokens
Vocabulary Size	50,260
Modalities	Text + Images
Training Tokens	~138 Million
Developer	Jershone Terin
License	Apache 2.0

---

🚀 Training Summary

Metric	Value
Hardware	Single NVIDIA T4 GPU
Training Time	~60 Hours
Total Training Tokens	~138 Million
Inner Training Steps	~540,000
Precision	Mixed Precision (FP16 / AMP)
Initialization	Random

---

🎯 Intended Use

FluidAI-0.7B-Base is a foundation model intended for:

• Language modeling
• Multimodal research
• Fine-tuning
• Instruction tuning
• Image understanding
• Image generation research
• Custom downstream applications
• Local inference on consumer hardware

This release is the base model and has not undergone instruction tuning, reinforcement learning, or preference optimization.

---

📈 Evaluation Status

This is the initial public release of the base model.

Formal benchmark evaluations are not yet available.

Future evaluations may include:

• HellaSwag
• ARC
• GSM8K
• HumanEval
• MMLU
• Multimodal reasoning benchmarks
• Image generation quality benchmarks

---

📂 Repository Contents

FluidAI_0.7B_Base.pt
README.md
LICENSE
config.json
tokenizer_config.json

---

📦 Model Variants

FluidAI-0.7B-Base

The pretrained foundation model containing the learned language, reasoning, coding, and multimodal representations acquired during pre-training.

Recommended for:

• Research
• Fine-tuning
• Architecture exploration
• Downstream adaptation

---

FluidAI-0.7B-Instruct (Coming Soon)

An instruction-tuned version optimized for:

• Chat
• Coding assistance
• Structured reasoning
• Question answering
• Reduced repetition

---

🛣️ Roadmap

Planned future work includes:

• Instruction tuning (SFT)
• Preference optimization
• Larger FluidAI models
• Longer context lengths
• Expanded multimodal capabilities
• Comprehensive benchmark evaluations
• Research publication describing the Fluidic Wave Architecture

---

🤝 Contributing

Community feedback, bug reports, feature requests, and research collaborations are welcome.

If you build upon FluidAI in your own work, please consider citing the project.

@software{fluidai2026,
  author = {Terin, Jershone},
  title = {FluidAI-0.7B: The Fluidic Wave Architecture},
  year = {2026},
  url = {https://huggingface.co/Jershone/FluidAI-0.7B-Base}
}

---

📜 License

FluidAI is released under the Apache License 2.0.

You are free to use, modify, distribute, and commercially deploy both the model weights and source code under the terms of the Apache 2.0 License.

---

🙏 Acknowledgements

FluidAI was independently designed, implemented, and trained by Jershone Terin.

All model weights were randomly initialized and trained from scratch. The model uses a GPT-2 Byte-Pair Encoding tokenizer with three additional multimodal tokens while introducing the novel Fluidic Wave Architecture for unified language and vision processing.

This repository represents the first public release of the FluidAI project. Future releases will expand the architecture, improve multimodal capabilities, and provide comprehensive benchmark evaluations.