# 创建变量
name = "小明"        # 字符串 (文字)
age = 20             # 整数 (数字)
height = 1.75        # 浮点数 (带小数点的数字)
is_student = True    # 布尔值 (真/假)

print(name)          # 输出: 小明
print(age + 5)       # 输出: 25

# 条件判断示例
temperature = 28

if temperature > 30:
    print("太热了！开空调")
elif temperature > 20:
    print("天气真舒服")
else:
    print("有点冷，多穿点")

# for循环示例 - 遍历序列
fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits:
    print(f"我爱吃{fruit}")

# while循环示例 - 达到条件前重复
count = 0
while count < 5:
    print(f"这是第{count+1}次说你好")
    count += 1

# 定义函数：计算圆的面积
def circle_area(radius):
    area = 3.14 * radius * radius
    return area

# 使用函数
print(circle_area(5))  # 计算半径为5的圆面积

# 定义"汽车"类
class Car:
    # 初始化方法(给新车设置属性)
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
    
    # 类的方法(行为)
    def drive(self):
        print(f"{self.color}色的{self.brand}正在行驶")

# 使用类创建对象
my_car = Car("特斯拉", "黑")
my_car.drive()  # 输出: 黑色的特斯拉正在行驶

# 尝试打开一个不存在的文件
try:
    file = open("不存在的文件.txt", "r")
except FileNotFoundError:
    print("找不到文件！请检查文件名")

# 综合示例
# 购物清单（列表）
shopping_list = ["牛奶", "鸡蛋", "面包"]

# 商品价格（字典）
prices = {
    "牛奶": 15.5,
    "鸡蛋": 12.8,
    "面包": 8.0
}

# 计算总价
total = 0
for item in shopping_list:
    if item in prices:
        total += prices[item]

print(f"购物总价: {total}元")  # 输出: 购物总价: 36.3元

# 使用列表实现栈
stack = []
stack.append("第1盘")  # 放入
stack.append("第2盘")
top = stack.pop()      # 取出: "第2盘"

# 使用队列
from collections import deque
queue = deque()
queue.append("第1人")  # 排队
queue.append("第2人")
first = queue.popleft()  # 服务: "第1人"

# 简单查找 - O(n)
def simple_search(items, target):
    for item in items:
        if item == target:
            return True
    return False

