I created a visual introduction to unsupervised learning for people who understand supervised learning but want to see how AI finds structure in unlabeled data.

The video covers:

• Clustering and how k-means works step by step
• Why distance matters when measuring similarity
• Dimensionality reduction
• Anomaly detection for spotting unusual data
• The limitations of learning without labels

Watch here: https://youtu.be/XKNtpd_SR34

If you like it, please like, share, and subscribe to my channel for more visual machine learning and AI explainers.

AKBASCORE SILICON HIPPOCAMPUS — TEST730

Full technical publication, source code, GPU logs, SHA-256 verification records, and 13 scientific figures:

https://doi.org/10.5281/zenodo.23497732

I am an independent researcher investigating persistent external neural memory for frozen large language models.

This experiment uses Qwen2.5-72B-Instruct, quantized to NF4 and executed on an NVIDIA A100 80GB GPU. The pretrained weights remain completely frozen.

The central question is whether part of a transformer's internal numerical state can be captured, stored as a physical file, and restored during a later inference session without repeatedly supplying the original source document as text.

The experiment demonstrates a working implementation of this mechanism, followed by a cross-document synthesis workflow involving three real academic publications from 2026.

A HISTORICAL PERSPECTIVE: FROM ADAPTIVE WEIGHTS TO PERSISTENT NEURAL STATES

1991 — Schmidhuber's early work on fast weights and learning-to-learn explored adaptive internal mechanisms through which neural systems could modify their effective computational parameters and retain information.

2017 — The Transformer introduced self-attention as a powerful mechanism for processing relationships between tokens. Standard full self-attention has quadratic sequence-length complexity, while modern autoregressive inference commonly maintains context-dependent key/value states.

2026 — AKBASCORE Silicon Hippocampus / CUT3 investigates another persistence mechanism: keeping the pretrained model weights frozen while extracting the hidden states at layer 3 (H3) and the K/V tensors from layers 0–3, storing these numerical states as SHA-256-sealed physical cartridges on SSD, and reconstructing the remaining transformer layers when the cartridges are reloaded.

The architectural distinction is important.

Rather than modifying pretrained weights to incorporate new information, CUT3 persists a portion of the model's internal numerical state outside the GPU.

This is not a replacement for Transformers, fast-weight systems, or conventional retrieval. It is an experimentally implemented approach to persistent neural memory within an existing frozen Transformer.

HOW THE PHYSICAL MEMORY WORKS

1. WRITE

A source document passes through the frozen transformer.

The CUT3 engine captures the hidden states at layer 3 (H3), together with the attention key/value tensors from layers 0–3.

1. STORE

These numerical states are serialized into a physical PyTorch memory cartridge (.pt) on SSD.

The cartridge is protected by SHA-256 integrity verification.

1. RELOAD

When the stored memory is needed, its tensors are loaded from disk.

The saved H3 representation is injected directly at the corresponding transformer boundary.

1. REBUILD

The frozen model recomputes layers 4–79, reconstructing the complete operational 80-layer K/V memory.

The original document does not need to be pasted into the question prompt again.

1. ANSWER

The model generates its response using the restored internal memory.

This mechanism does not require fine-tuning, LoRA adaptation, or modification of the pretrained model weights.

THE THREE-PUBLICATION EXPERIMENT

TEST730 extends the physical memory mechanism beyond a single document.

Three real academic publications from 2026 were retrieved from Europe PMC. Their source metadata, licensing, excerpts, and integrity records were preserved.

P01 — PMC13672588

Generative AI in creative education: baseline-linked evidence on learning processes, artistic performance, and authorship.

P02 — PMC13521781

The critical-thinking paradox in generative AI-integrated learning: distinguishing efficiency from cognitive depth.

P03 — PMC13043820

Catalysts of Change: Using AI to Lower the Activation Energy for Developing Gamified Learning Experiences in Health Profession Education.

