企业官网建设流程全解析

Python + AI 大模型从入门到项目实战：一条完整的学习路线与落地指南

近两年 AI 大模型相关岗位的需求持续增长，很多同学在后台问我：只学过一点 Python 基础，能不能直接学习大模型开发？从哪一步开始学最合适？市面上教程太多，到底该按什么顺序学？

这篇文章我结合自己从小白到独立完成大模型应用项目的经验，整理了一套从Python 基础 → AI 大模型原理 → 模型部署 → RAG 应用 → 微调 → 项目实战的完整学习与落地路线。内容不求“快”，而是求“全”和“细”，尽量把每个环节的坑都提前说清楚。不论你是刚接触编程的新手，还是有一定开发经验想转型 AI 应用方向的同学，都可以把本文当作一份路线图收藏备用。

为了便于阅读，我把整条路线拆成八个部分，从环境准备一直讲到项目上线，每一步都配有实际可运行的代码示例。

1. 为什么学 AI 大模型首选 Python？

1.1 Python 是 AI 生态的“通用语言”

先理解一个问题：大模型开发为什么言必称 Python？

核心原因是AI 生态里最核心的框架、工具和预训练模型，几乎全部优先提供 Python 接口。无论是 Hugging Face Transformers、PyTorch、TensorFlow，还是 LangChain、LlamaIndex、Ollama、vLLM，Python 都是它们的“一等公民”。这意味着你学习过程中遇到的绝大多数示例代码、开源项目、官方文档，都能用 Python 直接运行。

如果你用 Java 或 Go 开发，遇到一个最新模型开源，很可能需要等社区封装好 SDK 才能调用，而 Python 用户当天就能通过 Transformers 加载权重。技术选型上，Python 几乎是大模型应用开发的最低门槛路径。

1.2 AI 大模型开发的完整链路

先看一张整体技术地图：

Python 基础 ↓ 机器学习/深度学习基础概念（可选但推荐） ↓ 大模型原理与常见模型（Transformer、GPT、LLaMA、Qwen、ChatGLM） ↓ 模型获取与本地部署（Hugging Face、ModelScope、Ollama） ↓ 模型 API 调用与提示词工程（OpenAI 兼容接口、Prompt 设计） ↓ 应用开发框架（LangChain / LlamaIndex / FastAPI） ↓ RAG 检索增强生成（向量数据库 + Embedding） ↓ 模型微调（LoRA / QLoRA 等高效微调） ↓ 模型服务化与项目实战（Gradio、FastAPI、Docker）

以上每一步都不是孤立的。比如 RAG 项目同时依赖 Python 基础、Prompt 工程、向量数据库、后端服务封装等知识，所以学习的顺序很关键。

1.3 常见误区和建议

• 误区一：先把 Python 全部学完才学 AI。Python 语法很多，但 AI 开发真正高频使用的只是变量、函数、类、列表/字典、文件读写、异常处理、装饰器等。建议“边用边学”，在完成项目过程中补语法。
• 误区二：一上来就读大模型论文。读论文是进阶阶段的事，入门阶段先从使用模型、调用 API、做应用开始，建立感性认识后再看原理。
• 误区三：本地没有好显卡就不能学。大模型开发分为“训练/微调”和“应用开发”两类。应用开发（API 调用、RAG、Prompt 工程）不需要专业显卡；即使是微调，也可以用 QLoRA 等方式在消费级显卡上完成。

2. 环境准备与工具链

在写第一行代码之前，先把环境配好。环境问题看似琐碎，但确实是新手最容易卡住的地方。

2.1 Python 版本选择

建议安装Python 3.10 或 3.11。这两个版本对 PyTorch、Transformers 等主流 AI 库支持最好，避免 3.12/3.13 刚发布时部分依赖库还没有适配的情况。

到 Python 官网下载对应系统安装包即可。安装时务必勾选：

Add Python to PATH

Windows 用户可以在命令行验证：

python --version

如果输出类似：

Python 3.11.9

说明安装成功。

2.2 使用虚拟环境隔离项目依赖

强烈建议每个 Python 项目创建独立虚拟环境，避免不同项目的依赖互相冲突。