# 二分查找（有序列表）- O(log n)
def binary_search(items, target):
    low, high = 0, len(items)-1
    while low <= high:
        mid = (low + high) // 2
        if items[mid] == target:
            return True
        elif items[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return False

def binary_search(items, target):
    # 起点和终点索引
    low, high = 0, len(items)-1
    
    while low <= high:
        # 计算中间位置
        mid = (low + high) // 2
        mid_value = items[mid]
        
        # 找到目标
        if mid_value == target:
            return mid
        
        # 目标在右侧
        elif mid_value < target:
            low = mid + 1
        
        # 目标在左侧
        else:
            high = mid - 1
    
    # 未找到
    return -1

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    
    pivot = arr[len(arr) // 2]  # 选择中间值作为基准
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    
    return quicksort(left) + middle + quicksort(right)

def fib(n):
    # 存储计算结果
    cache = [0, 1]  
    
    # 从2开始计算并存储结果
    for i in range(2, n+1):
        cache.append(cache[i-1] + cache[i-2])
    
    return cache[n]

print(fib(10))  # 输出: 55

def coin_change(coins, amount):
    # 排序硬币（从大到小）
    coins.sort(reverse=True)
    result = []
    
    # 尝试使用每个硬币
    for coin in coins:
        while amount >= coin:
            amount -= coin
            result.append(coin)
    
    return result

# 用最少硬币组成86分
coins = [1, 5, 10, 25]
print(coin_change(coins, 86))  # [25, 25, 25, 10, 1]

import numpy as np

# 创建2x2矩阵
matrix = np.array([[1, 2], 
                   [3, 4]])
                   
# 矩阵加法
matrix + 2  # 所有元素加2 → [[3,4],[5,6]]

# 矩阵乘法
np.dot(matrix, matrix)  # 矩阵自乘 → [[7,10],[15,22]]

# 在三维空间中的两个向量
vector_a = np.array([1, 2, 3])
vector_b = np.array([4, 5, 6])

# 向量的点积（投影）
dot_product = np.dot(vector_a, vector_b)  # 1×4 + 2×5 + 3×6 = 32

# 向量长度
length_a = np.linalg.norm(vector_a)  # √(1²+2²+3²) ≈ 3.74

# 求矩阵的特征值和特征向量
matrix = np.array([[2, 1],
                   [1, 2]])
                   
eigenvalues, eigenvectors = np.linalg.eig(matrix)

print("特征值:", eigenvalues)    # [3., 1.]
print("特征向量:\n", eigenvectors)  # [[ 0.707, -0.707], [0.707, 0.707]]

# 图像压缩示例（实际应用中）
from skimage import data
from skimage.transform import resize
import matplotlib.pyplot as plt

# 加载小图像
image = resize(data.astronaut(), (100, 100))
gray_image = np.mean(image, axis=2)

# 进行奇异值分解
U, s, VT = np.linalg.svd(gray_image, full_matrices=False)

# 仅保留前20个特征重建图像
k = 20
reconstructed = U[:, :k] @ np.diag(s[:k]) @ VT[:k, :]

# 显示压缩前后对比
fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.imshow(gray_image, cmap='gray')
ax1.set_title('原始图像')
ax2.imshow(reconstructed, cmap='gray')
ax2.set_title('压缩后图像 (SVD)')
plt.show()

import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import norm, binom, poisson

# 正态分布（高斯分布）
x = np.linspace(-5, 5, 100)
plt.plot(x, norm.pdf(x, 0, 1), label='正态分布')

# 二项分布（抛硬币）
n, p = 10, 0.5
x_binom = np.arange(0, 11)
plt.stem(x_binom, binom.pmf(x_binom, n, p), 'bo', label='二项分布')

# 泊松分布（罕见事件）
lambda_ = 3
x_poisson = np.arange(0, 10)
plt.stem(x_poisson, poisson.pmf(x_poisson, lambda_), 'g^', label='泊松分布')

plt.legend()
plt.title('常见概率分布')
plt.xlabel('数值')
plt.ylabel('概率密度')
plt.show()

# 计算贝叶斯概率
p_disease = 0.01      # P(D)
p_positive_given_disease = 0.99  # P(阳性|D)
p_negative_given_healthy = 0.95  # P(阴性|健康)

# P(阳性|健康) = 1 - P(阴性|健康)
p_positive_given_healthy = 1 - p_negative_given_healthy

# P(阳性) = P(阳性|D) * P(D) + P(阳性|健康) * P(健康)
p_positive = (p_positive_given_disease * p_disease) + (p_positive_given_healthy * (1-p_disease))

# P(D|阳性) = [P(阳性|D) * P(D)] / P(阳性)
p_disease_given_positive = (p_positive_given_disease * p_disease) / p_positive

print(f"检测阳性后真正患病的概率: {p_disease_given_positive*100:.2f}%")  # ≈16.2%

from scipy import stats

# 生成模拟数据（方差为10）
np.random.seed(42)
class_a = np.random.normal(78, 10, 30)
class_b = np.random.normal(82, 10, 30)

# 进行t检验
t_stat, p_value = stats.ttest_ind(class_a, class_b)

alpha = 0.05  # 显著性水平
if p_value < alpha:
    print(f"p值 = {p_value:.4f} < 0.05，两组有显著差异")
else:
    print(f"p值 = {p_value:.4f} >= 0.05，两组无显著差异")

from sklearn.linear_model import LinearRegression

# 样本数据（面积 vs 价格）
areas = np.array([50, 70, 90, 110, 130]).reshape(-1, 1)  # m²
prices = np.array([200, 240, 290, 340, 380])  # 万元

# 创建模型并拟合
model = LinearRegression()
model.fit(areas, prices)

# 预测80平米房子的价格
prediction = model.predict([[80]])
print(f"预测80平米房屋价格：{prediction[0]:.1f}万元")

# 绘制数据点及拟合线
plt.scatter(areas, prices, label='实际价格')
plt.plot(areas, model.predict(areas), 'r-', label='预测趋势')
plt.scatter([80], prediction, c='g', marker='*', s=200, label='预测点')
plt.xlabel('面积(m²)')
plt.ylabel('价格(万元)')
plt.legend()
plt.show()

# 某车辆的运动函数：位置 = 时间²
t = np.linspace(0, 5, 100)  # 0到5秒
position = t**2              # 位置函数

# 计算导数（速度）
# 导数的数值计算：dy/dx ≈ Δy/Δx
velocity = np.gradient(position, t)  # 2t

# 计算积分（总路程）
# 积分的数值计算（累加）
distance = np.cumsum(velocity * np.diff(t, prepend=0))

# 绘制结果
plt.figure(figsize=(10, 6))
plt.subplot(211)
plt.plot(t, position, 'b-', label='位置')
plt.plot(t, velocity, 'g--', label='速度(导数)')
plt.legend()
plt.title('位置与速度关系')

plt.subplot(212)
plt.plot(t, distance, 'r-', label='路程(积分)')
plt.legend()
plt.xlabel('时间(秒)')
plt.show()

from mpl_toolkits.mplot3d import Axes3D

# 创建时间和空间的网格
x = np.linspace(0, 10, 100)  # 空间坐标
t = np.linspace(0, 5, 100)    # 时间坐标
X, T = np.meshgrid(x, t)

# 温度函数：温度 = e^{-0.1t} * sin(x)
Z = np.exp(-0.1*T) * np.sin(X)

# 绘制3D温度场
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, T, Z, cmap='viridis')
ax.set_xlabel('位置(x)')
ax.set_ylabel('时间(t)')
ax.set_zlabel('温度(℃)')
ax.set_title('空间温度分布随时间变化')
plt.show()

# 定义一个山峰形状的函数
def mountain(x, y):
    return np.exp(-0.1*(x**2 + y**2)) * np.cos(0.5*x)

# 创建网格
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = mountain(X, Y)

# 计算梯度（下山方向）
gy, gx = np.gradient(Z)
skip = 5  # 显示部分箭头

# 绘制等高线图
plt.figure(figsize=(10, 8))
plt.contourf(X, Y, Z, 20, cmap='viridis')
plt.colorbar()
plt.quiver(X[::skip, ::skip], Y[::skip, ::skip], 
           -gx[::skip, ::skip], -gy[::skip, ::skip], 
           scale=50, color='white')  # 负梯度表示最陡下降方向
plt.title('地形梯度图 - 白色箭头指向最陡下降方向')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

# 正弦函数及其泰勒展开
x = np.linspace(-10, 10, 500)
sin_x = np.sin(x)

# 不同阶数的泰勒展开
taylor1 = x  # 1阶
taylor3 = x - x**3/6  # 3阶
taylor5 = taylor3 + x**5/120  # 5阶

# 绘制比较图
plt.figure(figsize=(10, 6))
plt.plot(x, sin_x, 'b-', lw=3, label='真实 sin(x)')
plt.plot(x, taylor1, 'g--', label='1阶展开')
plt.plot(x, taylor3, 'r-.', label='3阶展开')
plt.plot(x, taylor5, 'm:', lw=2, label='5阶展开')
plt.ylim(-3, 3)
plt.legend()
plt.title('泰勒级数逼近正弦函数')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid(True)
plt.show()

# 定义函数：f(x) = x^4 - 3x^3 + 2
def f(x):
    return x**4 - 3*x**3 + 2

# 导数：f'(x) = 4x^3 - 9x^2
def df(x):
    return 4*x**3 - 9*x**2

# 梯度下降
x = 2.0     # 初始点
lr = 0.01   # 学习率
steps = 50  # 迭代次数

# 记录路径
path = [x]

for i in range(steps):
    grad = df(x)
    x = x - lr * grad  # 向下走一步
    path.append(x)
    
# 绘制函数及下降路径
x_vals = np.linspace(-1, 3, 200)
plt.plot(x_vals, f(x_vals), 'b-', lw=2, label='f(x)')
plt.scatter(path, f(np.array(path)), c='r', marker='o')
for i in range(1, len(path)):
    plt.annotate('', xy=(path[i], f(path[i])), 
                xytext=(path[i-1], f(path[i-1])),
                arrowprops=dict(arrowstyle='->', color='r'))
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('梯度下降过程')
plt.grid(True)
plt.show()

from scipy.optimize import minimize

# 目标函数：f(x,y) = (x-1)² + (y-2.5)²
objective = lambda x: (x[0]-1)**2 + (x[1]-2.5)**2

# 约束条件：
# x - 2y >= -1    → 约束1
# -x - 2y >= -6   → 约束2
# -x + 2y >= -2   → 约束3
constraints = [
    {'type': 'ineq', 'fun': lambda x: x[0] - 2*x[1] + 1},  # ≥0
    {'type': 'ineq', 'fun': lambda x: -x[0] - 2*x[1] + 6},
    {'type': 'ineq', 'fun': lambda x: -x[0] + 2*x[1] + 2}
]

# 初始猜测
x0 = [0, 0]

# 求解
solution = minimize(objective, x0, constraints=constraints)
print(f"最小值点: ({solution.x[0]:.2f}, {solution.x[1]:.2f})")
print(f"最小值: {solution.fun:.4f}")

# 三种学习率策略
def constant_lr(epoch):  # 固定学习率
    return 0.1

def step_lr(epoch):     # 阶梯下降
    if epoch < 10:
        return 0.1
    elif epoch < 20:
        return 0.01
    else:
        return 0.001

def exp_lr(epoch):      # 指数衰减
    return 0.1 * (0.9 ** epoch)

# 绘制学习率变化曲线
epochs = range(1, 31)

plt.plot(epochs, [constant_lr(e) for e in epochs], 'b-o', label='固定学习率')
plt.plot(epochs, [step_lr(e) for e in epochs], 'r-s', label='阶梯衰减')
plt.plot(epochs, [exp_lr(e) for e in epochs], 'g-^', label='指数衰减')
plt.xlabel('训练轮次(epoch)')
plt.ylabel('学习率')
plt.title('不同学习率策略比较')
plt.legend()
plt.grid(True)
plt.show()

# 简单线性回归示例
import numpy as np
from sklearn.linear_model import LinearRegression

# 房子面积数据（平方米）
house_sizes = np.array([50, 70, 90, 110]).reshape(-1, 1)
# 对应房价（万元）
prices = np.array([300, 400, 500, 600])

# 创建模型并训练
model = LinearRegression()
model.fit(house_sizes, prices)

# 预测120平房子的价格
prediction = model.predict([[120]])
print(f"预测房价: {prediction[0]:.1f}万元")  # 输出: 预测房价: 700.0万元

# 垃圾邮件识别示例
from sklearn.linear_model import LogisticRegression

# 假设有以下特征：
# feature1: 邮件包含"免费"次数
# feature2: 邮件包含"获奖"次数
X_train = [[3, 1], [5, 2], [1, 0], [0, 1]]  # 训练数据
y_train = [1, 1, 0, 0]  # 1=垃圾邮件，0=正常邮件

# 创建模型并训练
spam_detector = LogisticRegression()
spam_detector.fit(X_train, y_train)

# 预测新邮件
new_email = [[4, 3]]  # 包含4次"免费"，3次"获奖"
prediction = spam_detector.predict(new_email)
print("垃圾邮件" if prediction[0] == 1 else "正常邮件")  # 输出: 垃圾邮件

# 客户分群示例
from sklearn.cluster import KMeans
import numpy as np

# 假设有两种客户特征：购买频率和平均客单价
customer_data = np.array([
    [1, 100],   # 客户1
    [5, 500],   # 客户2
    [1, 150],   # 客户3
    [6, 550]    # 客户4
])

# 创建K=2的聚类模型
kmeans = KMeans(n_clusters=2)
kmeans.fit(customer_data)

# 查看分群结果
print("客户分群结果:", kmeans.labels_)
# 可能输出: [0, 1, 0, 1] 表示分成两组

# PCA降维示例
from sklearn.decomposition import PCA
import numpy as np

# 创建一些三维数据
data = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
    [10, 11, 12]
])