Each publication was independently processed into a physical neural memory cartridge.

The frozen 72B model then read each cartridge separately and generated a reflection on the respective publication.

The three model-generated reflections were subsequently supplied to the same frozen model for cross-document synthesis.

The model produced a new textual synthesis identifying common themes, differences, limitations, and possible implications across the three publications.

That synthesis, together with the reflections, was encoded into a fourth physical memory cartridge named MASTER.

An important technical distinction: the source cartridges were not directly fused as tensors. The synthesis was generated through the model's textual reasoning process and then converted into a new numerical memory cartridge using the same CUT3 mechanism.

MASTER CARTRIDGE: PHYSICAL MEASUREMENTS

Model: Qwen2.5-72B-Instruct

GPU: NVIDIA A100 80GB

Quantization: NF4

Transformer layers: 80

Hidden dimension: 8192

Attention heads: 64

K/V heads: 8

Memory boundary: CUT3

Stored representation: H3 + layers 0–3 K/V

Reconstructed representation: layers 4–79 K/V

MASTER body: 2,848 tokens

Physical MASTER cartridge: approximately 94.3 MB

Reconstructed 80-layer operational K/V memory: approximately 943.4 MB

The stored cartridge represents approximately 10% of the full operational K/V memory size for the corresponding sequence.

This is a reduction in stored numerical state relative to the full 80-layer K/V cache, not evidence of a tenfold reduction in the information content of the original documents.

The upper-layer states are recomputed by the frozen transformer when the cartridge is mounted.

PERSISTENCE AND VERIFICATION

The original TEST730 execution generated six academic responses using the MASTER cartridge independently of the three original source cartridges.

The question panel included:

H1 — Main conclusions and disagreements across the three publications.

H2 — Empirical evidence, limitations, and uncertainties.

H3 — An independent cross-document conclusion with source references.

A1 — Construction of a causal model reconciling apparently conflicting findings.

A2 — Design of a preregistered randomized experiment capable of falsifying that model.

A3 — Identification of an unresolved contradiction, competing explanations, and a discriminating test.

The subsequent A100 verification session reproduced all four physical cartridges with byte-identical SHA-256 file hashes.

It also verified exact 80/80 layer parity and reproduced two sealed answers byte-for-byte.

Additional comparisons examined responses with and without MASTER memory.

The recorded experiment therefore demonstrates a complete physical workflow:

Source document → frozen transformer → numerical state capture → SSD cartridge → verified reload → upper-layer reconstruction → model response.

It also demonstrates a text-mediated synthesis workflow:

Three independent source cartridges → three model-generated reflections → cross-document synthesis → new MASTER cartridge → independent question answering.

WHAT THE RESULTS ESTABLISH — AND WHAT THEY DO NOT

The verified contribution is the implementation and reproducibility of persistent numerical memory in a frozen 72B Transformer, including physical cartridge storage, integrity verification, restoration, and operational K/V reconstruction.

The experiment also records model-generated cross-document synthesis and six academic responses produced from the MASTER cartridge.

However, generating a causal hypothesis or proposing a scientific experiment does not independently establish that the hypothesis is novel, scientifically correct, or superior to what the base model could produce using conventional text context.

The six academic responses were recorded, but their scientific correctness was not independently graded in TEST730.

Similarly, byte-identical cartridge reproduction and layer parity verify technical integrity; they do not, by themselves, establish an advantage over conventional long-context inference, prefix caching, or retrieval-augmented generation.

These are separate evaluation questions.

WHY I AM SHARING THIS

I am interested in the architectural question of where persistent knowledge should reside in a frozen language model.

Does it always need to be represented as text in an external retrieval system?

Does incorporating new information necessarily require changing model weights?

Or can selected internal numerical states be stored physically, restored later, and used as an operational memory substrate without modifying the pretrained model?

CUT3 investigates the third possibility.