# 创建虚拟环境（Windows / macOS / Linux 通用） python -m venv venv # 激活虚拟环境 # Windows venv\Scripts\activate # macOS / Linux source venv/bin/activate

激活后，命令行前面会出现(venv)前缀，说明当前在虚拟环境中。

2.3 IDE 选择与配置

对于 AI 开发，VS Code 是目前最主流的编辑器，配置简单且插件丰富。

推荐安装以下 VS Code 插件：

安装插件后，在 VS Code 中按Ctrl+Shift+P，输入Python: Select Interpreter，选择刚才创建的虚拟环境路径。

2.4 基本 Python 包安装

创建并激活虚拟环境后，先安装一批基础 AI 库：

pip install --upgrade pip pip install numpy pandas matplotlib jupyter pip install torch transformers datasets accelerate

安装时如果速度慢，可以临时使用国内镜像源：

pip install torch -i https://pypi.tuna.tsinghua.edu.cn/simple

注意：PyTorch 的安装版本取决于你的 CUDA 环境。如果没有 NVIDIA 显卡，直接安装 CPU 版本即可；有 NVIDIA 显卡的同学，建议先到 PyTorch 官网根据 CUDA 版本复制对应的安装命令。

3. 大模型核心概念：先建立整体认知

在实际动手部署模型之前，有必要先理解几个最基础的概念。否则后面看到“模型参数”“上下文窗口”“Token”这些词很容易懵。

3.1 什么是大语言模型

大语言模型（Large Language Model，LLM）本质上是基于Transformer架构的深度神经网络模型，通过在海量文本数据上进行“下一个 Token 预测”任务训练而成。

用一句话概括：给它一段文字，它根据已经看到的内容预测下一个最可能出现的词，然后不断重复这个过程，最终生成完整回答。

当前主流的开源模型包括：

• Qwen（通义千问）系列
• ChatGLM / GLM 系列
• LLaMA / Llama 系列
• DeepSeek 系列
• Mistral 系列

各个模型有不同参数规模，比如 0.5B、1.8B、7B、14B、72B 等。这里的 B 表示Billion（十亿），参数越多，模型理论上能力越强，但对显存和计算资源要求也越高。

3.2 Token：模型处理文本的基本单位

大模型并不是按“字”来理解文本的，而是按Token。Token 可以理解为“词元”，一个 Token 可能是一个完整的英文单词、一个中文字符或几个字符的组合。

例如句子：

我喜欢Python编程

按中文字符切分，大概会对应 10 个左右的 Token（不同分词器切分规则不同）。

Token 数量决定了模型能接收多长的输入和输出。模型都有“上下文窗口”限制，例如 8K、32K、128K。输入 + 输出总长度不能超过上下文窗口，否则会报错或自动截断。

3.3 推理资源估算：7B 模型需要多大显存

很多同学关心本地部署模型需要什么配置。这里给一个粗略但实用的估算方法。

以 FP16（半精度）加载一个 7B 参数模型为例，模型权重约占显存：

7B × 2 字节 ≈ 14 GB

再加上 KV Cache、中间激活值等额外开销，7B 模型在 FP16 精度下一般建议 16 GB 以上显存。

如果显存不够，可以采取以下方案：

• 使用 4bit/8bit 量化加载，例如bitsandbytes库，7B 模型量化后可以降到 6 GB 以内。
• 使用 Ollama 等工具，它默认对模型做量化，部署门槛更低。
• 使用 CPU 部署，速度较慢但可以跑通流程；也可以使用 Apple Silicon 的 MacBook，M 系列芯片对部分模型有特殊加速优化。

3.4 提示词工程：大模型应用开发的起点

提示词工程（Prompt Engineering）是用自然语言引导模型输出符合需求内容的技术。即使不做任何微调，通过精心设计的 Prompt，模型输出质量也会有显著差异。

一个经典的提示词结构包括：

角色设定 + 任务描述 + 输入数据 + 输出格式要求

示例：

你是一位资深Python工程师，擅长代码审查。 请审查下面这段代码，指出潜在问题，并按“问题描述 -> 原因分析 -> 修改建议”的格式输出。 代码： def calc(a, b): return a / b

一个好的 Prompt 是项目效果的上限。很多初学者把大量时间花在“调模型”上，其实先优化 Prompt 往往能解决大部分问题。