# 创建PCA模型，降到二维
pca = PCA(n_components=2)
reduced_data = pca.fit_transform(data)

print("降维后数据:")
print(reduced_data)

# 交叉验证示例
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

# 创建模型
model = RandomForestClassifier()

# 使用5折交叉验证
scores = cross_val_score(model, X, y, cv=5)

print(f"交叉验证得分: {scores}")
print(f"平均准确率: {scores.mean():.2f}")

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 7]
}

grid_search = GridSearchCV(RandomForestClassifier(), param_grid, cv=5)
grid_search.fit(X_train, y_train)

print("最佳参数组合:", grid_search.best_params_)

from sklearn.model_selection import RandomizedSearchCV

param_dist = {
    'n_estimators': range(50, 500, 50),
    'max_depth': range(3, 15)
}

random_search = RandomizedSearchCV(RandomForestClassifier(), 
                                 param_dist, 
                                 n_iter=20, 
                                 cv=5)
random_search.fit(X_train, y_train)

# 单个神经元的工作代码
def 神经元(输入信号, 权重, 偏置):
    weighted_sum = sum(输入信号 * 权重) + 偏置  # 加权求和
    return 激活函数(weighted_sum)           # 非线性转换

from keras.models import Sequential
from keras.layers import Dense

# 搭建流水线
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,))) # 首层需指定输入尺寸
model.add(Dense(256, activation='relu'))     # 隐藏层2
model.add(Dense(128, activation='relu'))     # 隐藏层3
model.add(Dense(10, activation='softmax'))   # 输出层(10个数字概率)