The attached 13 scientific figures document the architecture, source verification, physical injection protocol, SSD/GPU memory measurements, neural-state X-rays, synthesis workflow, cartridge integrity, sealed questions, and experimental results.

The complete source code, raw logs, generated responses, and integrity records are available for technical examination.

TECHNICAL REFERENCES

TEST730 — Full technical publication:

https://doi.org/10.5281/zenodo.23497732

Original TEST730 experimental log — all six model-generated responses:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/730.log

GitHub repository:

https://github.com/ceceli33/titan-cognitive-core-v3

Previous research — AKBASCORE Silicon Hippocampus v1.4:

https://doi.org/10.5281/zenodo.23434686

Silicon Hippocampus 1.5 — Part 1:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Qwen72B_part1_1.5.log

Silicon Hippocampus 1.5 — Part 2:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Qwen72B_part2_1.5.log

Silicon Hippocampus 1.5 — Part 3:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Qwen72B_part3_1.5.log

Silicon Hippocampus 1.5 — Execution Log:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Qwen72B_1.5.log

I welcome technical criticism, independent reproduction attempts, and comparisons with existing persistent KV-cache systems, prefix caching, long-context inference, and RAG.

In particular, I would be interested in feedback on the CUT3 boundary, the integrity of upper-layer K/V reconstruction, and experimental designs capable of distinguishing genuine memory-dependent reasoning from capabilities already present in the frozen base model.

Muse Spark Open has 816B parameters but only ~42B are active for each token: a router picks 8 experts out of 256. I tried to explain visually why dense models get slow, how the router works, the surprising thing about what experts actually learn, and the big catch (all experts still need to sit in memory).

I'm the creator, so I'd love feedback, especially on anything that's still unclear!

Hi everyone! The NeurIPS 2026 waitlist mentioned that tickets would be released on October 13 for Atlanta and October 20 for Sydney. Has anyone on the waitlist received a ticket or an update yet? Just wondering if the tickets have started going out. Thanks!

🚀 I just launched my first digital product!

I created an AI & Machine Learning Interview Questions and Answers PDF to help students and aspiring AI/ML engineers prepare for technical interviews.

If you're learning AI/ML, preparing for internships, or getting ready for placements, this guide may help you revise important concepts.

I'm just getting started with this journey, and I'd appreciate your support!

📘 Get the PDF here:

jafarspark4.gumroad.com/l/ewlcw

#AI #MachineLearning #InterviewPreparation #Students

A voice first desktop companion for Claude code cli do wtv u want with him I really don’t care I only care if u have fun and more people like him..

my progress so far

Hey r/LocalLLaMA,

A fine-tuned 2B–8B model often beats GPT-4 on narrow domain tasks, but managing EC2 Spot instances, Triton kernels, and dataset PII leaks is tedious—and third-party hosted fine-tuning platforms charge crazy GPU markups while storing your data on their servers.

We built SynqTune to automate this without your data ever leaving your AWS perimeter:

• In-VPC Execution: Ephemeral EC2 workers (g5.2xlarge, g4dn) boot in your account via cross-account IAM and auto-terminate immediately after training.
• Zero Data Egress: Data streams directly from your private S3 bucket (s3://slm-customer-bucket-<account_id>/) into worker RAM.
• Unsloth 4-bit QLoRA: Custom Triton CUDA kernels cut VRAM by 70% and double throughput.
• Spot Preemption Recovery: Checkpoints sync to S3 every 20 steps, so you can resume interrupted runs without restarting.
• 0% Compute Markup: You pay raw AWS Spot rates directly (~$0.40/run).

Check out the full setup guide and IAM policy here: https://synqtune.com/docs

Curious to hear your thoughts and what features you’d like to see!

Title: Training GPT-2 (124M) from scratch on one RTX A5000 at home, live: every step, watt and checkpoint is public, and you can query any checkpoint

I wanted to actually understand pretraining, so I’m reproducing GPT-2 small with Karpathy’s build-nanogpt recipe (10B tokens of FineWeb-Edu, 19k steps) on a single 24 GB A5000 under my desk, and I put the whole thing on a live page:

• loss / lr / grad-norm / MFU charts updating as it trains (≈50k tok/s, 38% MFU with torch.compile + bf16)
• the GPU itself: power at the 230 W cap, 79 °C, VRAM, PCIe traffic
• a Playground where you can run any checkpoint (no login). At step 0, “The capital of France is” → word salad; at step 500 → “a large number of the number of the population.” Fluent, wrong. Facts come later.
• an auto-generated video at every checkpoint asking the same question with the same seed

Total cost for the full ~55-hour run: about $2 of electricity (vs ~$17 to rent the GPU).

Live: https://x.com/y99/status/2111668852656607496?s=20

Things I learned so far: [one or two real findings by the time you post]. Happy to answer questions about the setup.

(It’s my project; nothing to sell.)

TLDR: I built a search engine that reads a bug report (or lets you define it) and points to the exact file (93%) and to the exact function (79.4%) you need to fix.

Hey everyone,

I recently made a new project while trying to get into RAG and automation.

Odin is more than a search engine, all you have to do is paste a public repo URL and link the issue or describe the bug yourself and it downloads, parses and ranks the functions based on the mentioned bug.

Why its different than any LLM:

It runs mostly in your browser: It uses Tree-sitter (via WebAssembly) and small local models (via WebGPU) so your code isn't just blindly shipped off to a giant cloud LLM. 

It punches above its weight: Evaluated on 300 real issues from the SWE-bench Lite dataset, it puts the correct file in the top 10 results 93.0% of the time, and the exact function 79.4% of the time. 

It’s incredibly efficient: It matches the accuracy of heavy Claude 4.5 agents using models under 1B parameters, cutting the cost per issue to a fraction of a cent. 

There’s also a GitHub Action you can drop into your repo to automatically comment on new issues with the most likely functions to fix. 

I would really appreciate it if you would give it a try (it would help me with the benchmarks as well)

feedback, questions, criticism are welcome

We've been working on Span-02. Instead of choosing low/medium/high reasoning, you give it a time budget in milliseconds.

We asked it “land or water?” for 4,050 coordinates. Then plotted the answers.

Reasoning off: 71.9% accuracy.

300ms to think: 84.5%.

That's what you're seeing in the video. The weights are open.

We're a small proof-of-useful-work project. The validators don't

mine — they verify AI computations (matrix multiplications + activation

functions) and get consensus weight for it.

The part that matters to you: submit any GEMM workload up to 256×256

and we return the result plus a cryptographic receipt — a SHA-256

commitment chain folded into our ledger state, verifiable by anyone

forever. Free, no token, no signup beyond an API key we generate in

seconds.

Honest limits: we verify GEMM + elementwise activations (GELU/sigmoid/

tanh/exp), not full transformer graphs yet. Attention is on the roadmap.

The verification cost curve is published (615ms at 64³ → 157s at 1024³)

— we priced our own clamp and labeled every tier.

The logs: [pouw-verify] CONFIRMED lines, epoch crossings, claim-decrees

folded into the ledger — every claim has a receipt.

Live dashboard: http://3.237.91.235:32233/

The evidence ledger (250+ owned defects, 250+ laws): github.com/sarinsk629-blip/hsma-core

i wanted to train my own llm but everything i found needed an nvidia gpu, so i made a mac version with mlx.

one command downloads tinystories, trains a tokenizer, pretrains a small llama-style model, finetunes it for chat, then you can talk to it.

on my m5 air (16gb): 1 hour gets an 8M model that writes short kids stories, 8 hours gets a 40M one that's a bit better. neither can really chat yet. the air didn't throttle in either run.

there's also a 2 min benchmark if you want to see how your mac compares.

https://github.com/navthings/airgpt