4. 本地部署模型：从 Ollama 到 Hugging Face

本地部署模型是学习大模型最具成就感的环节之一。这里我介绍两种主流方式。

4.1 方式一：使用 Ollama 快速部署

Ollama 是目前最简单易用的本地模型运行工具，支持 Windows、macOS、Linux，一条命令即可启动模型。

安装 Ollama 后，在终端执行：

# 拉取并运行 Qwen2.5 7B 模型 ollama run qwen2.5:7b

首次运行会自动下载模型权重，之后进入交互式对话界面。

在实际项目中，我们更多是通过 HTTP API 调用模型。Ollama 默认提供了 OpenAI 兼容的接口：

# 启动 Ollama 服务（默认 11434 端口） ollama serve

然后使用 Python 调用：

import requests response = requests.post( "http://localhost:11434/api/chat", json={ "model": "qwen2.5:7b", "messages": [ {"role": "user", "content": "用一句话解释什么是大模型"} ], "stream": False } ) print(response.json()["message"]["content"])

这个方案的好处是：不用手动处理显存配置、模型下载、CUDA 环境问题，是初学者本地学习的首选。

4.2 方式二：使用 Hugging Face Transformers 加载模型

如果你要微调模型，或者在代码中直接获得模型输出，Hugging Face Transformers 是更主流的选择。

安装依赖：

pip install transformers torch accelerate

加载一个生成模型做推理：

from transformers import AutoTokenizer, AutoModelForCausalLM import torch # 使用通义千问 1.8B 模型作为示例 model_name = "Qwen/Qwen2.5-1.5B-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name, trust_remote_code=True, torch_dtype=torch.float16, device_map="auto" ) prompt = "请用一句话解释Python的GIL锁。" messages = [ {"role": "system", "content": "你是一位耐心的Python技术老师。"}, {"role": "user", "content": prompt} ] text = tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True ) inputs = tokenizer([text], return_tensors="pt").to(model.device) outputs = model.generate( inputs.input_ids, max_new_tokens=256, do_sample=True, temperature=0.7 ) response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True) print(response)

说明：

• trust_remote_code=True允许加载部分需要自定义代码的模型。
• torch_dtype=torch.float16使用半精度加载，减少显存占用。
• device_map="auto"让库自动决定把模型放到 GPU 还是 CPU。
• apply_chat_template会将 messages 转换成模型指定的对话格式。

如果本地没有显卡，可以去掉torch_dtype，模型会自动以 FP32 跑 CPU，速度会慢一些，但能正常运行。

4.3 通过 ModelScope 下载模型

Hugging Face 在国内访问不稳定，可以使用国内镜像平台ModelScope（魔搭）下载模型。

pip install modelscope

下载 Qwen2.5 模型：

from modelscope import snapshot_download model_dir = snapshot_download('Qwen/Qwen2.5-7B-Instruct') print(model_dir)

下载完成后，把得到的本地路径传给AutoTokenizer.from_pretrained即可。

5. 开发第一个大模型实战项目：本地知识库问答助手

理论部分先告一段落。从这一节开始，我们做一个完整的实战项目：基于 RAG 的本地知识库问答助手。

5.1 项目背景与需求

传统大模型只能根据训练数据回答问题，无法回答你私有文档中的内容。RAG（Retrieval-Augmented Generation，检索增强生成）的思路是：

用户提问 ↓ 在知识库中检索相关文档片段 ↓ 把文档片段 + 原始问题一起交给大模型 ↓ 大模型基于检索到的内容生成回答

这样做的好处是：

• 不需要微调模型，成本低。
• 知识库内容可以随时更新。
• 回答可以溯源到具体文档，减少幻觉。

最终效果是：你上传几份 Python 技术文档或公司内部手册，就能构建一个针对该知识的问答助手。

5.2 技术选型与项目结构

我们选用的技术栈：

• 文本加载与切分：LlamaIndex 或 LangChain
• Embedding 模型：text2vec或BAAI/bge-small-zh-v1.5
• 向量存储：Chroma（轻量、本地、免部署）
• 大模型：Ollama 加载的 Qwen2.5
• 服务接口：FastAPI + Gradio

项目结构如下：