# 配置生产线
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 开始训练(使用MNIST数据集)
model.fit(x_train, y_train, epochs=10)

# 测试效果
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"识别准确率: {test_acc*100:.1f}%")  # 典型结果：98.2%

import numpy as np
from PIL import Image

# 加载一张猫咪图片
image = Image.open("cat.jpg")
pixel_data = np.array(image)

print(f"图片尺寸: {pixel_data.shape}")  # 例如 (480, 640, 3)
print("左上角像素值:", pixel_data[0, 0])  # 例如 [255, 200, 150]

原始图像： [1 1 1 0 0]
卷积核：   [1 0 -1]
结果：     [ (1 * 1)+(1 * 0)+(1*(-1)) = 0 ]
           [ (1 * 1)+(1 * 0)+(0*(-1)) = 1 ] → 边缘检测！

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, 3) # 3通道输入, 32个卷积核, 3x3大小
        self.pool = nn.MaxPool2d(2, 2)  # 2x2池化
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.fc1 = nn.Linear(64 * 54 * 54, 10) # 全连接层
        
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = torch.flatten(x, 1) # 展平
        x = self.fc1(x)
        return x

# 使用预训练YOLOv5模型检测物体
import torch
model = torch.hub.load('ultralytics/yolov5', 'yolov5s')  # 加载模型
results = model('street.jpg')  # 推理
results.print()  # 显示结果
results.save()   # 保存标注图像

