← 返回教育专区

AI 编程实战：从 Python 基础到大模型应用开发

掌握 AI 编程的核心工具链，动手构建你的第一个 AI 应用

一、AI 编程工具链

1.1 编程语言选择

语言在 AI 中的角色推荐度
PythonAI 开发的绝对主力，99% 的 AI 框架⭐⭐⭐⭐⭐
C/C++底层性能优化（PyTorch/TF 底层实现）⭐⭐⭐
JavaScript前端 AI 应用、ONNX.js⭐⭐
Rust新兴 AI 基础设施（Candle、Tokenizers）⭐⭐
Julia科学计算、数值模拟⭐⭐

结论：学 AI 编程，从 Python 开始。

1.2 开发环境搭建

推荐方案：

  • Anaconda（Python 环境管理）
  • VS Code + Python 扩展（代码编辑器）
  • Jupyter Notebook（交互式实验）
  • Google Colab（免费 GPU 云端环境）
    • # 安装 Anaconda 后创建 AI 开发环境
conda create -n ai-dev python=3.11
conda activate ai-dev

# 安装核心 AI 库
pip install torch torchvision torchaudio  # PyTorch
pip install transformers datasets          # Hugging Face
pip install openai                         # OpenAI API
pip install langchain                      # LLM 应用框架
pip install jupyter                        # Jupyter Notebook

二、Python AI 编程基础

2.1 NumPy — 数值计算基础

import numpy as np

# 创建矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵运算
C = A @ B           # 矩阵乘法
D = np.dot(A, B)    # 等价写法

# AI 中常用的操作
x = np.random.randn(100, 784)   # 100 个 784 维样本（如 MNIST 图片）
weights = np.random.randn(784, 128)  # 权重矩阵
bias = np.zeros(128)                  # 偏置

# 一层神经网络的前向传播
z = x @ weights + bias           # 线性变换
a = np.maximum(0, z)             # ReLU 激活

2.2 PyTorch — 深度学习框架

import torch
import torch.nn as nn

# PyTorch 张量（GPU 加速的矩阵）
x = torch.randn(100, 784)        # 100 个样本
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = x.to(device)                 # 移到 GPU

# 定义一个简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)   # 输入层 → 隐藏层
        self.fc2 = nn.Linear(128, 64)    # 隐藏层 → 隐藏层
        self.fc3 = nn.Linear(64, 10)     # 隐藏层 → 输出层(10类)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = SimpleNet().to(device)
print(f"模型参数量: {sum(p.numel() for p in model.parameters()):,}")

2.3 训练循环

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

# 训练循环
for epoch in range(10):
    model.train()
    for batch_x, batch_y in train_loader:
        batch_x, batch_y = batch_x.to(device), batch_y.to(device)
        
        # 前向传播
        outputs = model(batch_x)
        loss = criterion(outputs, batch_y)
        
        # 反向传播
        optimizer.zero_grad()   # 清空梯度
        loss.backward()         # 计算梯度
        optimizer.step()        # 更新参数
    
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

三、Hugging Face Transformers — 大模型应用

3.1 使用预训练模型

from transformers import pipeline

# 文本分类（情感分析）
classifier = pipeline("sentiment-analysis")
result = classifier("I love this product! It's amazing!")
print(result)  # [{'label': 'POSITIVE', 'score': 0.9998}]

# 文本生成
generator = pipeline("text-generation", model="gpt2")
result = generator("人工智能的未来是", max_length=50)
print(result[0]['generated_text'])

# 中文问答
qa = pipeline("question-answering", model="uer/roberta-base-finetuned-cmrc2018")

3.2 使用大语言模型 API

from openai import OpenAI

# 连接阿里 Qwen API（兼容 OpenAI 格式）
client = OpenAI(
    api_key="your-key",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 简单对话
response = client.chat.completions.create(
    model="qwen-plus",
    messages=[
        {"role": "system", "content": "你是一位Python编程导师"},
        {"role": "user", "content": "用简单的话解释什么是递归"}
    ]
)
print(response.choices[0].message.content)

四、LangChain — LLM 应用开发框架

4.1 构建 AI 对话链

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import StrOutputParser

# 初始化模型
llm = ChatOpenAI(
    model="qwen-plus",
    openai_api_key="your-key",
    openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位资深的{domain}专家，用通俗易懂的语言回答问题"),
    ("user", "{question}")
])

# 构建链
chain = prompt | llm | StrOutputParser()

# 调用
result = chain.invoke({
    "domain": "人工智能",
    "question": "什么是迁移学习？为什么它在实际应用中如此重要？"
})
print(result)

4.2 RAG（检索增强生成）

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA

# 1. 加载文档
loader = TextLoader("ai_textbook.txt")
docs = loader.load()

# 2. 切分文档
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

# 3. 创建向量数据库
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. 构建 RAG 链
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 5. 提问
result = qa({"query": "Transformer 的自注意力机制是如何工作的？"})
print(result['result'])

五、实战项目

项目 1：手写数字识别（CNN）

import torch
import torchvision
import torchvision.transforms as transforms

# 数据
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# 简单 CNN
class MNIST_CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(64 * 7 * 7, 10)
    
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        return self.fc(x)

项目 2：AI 聊天机器人

# 使用 Gradio 快速构建 Web 聊天界面
import gradio as gr
from openai import OpenAI

client = OpenAI(api_key="...", base_url="...")

def chat(message, history):
    messages = [{"role": "system", "content": "你是友好的AI助手"}]
    for h in history:
        messages.append({"role": "user", "content": h[0]})
        messages.append({"role": "assistant", "content": h[1]})
    messages.append({"role": "user", "content": message})
    
    response = client.chat.completions.create(model="qwen-plus", messages=messages)
    return response.choices[0].message.content

demo = gr.ChatInterface(chat, title="AI 聊天机器人")
demo.launch()

参考资源

← 返回教育专区