knowledge_base_assistant/ ├── venv/ # 虚拟环境 ├── data/ # 原始知识文档 │ └── python_notes.md ├── src/ │ ├── ingest.py # 文档加载与向量入库 │ ├── query.py # 检索与问答 │ └── app.py # Gradio 界面 ├── requirements.txt └── README.md

5.3 安装依赖

pip install llama-index chromadb fastapi gradio

注意：LlamaIndex 默认需要 OpenAI API，但我们使用 Ollama 本地模型，需要额外安装：

pip install llama-index-llms-ollama llama-index-embeddings-huggingface

5.4 文档向量化入库

创建src/ingest.py，先加载文档并写入向量数据库。

# src/ingest.py from pathlib import Path from llama_index.core import ( SimpleDirectoryReader, VectorStoreIndex, Settings, StorageContext ) from llama_index.vector_stores.chroma import ChromaVectorStore from llama_index.embeddings.huggingface import HuggingFaceEmbedding from llama_index.llms.ollama import Ollama import chromadb # ======== 全局配置 ======== embed_model = HuggingFaceEmbedding( model_name="BAAI/bge-small-zh-v1.5" ) llm = Ollama(model="qwen2.5:7b", request_timeout=120.0) Settings.embed_model = embed_model Settings.llm = llm # ======== 向量数据库初始化 ======== # 使用 Chroma 持久化存储数据 db_path = "./chroma_db" chroma_client = chromadb.PersistentClient(path=db_path) collection = chroma_client.get_or_create_collection("knowledge_base") vector_store = ChromaVectorStore(chroma_collection=collection) storage_context = StorageContext.from_defaults(vector_store=vector_store) # ======== 加载文档 ======== documents = SimpleDirectoryReader( input_dir="./data", required_exts=[".md", ".txt"], recursive=True ).load_data() print(f"成功加载 {len(documents)} 个文档片段") # ======== 构建索引并持久化 ======== index = VectorStoreIndex.from_documents( documents, storage_context=storage_context, ) print("知识库索引构建完成！")

运行：

python src/ingest.py

这一步完成了 RAG 的第一个关键环节：把原始文档切分成小块（通常几百字左右），并为每一块生成向量表示，然后存入向量数据库。

关于 Embedding 模型说明：BAAI/bge-small-zh-v1.5是一个轻量级中文向量模型，首次运行会自动下载，大约 100 MB 左右。它的作用是计算文本的语义向量，检索时通过余弦相似度找到与问题最相关的文档片段。

5.5 编写问答查询逻辑

创建src/query.py，实现“检索 + 生成”的完整流程。

# src/query.py from llama_index.core import VectorStoreIndex from llama_index.core.storage.storage_context import StorageContext from llama_index.vector_stores.chroma import ChromaVectorStore import chromadb # 连接已有向量数据库 db_path = "./chroma_db" chroma_client = chromadb.PersistentClient(path=db_path) collection = chroma_client.get_collection("knowledge_base") vector_store = ChromaVectorStore(chroma_collection=collection) index = VectorStoreIndex.from_vector_store(vector_store) # 创建问答引擎 query_engine = index.as_query_engine( similarity_top_k=3, # 检索 3 个最相关的文档片段 ) # 测试提问 question = "Python中列表和元组有什么区别？" response = query_engine.query(question) print("问题：", question) print("回答：", str(response))

运行：

python src/query.py

如果知识库文档中恰好包含类似内容，模型会结合检索到的片段进行回答，并在回答中引用原文。

5.6 用 Gradio 搭建交互界面

为了让项目更完整，我们用 Gradio 做一个可视化问答界面。

创建src/app.py：

# src/app.py import gradio as gr from query import query_engine def answer(question): response = query_engine.query(question) return str(response) demo = gr.Interface( fn=answer, inputs=gr.Textbox(label="输入你的问题", lines=3), outputs=gr.Textbox(label="回答", lines=8), title="本地知识库问答助手", description="基于 RAG + Qwen2.5 构建的本地知识库问答系统" ) if __name__ == "__main__": demo.launch(server_name="0.0.0.0", server_port=7860)

运行：

python src/app.py

浏览器访问http://localhost:7860，就能看到问答界面了。