from stylegan2 import generate_faces
generated_images = generate_faces(num=4)  # 生成4张人脸

import albumentations as A  # 强大的数据增强库

transform = A.Compose([
    A.RandomRotate30(),       # 随机旋转
    A.HorizontalFlip(p=0.5), # 水平翻转
    A.RGBShift(),             # 颜色偏移
    A.Normalize()             # 标准化
])

from torchvision import models

# 加载预训练ResNet
model = models.resnet50(pretrained=True)

# 替换最后一层
model.fc = nn.Linear(2048, 10)  # 适配新任务的10分类

import jieba  # 中文分词库

text = "自然语言处理让计算机理解人类语言"
words = jieba.cut(text)

print("分词结果:", "/".join(words))
# 输出: 自然/语言/处理/让/计算机/理解/人类/语言

词典: ["apple", "banana", "orange"]
编码:
    apple: [1, 0, 0]
    banana: [0, 1, 0]
    orange: [0, 0, 1]

from gensim.models import Word2Vec

# 训练词向量模型
sentences = [["自然", "语言", "处理"], ["机器", "学习", "算法"]]
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1)

# 获取词向量
vector = model.wv["语言"]
print(f"语言'的词向量维度: {vector.shape}")  # (100,)

# 计算相似度
similarity = model.wv.similarity("语言", "处理")
print(f"语言'与'处理'的语义相似度: {similarity:.2f}")

from transformers import pipeline

# 使用预训练情感分析模型
classifier = pipeline("sentiment-analysis")
result = classifier("这家餐厅的服务太棒了，食物也很美味！")

print(result)  
# [{'label': 'POSITIVE', 'score': 0.998}]

from transformers import MarianMTModel, MarianTokenizer

# 中译英
model_name = "Helsinki-NLP/opus-mt-zh-en"
tokenizer = MarianTokenizer.from_pretrained(model_name)
model = MarianMTModel.from_pretrained(model_name)

text = "自然语言处理正在改变世界"
translated = model.generate(**tokenizer(text, return_tensors="pt"))
output = tokenizer.decode(translated[0], skip_special_tokens=True)

print(output)  # "Natural language processing is changing the world"

from transformers import GPT2LMHeadModel, GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")

input_text = "在未来的世界里，人工智能"
input_ids = tokenizer.encode(input_text, return_tensors="pt")

# 生成文本
output = model.generate(
    input_ids, 
    max_length=100,
    num_return_sequences=1
)

print(tokenizer.decode(output[0], skip_special_tokens=True))

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 加载预训练模型和分词器
model_name = "bert-base-chinese"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

# 文本处理
inputs = tokenizer("NLP让计算机理解人类语言", return_tensors="pt")

# 模型推理
outputs = model(**inputs)

# CNN图像分类示例 - PyTorch
import torch
import torchvision
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_set = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)

class CNNClassifier(nn.Module):
    def __init__(self):
        super(CNNClassifier, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(2)
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(64 * 8 * 8, 512)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = self.flatten(x)
        x = self.relu3(self.fc1(x))
        x = self.fc2(x)
        return x

model = CNNClassifier()

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    running_loss = 0.0
    for i, (images, labels) in enumerate(train_loader, 0):
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.4f}')

print('训练完成!')