Deep Dive into MYLLM: One Developer's Journey Through the Full LLM Tech Stack with a 0.5B Model

In the midst of today's heated large model arms race, the idea that one person, with a single consumer-grade GPU and a 0.5B parameter model, can walk through the entire LLM tech stack from training to Agent—that alone deserves more attention than any big-company product launch. The GitHub project we're looking at today is called MYLLM, a personal portfolio by developer Ding Lizhong that covers the reproduction and optimization of nearly every mainstream algorithm in the LLM and VLM space.

What Is This Project Actually Doing?

MYLLM is hosted on GitHub at dinglizhong/MYLLM. In short, it's a collection of algorithm reproductions and optimizations for Large Language Models (LLM) and Vision Language Models (VLM), primarily developed in Jupyter Notebooks. It currently has 10 Stars and 1 Fork.

10 Stars and 1 Fork—by GitHub's traffic logic, this project could easily be dismissed as "dead on arrival." But it's precisely projects like this that expose an awkward structural problem in the AI open-source community: there are far too few people actually implementing algorithms from scratch, and far too many people resharing papers or wrapping APIs.

Ding Lizhong chose to present his work in Jupyter Notebooks rather than a polished Python library, which signals that this isn't a project chasing Stars—it's a genuine "workbook." This choice feels out of place in an open-source culture dominated by performative metrics, but for personal technical growth, it may be the most honest path.

Of course, there are downsides: Jupyter Notebooks inherently lack engineering structure, and code reusability is poor. If the project ever needs to evolve from a "portfolio" into a "usable tool," the accumulated technical debt will be significant.

Full-Stack LLM Coverage: From Training to Agent, Nothing Left Out

The technical directions covered by this project read like a complete table of contents for the 2023-2024 large model tech stack:

• Training: Foundational training workflows for large language models
• LoRA Fine-tuning: Parameter-efficient fine-tuning using low-rank adaptation, training less than 1% of the original model's parameters while approaching full fine-tuning performance
• SFT (Supervised Fine-Tuning): Using human-annotated instruction-response pairs to teach the model to follow and respond to human instructions
• Knowledge Distillation: "Compressing" a large model's capabilities into a smaller one
• Reinforcement Learning: Including RLHF and other alignment techniques to make model outputs safer and more useful
• Multimodal: Vision-language model implementations that enable the model to process images alongside text
• Agent: Building autonomous systems with LLMs as the "brain," capable of planning tasks and invoking tools

The ambition is impressive, but this is also where the danger lies. Each of these directions could be a team-level research topic on its own—covering all of them as a single individual inevitably means sacrificing depth.

Honestly, LoRA fine-tuning and SFT already have abundant mature tutorials and tools in the community (like LLaMA-Factory and Unsloth), so the marginal value of pure reproduction is diminishing. What truly differentiates is knowledge distillation and RLHF—the former involves careful teacher-student model design, the latter involves reward model training and PPO engineering optimization. If these two areas are done well, they carry far more weight than the rest.

Rather than spreading across seven directions with a demo each, it would be better to achieve "someone can read this and actually use it" depth in two or three areas. Breadth decorates a resume; depth proves capability.

Quick Glossary of Key Technical Terms

For those new to this field, here's a quick overview of the core concepts involved in this project:

LLM (Large Language Model): Deep learning models with parameters ranging from billions to hundreds of billions, pre-trained on massive text corpora, capable of text generation, Q&A, reasoning, and more. Notable examples include the GPT series, LLaMA series, and Qwen series. The core architecture is based on the Transformer decoder structure.

VLM (Vision Language Model): Multimodal models that process both images and text by combining visual encoders (like ViT) with language models, enabling capabilities like image captioning and visual question answering. Notable examples include GPT-4V, LLaVA, and Qwen-VL.

LoRA (Low-Rank Adaptation): Currently the most popular parameter-efficient fine-tuning method. The core idea is to insert trainable low-rank matrices alongside the original model weights while freezing the original parameters. This requires training far fewer parameters, dramatically reducing memory and compute requirements, while achieving results close to full fine-tuning. Proposed by Microsoft Research in 2022.

SFT (Supervised Fine-Tuning): The critical step that transforms a pre-trained model into a usable conversational model. The model is trained on high-quality instruction-response pairs to learn to follow human instructions. In the overall pipeline, SFT sits between pre-training and RLHF.

