人工智能应用开发快速入门

面向高职学生/零基础开发者，重实践、轻理论，学会用工具解决实际问题，不抠数学推导。

---

目录

• 前置准备：环境搭建
• 第一章：机器学习基础（Scikit-learn）
• 第二章：深度学习导论
• 第三章：计算机视觉入门
• 第四章：自然语言处理入门
• 第五章：模型部署
• 第六章：模型压缩与优化
• 第七章：大模型API调用与微调
• 第八章：实战项目推荐

---

前置准备：环境搭建

需要安装的软件

1. Python 3.9+：官网下载，勾选"Add Python to PATH"
2. VS Code：代码编辑器，安装Python插件
3. Git：代码版本管理工具

常用Python库安装

pip install numpy pandas matplotlib scikit-learn torch torchvision opencv-python
pip install transformers onnx onnxruntime-tensorrt onnxruntime
pip install transformers datasets peft accelerate langchain openai

提示：如果安装慢，使用清华镜像： bash pip install 包名 -i https://pypi.tuna.tsinghua.edu.cn/simple

---

第一章：机器学习基础（Scikit-learn）

核心目标：会用Scikit-learn训练机器学习模型，解决实际问题，不用推导公式。

1.1 机器学习到底是什么？

简单说：给算法很多数据，让算法从数据中学到规律，然后用这个规律预测新的数据。

常见分类： - 监督学习：数据有标签（比如告诉算法这张图是猫，那是狗），我们主要学这个 - 无监督学习：数据没有标签，让算法自己找规律 - 强化学习：让算法在环境中通过试错学习

1.2 一个完整的机器学习流程

数据收集 → 数据预处理 → 划分训练集测试集 → 选择模型 → 训练模型 → 预测 → 评估模型

1.3 实战：房价预测（线性回归）

代码示例：

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# 1. 加载数据
data = fetch_california_housing()
X = data.data  # 特征
y = data.target # 标签（房价）

# 2. 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 3. 创建模型
model = LinearRegression()

# 4. 训练模型
model.fit(X_train, y_train)

# 5. 预测
y_pred = model.predict(X_test)

# 6. 评估
mse = mean_squared_error(y_test, y_pred)
print(f"均方误差: {mse:.4f}")

关键点： - 不用推导线性回归的公式，会调用fit()训练，predict()预测就行 - 重点理解：训练集是用来让模型学习的，测试集是用来检验模型学的好不好的

1.4 其他常用模型

问题类型	常用模型	Scikit-learn调用
分类问题	逻辑回归	from sklearn.linear_model import LogisticRegression
分类问题	决策树	from sklearn.tree import DecisionTreeClassifier
分类/回归	随机森林	from sklearn.ensemble import RandomForestClassifier
聚类	K-Means	from sklearn.cluster import KMeans

记住： 调用方式都差不多，都是fit()训练，predict()预测，不用记住每个模型的原理，会用就行，需要的时候查文档。

1.5 数据预处理很重要

常用操作： - 缺失值处理：填充平均值/中位数，或者删除缺失样本 - 特征缩放：StandardScaler或MinMaxScaler，让不同特征的尺度差不多 - 编码分类变量：OneHotEncoder把文字变成数字

示例：

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

---

第二章：深度学习导论

核心目标：理解深度学习基本概念，会用PyTorch跑通简单的神经网络。

2.1 深度学习是什么？

深度学习就是多层神经网络，层数越多，能学到越复杂的规律。

• 输入层：输入数据（比如图片像素）
• 隐藏层：多层计算，提取特征
• 输出层：输出预测结果

不用推导反向传播公式，你只要知道： - 神经网络就是一堆"神经元"连接起来，层层计算 - PyTorch/TensorFlow这些框架已经帮你实现了所有自动求导，你只要调用API就行

2.2 PyTorch基础入门

最简单的神经网络：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义一个简单的全连接神经网络
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 初始化模型
model = SimpleNN(input_size=10, hidden_size=20, output_size=2)

# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

核心概念： - forward：前向传播，计算预测结果 - 损失函数：衡量预测和真实值的差距 - 优化器：更新模型参数，减小损失

