From 6B to 65B: A Field Guide to Actually Training and Fine-Tuning LLMs

You've read the theory. You've seen the architecture diagrams. But when you sit down to actually fine-tune a 7B model on your own hardware, the gap between "I understand attention" and "why is my GPU OOM-ing" hits hard. The docs are scattered, the blog posts are outdated, and the code snippets on Twitter never quite run. If that sounds familiar, the llm-action repository is the practical companion you've been looking for.

This isn't another curated list of papers. It's a hands-on, code-first guide that walks you through training and inference for models ranging from 6B to 65B parameters, with real tutorials and working code for each step.

What It Does

llm-action is a comprehensive, Chinese-language resource hub for large language model engineering. The README organizes a massive amount of practical content into clear categories covering the entire LLM lifecycle: training, fine-tuning, inference, compression, evaluation, data engineering, and even deployment infrastructure.

The training section is the heart of the project. It includes step-by-step tutorials with companion code for:

• Reproducing Stanford Alpaca (7B) with full fine-tuning
• Using LoRA on LLaMA models from 7B up to 65B
• Implementing P-Tuning v2 and QLoRA for parameter-efficient fine-tuning
• Building RLHF pipelines from scratch

Beyond the hands-on tutorials, the repo dives deep into the underlying theory. There are dedicated sections on distributed training parallel techniques (think data parallelism, tensor parallelism, pipeline parallelism), distributed AI frameworks, and even the network communication layer that makes multi-GPU training work. If you've ever wondered what NCCL is actually doing under the hood, this project covers it.

The scope doesn't stop at training. You'll find sections on inference optimization (like quantization and pruning), LLM compression techniques, benchmarking and evaluation, prompt engineering, and even AI compiler infrastructure. There's also a section on "国产化适配" — adapting LLMs for domestic Chinese hardware and software ecosystems, which is increasingly relevant given the global chip landscape.

Why It's Cool

What makes this project stand out isn't any single tutorial — it's the sheer breadth combined with practical depth.

• It's written by someone who's actually done the work. The author, 吃果冻不吐果冻皮, has clearly hit the same walls you're about to hit. The tutorials aren't sanitized walkthroughs; they read like field notes from someone who debugged the OOM errors so you don't have to.

• The 6B-to-65B range is the sweet spot. Most tutorials stop at 7B because that's what fits on a single consumer GPU. This project pushes into the 65B territory, which means it covers the multi-GPU orchestration, distributed training, and memory optimization techniques that you'll actually need for production-scale work.

• Theory and practice are paired, not separated. Each topic has both a "原理" (principles) section and a "实战" (hands-on) section. You learn why LoRA works, then you see the code that implements it. This dual-track approach means you're not just copy-pasting — you're building understanding.

• It covers the boring-but-critical stuff. There's a section on server environment setup and common tools. That's the kind of thing nobody writes tutorials about, but it's often where beginners get stuck for days. The project also includes LLM interview questions, which makes it useful if you're job hunting or hiring.

• The ecosystem is current. The repo covers recent developments in AI compilers, AI accelerators, cluster networking, and LLMOps. This isn't a static archive — it's tracking the moving target that is the modern LLM stack.

How to Try It

Head over to the repository at github.com/liguodongiot/llm-action and start with the table of contents. It's a long list, so don't try to read it linearly.

If you're new to fine-tuning, pick the Alpaca full fine-tuning tutorial first. It's the foundational walkthrough, and the companion code is in the llm-train/alpaca directory. Clone the repo and follow along:

git clone https://github.com/liguodongiot/llm-action.git
cd llm-action/llm-train/alpaca

If you're already comfortable with the basics, jump straight to the LoRA section for the 7B-to-65B fine-tuning tutorials. The code for those is in llm-train/alpaca-lora.

The author also maintains a WeChat public account and is active on Zhihu, Juejin, and CSDN — so if you prefer following along in a social feed rather than digging through a repo, those links are in the README.

One note: the content is primarily in Chinese. If you're not a Chinese speaker, you'll still get value from the code and the architecture diagrams, but you'll miss some of the nuance in the explanations. Google Translate will get you most of the way there.

Final Thoughts

llm-action is the kind of resource that saves you weeks of scattered Googling. It's not a polished course or a hand-holding tutorial series — it's a dense, practical knowledge base from someone who's been in the trenches. If you're a developer who's comfortable with Python and PyTorch and wants to move from "running inference on a pretrained model" to "training and fine-tuning your own LLMs," this repo is an excellent map for the journey.

The field moves fast, but the fundamentals this project covers — distributed training, efficient fine-tuning, inference optimization — aren't going anywhere. Start with the tutorial that matches your current skill level, work through the code, and keep the repo bookmarked. You'll be coming back to it.

Follow @githubprojects for more developer tools and open source projects.