到这里，你已经完成了一个完整的 RAG 项目，涉及文档加载、向量化、检索、大模型生成、Web 界面等核心环节。把这套流程扩展开，可以直接复用到企业文档问答、个人知识库助手等场景。

6. 大模型微调入门：用 LoRA 训练自己的模型

很多同学想问：如果知识库场景用 RAG 就能解决，那什么时候需要微调？

简单来说：

• 你想让模型学会特定格式的输出：比如让它按你的 JSON Schema 输出结构化数据。
• 你想让模型学习特定领域的专业术语和表达风格：比如医疗报告、法律文书。
• 你想让模型掌握某些私有数据中的规律：比如代码规范、SQL 方言。

微调中目前最流行的方法是LoRA（Low-Rank Adaptation，低秩适配）。它的核心思想是：冻结原始模型权重，只训练一小部分附加的低秩矩阵参数，用很小的显存开销实现接近全参微调的效果。

6.1 使用 QLoRA 进行高效微调的示例

下面演示基于 Hugging Facepeft库对 Qwen2.5 模型做 LoRA 微调的核心流程。

安装依赖：

pip install peft bitsandbytes trl

准备训练数据，格式为 JSON 文件：

[ { "instruction": "请写一个Python函数，实现两个数字相加。", "output": "def add(a, b):\n return a + b" }, { "instruction": "请用Python实现一个列表去重功能。", "output": "def unique_list(items):\n return list(set(items))" } ]

微调脚本核心代码：

from datasets import Dataset from transformers import ( AutoTokenizer, AutoModelForCausalLM, TrainingArguments, BitsAndBytesConfig ) from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training from trl import SFTTrainer import torch # 4bit 量化配置，降低显存占用 bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, ) model_name = "Qwen/Qwen2.5-1.5B-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name, quantization_config=bnb_config, device_map="auto", trust_remote_code=True ) model = prepare_model_for_kbit_training(model) # LoRA 配置 lora_config = LoraConfig( r=8, # 低秩矩阵的秩 lora_alpha=32, # 缩放参数 target_modules=["q_proj", "k_proj", "v_proj", "o_proj"], lora_dropout=0.05, bias="none", task_type="CAUSAL_LM" ) model = get_peft_model(model, lora_config) # 加载数据 train_data = [ {"text": f"指令：{item['instruction']}\n回答：{item['output']}"} for item in [ {"instruction": "请写一个Python函数，实现两个数字相加。", "output": "def add(a, b):\n return a + b"}, {"instruction": "请用Python实现一个列表去重功能。", "output": "def unique_list(items):\n return list(set(items))"} ] ] dataset = Dataset.from_list(train_data) # 训练参数 training_args = TrainingArguments( output_dir="./lora_output", per_device_train_batch_size=1, gradient_accumulation_steps=4, num_train_epochs=3, learning_rate=2e-4, fp16=True, logging_steps=10, save_steps=100, save_total_limit=2, remove_unused_columns=False, ) # 使用 SFTTrainer 进行指令微调 trainer = SFTTrainer( model=model, train_dataset=dataset, args=training_args, tokenizer=tokenizer, ) trainer.train() # 保存 LoRA 权重 model.save_pretrained("./lora_output/final") print("微调完成，LoRA 权重已保存")

这段代码只是演示核心思路，实际项目中你需要：

• 准备更多、更高质量的训练数据。
• 认真设置target_modules，不同模型结构不同，LoRA 要适配的目标层也不同。
• 训练时观察 loss 变化，避免过拟合或欠拟合。

6.2 微调的显存建议

LoRA/QLoRA 已经大幅降低了微调门槛，但仍有基础要求：

显存不足时，还可以进一步压缩训练序列长度，或者使用更小的 batch size + 梯度累积。

6.3 微调后的模型加载

微调完成后，加载 LoRA 模型推理：

from peft import PeftModel from transformers import AutoTokenizer, AutoModelForCausalLM base_model_name = "Qwen/Qwen2.5-1.5B-Instruct" lora_path = "./lora_output/final" tokenizer = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( base_model_name, device_map="auto", trust_remote_code=True ) model = PeftModel.from_pretrained(model, lora_path) inputs = tokenizer("指令：请写一个Python函数，实现两个数字相加。", return_tensors="pt") outputs = model.generate(**inputs, max_new_tokens=128) print(tokenizer.decode(outputs[0], skip_special_tokens=True))