训练一步：

# 假设x是输入，y是真实标签
optimizer.zero_grad()  # 梯度清零
outputs = model(x)     # 前向传播
loss = criterion(outputs, y) # 计算损失
loss.backward()        # 反向传播，计算梯度
optimizer.step()       # 更新参数

记住这个四步走：梯度清零 → 前向传播 → 反向传播 → 更新参数，所有神经网络训练都是这个流程。

这四步确实是神经网络训练的核心闭环，不管是 PyTorch、TensorFlow 还是其他框架，本质都是围绕这个逻辑展开 —— 只是不同框架的 API 写法不同，但核心步骤完全一致。

核心步骤	作用（通俗解释）	PyTorch 代码示例	TensorFlow 代码示例（GradientTape 模式）
梯度清零	避免上一轮迭代的梯度累加，保证每轮梯度独立	optimizer.zero_grad()	optimizer.zero_grad()（同 PyTorch）
前向传播	把数据喂给模型，计算预测值和损失值	output = model(data)``loss = criterion(output, target)	with tf.GradientTape() as tape: output = model(data, training=True) loss = loss_fn(target, output)
反向传播	计算损失对模型参数的梯度（链式法则）	loss.backward()	grads = tape.gradient(loss, model.trainable_variables)
更新参数	用计算好的梯度，按优化器规则调整模型参数	optimizer.step()	optimizer.apply_gradients(zip(grads, model.trainable_variables))

二、统一视角：用伪代码看核心闭环

2.3 训练一个MNIST手写数字识别