Knowledge Distillation: A model compression technique where a small model (student) learns from a large model's (teacher) output distribution rather than just hard labels. This allows the small model to inherit some of the large model's capabilities while maintaining a compact size. Proposed by Hinton in 2015 and widely used in the large model era.

RLHF (Reinforcement Learning from Human Feedback): The core alignment technology behind ChatGPT. The process has three steps: first SFT, then training a reward model on human preference data, and finally using reinforcement learning algorithms like PPO to optimize model outputs based on reward signals. The goal is to make models safer, more useful, and more aligned with human values. More recently, simpler alternatives like DPO and GRPO have emerged.

Agent: A system with an LLM as its core "brain," capable of autonomous planning, decision-making, and tool invocation. It can decompose user instructions into tasks, create plans, call search engines or APIs, and iteratively improve based on feedback. Typical frameworks include ReAct, AutoGPT, and LangChain Agent. This is widely considered the key direction for LLMs evolving from "chat tools" to "autonomous assistants."

Why Qwen2.5-0.5B? A Smart Move and a Forced Hand

The project's base model is Qwen2.5-0.5B-Instruct, the smallest instruction-tuned model in the Qwen2.5 series released by Alibaba's Tongyi Qianwen team in September 2024, with only about 500 million parameters.

Why it's smart: A 500M parameter model can run on a single consumer GPU with 8GB of VRAM, and can even manage inference on CPU. The hardware barrier drops to nearly zero, allowing anyone to reproduce the results. For a learning-oriented project, this is the most pragmatic choice.

Why it's a forced hand: The capability ceiling of a 0.5B model is extremely low. Many advanced techniques—complex reasoning, multi-turn dialogue, Agent tool invocation—may produce dismal results at this scale. It becomes hard to tell whether the algorithm implementation is wrong or the model simply isn't capable enough. This is the eternal dilemma of small-model experiments.

Choosing Qwen over the LLaMA series reflects a subtle ecosystem judgment. Qwen's advantages in Chinese-language scenarios, Alibaba's promotion efforts in the domestic open-source community, and the complete size coverage of the Qwen2.5 series from 0.5B to 72B all make it the most pragmatic choice for individual developers in China.

That said, a word of caution: Over-committing to a single model family can limit technical perspective. Comparative experiments across different architectures (such as Mistral, Gemma) often yield deeper understanding. If something only works on Qwen, switching to another model might tell a completely different story.

Jupyter Notebook: Great for Learning, Not for Engineering

Jupyter Notebook is an interactive programming environment that integrates code, execution results, visualizations, and text explanations in a single document, making it particularly suited for experimental development and educational demonstrations.

This project uses Jupyter Notebook as its primary development language, with a clear positioning: focused on experimental reproduction and learning presentation. You can run it cell by cell, observe intermediate results at each step, and understand the concrete implementation of each algorithm.

But if you want to take this code directly into a production environment, that's essentially unrealistic. Notebook's code organization inherently doesn't support modularization and reuse, which is why most mature open-source projects eventually migrate to standard Python package structures.

Who Is This Project For?

Ultimately, MYLLM is positioned as a full-stack LLM learning project, covering the complete technical pipeline from pre-training to deployment: Pre-training → SFT → RLHF → Knowledge Distillation → Multimodal Extension → Agent Applications.

It's suitable for:

1. Developers new to large models: Those who want to understand the full LLM technology landscape and need a broadly covering reference project
2. Learners with limited hardware: Those with only a consumer GPU or even just a CPU who want to run various algorithms hands-on
3. Students preparing for interviews or building portfolios: Those who need to demonstrate their understanding and hands-on ability with the LLM tech stack

It's less suitable for:

• Those looking for an out-of-the-box fine-tuning tool (check out LLaMA-Factory or Unsloth instead)
• Those looking for production-grade code reference (the project's engineering maturity isn't there)

Final Thoughts

The scarcest resource in the large model era isn't compute, isn't data—it's people willing to start from the first line of code, take each algorithm apart, and put it back together by hand.

The value of MYLLM isn't in how many Stars it has today, but in what it proves: the shortest path to understanding AI will always be building the wheel yourself.

A project with 10 Stars may deserve more respect than a wrapper project with 10,000 Stars.