7. 常见问题与排查思路

AI 大模型开发过程中，环境问题和报错几乎不可避免。以下是初学者最高频遇到的问题及排查方案。

排查问题时建议按以下顺序：

1. 先看报错堆栈，定位是网络问题、依赖问题还是代码问题。
2. 检查当前虚拟环境是否已激活，库有没有安装到当前环境。
3. 确认模型路径、数据集路径是否存在。
4. 把代码中的超参数逐步调回默认值，排除参数异常。
5. 查看官方 GitHub Issues，多数常见问题都有人遇到并解决。

8. 最佳实践与工程建议

学完技术点之后，工程习惯同样重要。以下建议来自项目落地过程中的经验总结。

8.1 关于项目结构

• 每个项目使用独立虚拟环境，并生成requirements.txt：

pip freeze > requirements.txt

• 敏感信息（API Key、数据库地址）不要硬编码到代码里，使用.env文件，并加入.gitignore。

pip install python-dotenv

from dotenv import load_dotenv import os load_dotenv() api_key = os.getenv("OPENAI_API_KEY")

8.2 关于 Prompt 管理

• 把 Prompt 从代码中抽离出来，放到独立的配置文件或模板文件中。
• 对 Prompt 进行版本管理，每次修改记录变化。
• 设计 Prompt 时尽量给出输出格式示例，少用模糊描述。

8.3 关于模型与数据安全

• 本地部署模型前确认模型许可证是否符合使用场景。
• 涉及公司内部知识库时，先进行脱敏处理，并对访问权限做控制。
• 部署到生产环境时，服务应运行在内网或经过身份认证，不要直接裸奔到公网。
• 大模型输出不可控，重要业务场景需要增加输出过滤和人工审核机制。

8.4 关于性能优化

• 并发请求较多时，不要使用同步阻塞方式调用模型，推荐使用 FastAPI 异步接口。
• 使用 vLLM 等推理加速框架部署服务，相比原生 Transformers 能显著提升吞吐量。
• RAG 应用中，知识库内容经常更新时，建议只对新文档增量构建向量索引，而不是每次都全量重建。

8.5 关于“AI 辅助”与生产力工具

很多同学还会问：AI 编程工具（如 Cursor、GitHub Copilot）现在这么强，还需要手动学吗？我的观点是：工具可以加速开发，但不能替代对原理的理解。AI 编程工具擅长生成模板代码、补全函数、解释报错，但在系统架构设计、性能调优、安全边界判断等场景，仍然需要开发者有自己的判断。建议学习阶段多手动敲代码、多调试，逐步掌握原理后再借助 AI 工具提高效率。

9. 总结与后续学习路线

最后把这篇文章的知识点串起来。

你已经掌握的内容：

• Python 是 AI 大模型开发的首选语言，核心原因在于 AI 生态对 Python 的深度支持。
• 大模型的基础概念：Token、上下文窗口、参数规模、推理显存估算。
• 本地部署模型的两种方式：Ollama 快速部署、Hugging Face Transformers 自定义部署。
• 一个完整的 RAG 知识库问答项目：文档加载、向量化、检索、生成、Web 界面。
• LoRA 微调的核心思路与最小实现。

下一步可以继续深入的方向：

1. 学习 LangChain / LlamaIndex 更多高级用法，包括 Agent、工具调用、多轮对话。
2. 学习 FastAPI 完整工程化开发，把模型封装成高并发服务。
3. 深入学习 vLLM 部署方案，掌握模型生产环境部署。
4. 学习 Function Calling / Tool Use 机制，让模型具备调用外部工具的能力。
5. 尝试做一个完整的 Agent 项目，例如自动代码生成助手、数据分析助手、行业知识助手。

AI 大模型领域技术迭代非常快，但核心基础是稳定的：Python 语法、模型推理流程、RAG 模式、微调原理，这些掌握后可以迁移到任何新模型和工具上。

如果这篇文章对你有帮助，建议收藏备用。环境配置和项目落地过程中遇到问题，欢迎在评论区留言讨论。后续我还会更新大模型微调实战、FastAPI 服务化部署、Agent 开发等进阶内容，可以保持关注。