MNIST是手写数字图片，0-9，经典入门项目。

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载数据
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 定义模型
class MNISTNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(32 * 14 * 14, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(-1, 32 * 14 * 14)
        x = self.fc1(x)
        return x

# 训练
model = MNISTNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

for epoch in range(5): # 训练5轮
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

        if batch_idx % 100 == 0:
            print(f"Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.4f}")

print("训练完成！")

跑起来，你就得到了一个能识别手写数字的深度学习模型。

---

第三章：计算机视觉入门

核心目标：理解计算机视觉基本任务，会用预训练模型做推理。

3.1 计算机视觉能做什么？

• 图像分类：判断图片里是什么物体
• 目标检测：找出图片里有什么物体，在哪里（用框框出来）
• 图像分割：把物体从背景中分割出来，精确到像素
• 人脸识别：识别出是谁
• OCR：识别图片中的文字

3.2 用预训练图像分类模型

不用自己训练，直接用别人训练好的模型：

import torch
from torchvision import models, transforms
from PIL import Image

# 加载预训练模型
model = models.resnet50(pretrained=True)
model.eval() # 切换到评估模式

# 预处理
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# 预测
img = Image.open("test.jpg")
img_tensor = transform(img).unsqueeze(0)
with torch.no_grad(): # 不计算梯度，更快
    outputs = model(img_tensor)
    _, predicted = outputs.max(1)
print(f"预测类别编号: {predicted.item()}")

ImageNet有1000个类别，去网上搜一下对应类别名称就知道预测结果了。

3.3 目标检测入门（YOLO）

YOLO是现在最流行的目标检测模型，速度快，效果好。

使用Ultralytics YOLO：

pip install ultralytics

from ultralytics import YOLO

# 加载预训练模型
model = YOLO("yolov8n.pt")

# 预测
results = model("test.jpg")

# 显示结果
for result in results:
    result.show() # 弹出窗口显示标注好的图片
    result.save("output.jpg") # 保存图片

就这么简单！几行代码就能跑通目标检测，能识别80种常见物体。

3.4 图像分割入门

图像分割就是把每个像素分类，精确分出物体轮廓。

用YOLOv8也能做分割：

from ultralytics import YOLO

model = YOLO("yolov8n-seg.pt") # 分割预训练模型
results = model("test.jpg")
for result in results:
    result.show()

---

第四章：自然语言处理入门

核心目标：理解NLP基本任务，会用预训练模型做文本分类和问答。

4.1 NLP能做什么？

• 文本分类：判断文本类别（比如垃圾邮件分类、情感分析）
• 命名实体识别：找出文本中的人名、地名、组织名
• 机器翻译：把一种语言翻译成另一种语言
• 问答系统：根据问题和上下文，给出答案
• 文本生成：生成文章、代码、对话

4.2 文本分类实战：情感分析

用Hugging Face Transformers，几行代码：

pip install transformers

from transformers import pipeline

# 加载预训练情感分析模型
classifier = pipeline("sentiment-analysis")

# 预测
result = classifier("I really liked this movie!")
print(result)
# 输出: [{'label': 'POSITIVE', 'score': 0.9998...}]

太简单了吧！预训练模型已经帮你训练好了，直接用就行。

中文情感分析：

classifier = pipeline("sentiment-analysis", model="hfl/chinese-roberta-wwm-ext")
result = classifier("这家餐厅味道真不错！")
print(result)

4.3 问答系统入门

问答系统就是给它一段上下文，问一个问题，它从上下文中找出答案。

from transformers import pipeline

qa_pipeline = pipeline("question-answering", 
                       model="distilbert-base-cased-distilled-squad")

context = """
OpenClaw is an open source personal assistant framework that runs on your local machine. 
It supports multiple AI models and can help you with daily tasks, coding, writing and more.
"""

question = "What is OpenClaw?"

result = qa_pipeline(question=question, context=context)
print(f"答案: {result['answer']}")
print(f"分数: {result['score']:.4f}")

---

第五章：模型部署（TensorRT/ONNX）

核心目标：把训练好的模型转换成部署格式，让它在生产环境跑得更快。

5.1 为什么需要模型部署？

训练好的模型要给用户用，需要部署成服务： - 更快的推理速度 - 更低的资源占用 - 方便集成到应用程序中

5.2 ONNX是什么？

ONNX是一种开放的神经网络模型格式，把模型从PyTorch/TensorFlow转换成ONNX，就能在不同推理引擎上跑。

PyTorch导出ONNX示例：

import torch
import torchvision.models as models

model = models.resnet50(pretrained=True)
model.eval()

# 示例输入
dummy_input = torch.randn(1, 3, 224, 224)

# 导出ONNX
torch.onnx.export(model, dummy_input, "resnet50.onnx", 
                  opset_version=17,
                  input_names=["input"], 
                  output_names=["output"])

就导出了一个resnet50.onnx文件，现在可以用ONNX Runtime推理了。

用ONNX Runtime推理：

import onnxruntime as ort
import numpy as np

session = ort.InferenceSession("resnet50.onnx")
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

# 假设有预处理好的输入numpy数组
result = session.run([output_name], {input_name: input_numpy})
print(result)

5.3 TensorRT是什么？

TensorRT是NVIDIA推出的模型推理加速引擎，能在NVIDIA GPU上把模型跑得更快。

转换流程： 1. 先把PyTorch模型导出成ONNX 2. 用TensorRT把ONNX转换成.engine格式（优化后的模型） 3. 用TensorRT推理

主要优势： - 量化：把FP32模型转换成FP16/INT8，体积更小，速度更快，精度损失不大 - 层融合：把多个层融合在一起，减少内存访问，提高速度 - 内核自动调优：根据你的GPU选择最优的计算内核

对于计算机视觉模型，TensorRT通常能带来2-5倍的速度提升。

---

第六章：模型压缩与优化

核心目标：让模型更小更快，能在端侧（手机、嵌入式设备）运行。

6.1 为什么需要模型压缩？

大模型精度高，但体积大，速度慢，跑不动在手机上。压缩后： - 体积变小，占用内存更少 - 推理速度变快，延迟更低 - 能耗降低，适合移动设备

6.2 常见的模型压缩方法

方法	原理	适用场景
剪枝	去掉神经网络中不重要的权重，让模型变稀疏	大部分神经网络
量化	用更低精度的数表示权重（FP32→FP16→INT8）	所有模型，推荐优先试
知识蒸馏	用大模型（老师）教小模型（学生）	有大模型精度，想要小模型速度
低秩分解	把大矩阵分解成几个小矩阵相乘	全连接层和卷积层

6.3 实战：PyTorch模型量化

PyTorch自带动态量化，非常简单：

import torch
from torch import nn

# 你的模型
model = nn.Sequential(
    nn.Linear(100, 50),
    nn.ReLU(),
    nn.Linear(50, 10)
)
model.eval()

# 动态量化，把Linear层量化成int8
quantized_model = torch.ao.quantization.quantize_dynamic(
    model, {nn.Linear}, dtype=torch.qint8
)

print(f"原始模型大小: {sum(p.numel() * p.element_size() for p in model.parameters()) / 1024 / 1024:.2f} MB")
print(f"量化后模型大小: {sum(p.numel() * p.element_size() for p in quantized_model.parameters()) / 1024 / 1024:.2f} MB")

通常量化后模型大小能缩小到原来的1/4左右，速度也会变快，精度下降不大。

---

第七章：大模型API调用与微调

核心目标：会调用大模型API开发应用，会做简单的微调。

7.1 大模型API调用入门

现在OpenAI、Anthropic、百度文心、阿里通义都开放了API，直接调用就能用。

OpenAI API示例：

pip install openai

from openai import OpenAI

client = OpenAI(api_key= "***")

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "你是一个有用的助手。"},
        {"role": "user", "content": "写一个Python冒泡排序代码"}
    ]
)

