All Blog Posts

Today I did two main things: gave zanbot long-term memory, and replaced the input() loop with a proper interactive terminal. I also fixed two small issues along the way. Below is a record in the order things happened, with the focus on the problems I ran into.

I worked through Lecture 5 on Sequence Modeling from the beginning. The CNN section has plenty of diagrams that seem clear at a glance, but when I ask myself what the second diagram actually shows or what a filter is, I struggle to explain.

This review focuses on understanding the slide diagrams and matching each symbol to its role in the formulas. The notes follow the order of the questions I asked. The numerical examples are for illustration: Section 5 uses the cs231n example cited in the slides; the others are not experimental results.

Lecture 6 has a long title: Contextual Embeddings, Model Architectures, and Decoding. It really covers three threads: how to give a word a representation that changes with its context, how an encoder-decoder turns one sequence into another, and how to pick a word at each step during generation.

While reviewing, I asked a lot of "what is this figure actually showing" questions, and got a few things wrong along the way. This post follows the order of my questions, mistakes included. All numeric examples are made up to aid understanding; none of them are experimental results.

Reviewing Lesson 4 on Language Models & Word Embeddings, I found that some concepts seem familiar at first glance, but when asked questions like "what is one dimension of this matrix" or "what probability does this actually predict", I still get stuck.

This post organizes problems I encountered during review: first understanding concepts in my own words, then matching them with small examples and formulas to see if I've confused two things together. The numerical examples in this article are meant to help explain concepts, not experimental results.

Last time I learned about RNN's BPTT and understood that gradients multiply continuously as they backpropagate through time, calculating $0.2^5=0.00032$. But when I encountered gradient clipping, I realized I hadn't truly understood: what's the actual problem with gradient explosion, and why do we need to clip?

Starting from this question, I gradually understand the gating mechanisms of LSTM and GRU, and finally connect the division of labor between BPTT and the Optimizer. The most rewarding insight is clarifying several easily confused concepts: memory and output, gate values and parameters, multiplication along paths and addition across multiple paths.

Last time I learned about Linear Regression, Gradient Descent, and SGD. This time continuing further: if instead of predicting house prices, the model predicts three categories—positive, negative, and neutral—how does the model output? After adding a hidden layer, how does the loss affect the parameters before it?

The most rewarding part today was breaking down the formulas into steps I could actually compute, especially the gradient of cross-entropy, the transpose in backpropagation, and the difference between "computing gradients to the hidden layer" and "updating parameters." This note is organized following the order of our actual questions and calculations, with the complete formulas together later.

Last time I manually worked through the forward and backward propagation of Softmax, Cross-entropy, and a ReLU MLP. This time continuing the question: if the input is a sentence, how does text become numbers? When sentence lengths differ and word order varies, how does the model handle it?

The main thread I worked through today is: token → embedding → RNN hidden state → prediction of next word → loss → backpropagation through time. The places most worth stopping to carefully work through are: the transpose in the embedding gradient, and why the gradient in RNN may become smaller the farther it propagates.

Starting from the second lecture of CS546, I felt like I was falling behind. Many concepts I heard about in undergrad, but never actually used. Once the slides switched to formulas, I started getting dizzy.

So this time I decided to pause and work through the training process with actual numbers. This record documents my journey from "does this really mean updating parameters?" to being able to distinguish between batch, step, epoch, and SGD. I haven't yet entered the world of multi-layer neural networks.

This article takes the survey paper A Survey on Evaluation of LLM-based Agents from ACL 2026 Findings as the main thread, systematically reviews Agent Evaluation's capability assessment, application-oriented benchmarks, general-purpose agents, evaluation frameworks and gym-like environments, and focuses on explaining the testing mechanisms of Conversational Agents, reference-based and reference-free trajectory assessment, human-in-the-loop approaches, as well as decoupled evaluation of backbone LLM and agent harness. The article further proceeds from engineering practice to discuss how vertical domain Research Agents should combine deterministic checks, LLM Judge, expert annotation and existing Eval platforms, and how enterprises can establish a continuous evaluation loop through Golden Set, Regression Set, CI Gate, and online monitoring.

LlamaIndex often appears alongside LangChain, LangGraph, and smolagents in Agent tutorials, but its truly distinctive part is not Agent or Multi-Agent, but rather a complete set of RAG abstractions built around private data: Document, Node, IngestionPipeline, VectorStoreIndex, Retriever, QueryEngine, and ResponseSynthesizer. Starting from a persona dataset, this article fully deconstructs the pipeline of data loading, chunking, embedding, vector storage, retrieval, response synthesis, and evaluation. It further explains why QueryEngine needs to be wrapped as a Tool, when Agent layer constitutes over-engineering, and how Workflow connects multiple Steps through Event types. Finally, it provides positioning comparisons between LlamaIndex, LangGraph, and smolagents, as well as typical issues encountered when running Notebooks locally.

After continuing to read the design article of Pi Coding Agent, I discovered that what the author repeatedly emphasized was not just "fewer features," but rather avoiding hidden state in the harness as much as possible. Pi retains a minimal agent loop, event stream, and tool protocol, while delegating capabilities like todos, plans, MCP, background processes, and sub-agents to ordinary files, CLI, tmux, and independent sessions. This article follows questions I raised while reading, to clarify the benefits and costs of this design approach, as well as its implications for building custom Agents and evals.

Pi implements layered architecture for model protocols, Agent orchestration, terminal interface, and CLI applications through pi-ai, pi-agent-core, pi-tui, and pi-coding-agent. For multi-provider support, Pi uses compatible configurations to unify OpenAI-compatible API fields, reasoning, and usage differences; token counting relies on data actually returned by the provider, so only best effort can be achieved. When switching across providers, Pi preserves or downgrade-converts contexts like reasoning, but cannot guarantee lossless migration of private signatures and ultra-long contexts. Additionally, Pi supports end-to-end cancellation of streaming requests and distinguishes between model-visible content and UI-specific data through structured tool results, thereby maintaining the Agent core's transparency, simplicity, and extensibility.

While studying Hugging Face Agents Course Unit 2.1, I thought I understood Tools and RAG, but only discovered several misunderstandings after examining the source code and notebook. This note documents four key issues from the @tool decorator to BM25 sparse retrieval.

Uploading images to Cloudflare via PicGo in Typora encountered obstacles. This article successfully uploads images and outputs them correctly locally by properly concatenating URLs.

Set up a quick alias c-d for Claude Code in Windows PowerShell and start with --dangerously-skip-permissions by default to reduce repetitive input and permission confirmations.