print(response.choices[0].message.content)

就这么简单，拿到返回结果就能在你的应用里用了。

国内大模型示例（百度文心）：

import erniebot

erniebot.api_type = "aistudio"
erniebot.access_token = "***"

response = erniebot.ChatCompletion.create(
    model="ernie-3.5",
    messages=[{"role": "user", "content": "介绍一下什么是大模型"}]
)

print(response.get_result())

7.2 Prompt工程入门

Prompt就是你给大模型的指令，Prompt写得好，大模型回答得好。

几个实用技巧： 1. 明确指令：不要说"给我讲讲AI"，要说"给我写一个面向高职学生的AI入门介绍，控制在300字以内" 2. 给例子："按照这个例子格式生成：输入→处理步骤→输出" 3. 限定范围："只用给定的上下文信息回答，不要用你自己知道的内容" 4. 分步思考："让我们一步一步来解决这个问题" 5. 角色扮演："你现在是一个Python编程老师，给学生讲解这个问题"

7.3 RAG检索增强生成

RAG是现在大模型应用最火的技术，能让大模型基于你的私有数据回答问题。

整体流程：

你的文档 → 切分小块 → 转成向量 → 存在向量数据库 → 用户问题 → 转向量 → 检索相关文档 → 把文档+问题给大模型 → 大模型回答

极简RAG示例：

from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI

# 1. 加载文档
loader = TextLoader("my_docs.txt")
documents = loader.load()

# 2. 切分文档
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# 3. 嵌入并保存到向量数据库
embeddings = OpenAIEmbeddings()
vectordb = Chroma.from_documents(texts, embeddings, persist_directory="./chroma_db")

# 4. 创建检索问答链
qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model_name="gpt-3.5-turbo"),
    chain_type="stuff",
    retriever=vectordb.as_retriever()
)

# 5. 提问
query = "xxx问题"
result = qa_chain.run(query)
print(result)

RAG能解决大模型"幻觉"问题，回答都是来自你的文档，非常适合做企业知识库。

7.4 大模型微调入门（LoRA）

如果你想让大模型适配你的特定领域，可以用LoRA微调，比全微调省很多GPU资源。

LoRA原理： - 不更新大模型所有参数，只训练一小部分额外的低秩矩阵参数 - 原始大模型参数冻住不动，所以显存占用少很多 - 最终只需要保存很小的LoRA权重文件，几MB到几百MB不等

使用PEFT库做LoRA微调（简化版）：

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model

# 加载基座模型和tokenizer
model = AutoModelForCausalLM.from_pretrained("Llama-2-7b-hf")
tokenizer = AutoTokenizer.from_pretrained("Llama-2-7b-hf")

# 配置LoRA
lora_config = LoraConfig(
    r=8,  # 秩
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"], # 要微调的层
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# 包装成PEFT模型
model = get_peft_model(model, lora_config)
model.print_trainable_parameters() 
# 通常可训练参数只有不到1%，非常省显存

# 然后正常训练就行了...

对于大多数应用场景，如果你数据量不是特别大，用LoRA足够了，不需要全参数微调。

---

第八章：实战项目推荐

学完上面内容，选一个项目动手做，做完就入门了。

8.1 计算机视觉应用项目

项目一：基于YOLOv8的工业零件缺陷检测

• 任务：检测工业图片中零件是否有缺陷，标出缺陷位置
• 步骤： 1. 收集缺陷图片数据集（网上公开有很多） 2. 用LabelImg标注数据 3. 用YOLOv8微调 4. 转ONNX/TensorRT部署 5. 做成一个简单的GUI程序
• 难度：⭐⭐☆☆☆
• 价值：企业真实需求，找工作很加分

项目二：基于计算机视觉的人流量统计

• 任务：监控摄像头画面，统计进出人数
• 步骤： 1. 用YOLO检测行人 2. 用追踪算法跟踪行人 3. 判断进出方向，统计数量 4. 输出统计结果
• 难度：⭐⭐⭐☆☆
• 场景：很多线下门店需要这个功能

8.2 自然语言处理应用项目

项目三：基于RAG的企业知识库问答系统

• 任务：上传企业文档，就能用自然语言提问，得到答案
• 步骤： 1. 文档上传和解析（支持PDF/Word/TXT） 2. 切分文档，存入向量数据库 3. 对接大模型API，实现问答 4. 做一个简单的Web界面
• 难度：⭐⭐⭐☆☆
• 价值：现在很多企业都需要，练手完就能接项目

项目四：中文新闻文本分类系统

• 任务：输入新闻文本，自动分类（科技/体育/娱乐/军事等）
• 步骤： 1. 下载公开新闻数据集 2. 用BERT预训练模型微调 3. 评估模型准确率 4. 部署成API服务
• 难度：⭐⭐☆☆☆
• 适合：入门练手，理解文本分类全流程

8.3 大模型应用项目

项目五：AI简历助手

• 功能：上传简历PDF，AI帮你分析简历优缺点，给出改进建议
• 用到技术：PDF解析 + RAG + 大模型API
• 难度：⭐⭐☆☆☆
• 非常实用，找工作自己就能用

项目六：AI客服机器人

• 功能：基于企业常见问题知识库，自动回答客户问题
• 用到技术：RAG + 大模型API + Web界面
• 难度：⭐⭐⭐☆☆
• 很多中小企业都需要，能直接卖钱

---

学习路线总结

1. 第一周：Python基础 + 环境搭建
2. 第二周：机器学习基础 + Scikit-learn实战
3. 第三周：深度学习导论 + PyTorch基础 + MNIST手写数字识别
4. 第四周：计算机视觉入门 + YOLO目标检测项目
5. 第五周：NLP入门 + Transformer预训练模型使用
6. 第六周：大模型API调用 + RAG实战，做一个完整应用

记住： 我们是应用开发快速入门，核心就是会用工具做项目，不用把所有数学公式都搞懂，先做起来，在做中学习，遇到问题再补理论。

---

常用学习资源推荐

• 免费课程：
• DeepLearning.AI 大模型专项课程（Coursera）
• 黄海广 《PyTorch深度学习实践》（B站）
• 李沐 《动手学深度学习》（免费在线书）
• 社区：
• GitHub：找开源项目，跟着学
• Hugging Face：预训练模型仓库
• 知乎：搜索AI相关问题
• 文档：
• Scikit-learn官方文档：https://scikit-learn.org/
• PyTorch官方文档：https://pytorch.org/
• Ultralytics YOLOv8文档：https://docs.ultralytics.com/

---

写在最后： 人工智能发展很快，不用等什么都学会了再动手，现在就选一个简单项目，动手做起来，做着做着就入门了。祝你学习顺利！