2026年安徽省大数据与人工智能应用竞赛基础知识分享
为了备战竞赛，在这里分享交流一下2026年安徽省大数据与人工智能应用竞赛基础知识。
！！！免责声明：本文是根据竞赛各模块要求，再结合一些例题，并且因为拿不到例题数据集，所以数据集我就用我自己找的，对例题进行些微修改后的代码，代码全程用大模型辅助，但是我后面会写代码详解！！！
1、竞赛主体内容（人工智能赛道“本科软件组”）
一、人工智能基础环境搭建部署（10 分）
二、样本数据预处理（30 分）
三、传统机器学习算法设计及应用（20 分）
四、深度学习算法设计及应用（20 分）
五、人工智能技术综合应用（20 分）
2、竞赛内容
分为基础环境搭建部署、样本数据预处理、传统机器学习算法设计及应用、深度学习算法设计及应用、人工智能技术综合应用五大模块，具体要求如下：
1. 人工智能基础环境搭建部署
参赛选手根据题目要求完成指定版本的人工智能相关开发环境的部署，包括但不限于 Anaconda、深度学习库 PyTorch、TensorFlow，并能够根据要求对部署的框架导入需要的相关库，包含但不限于 sklearn，opencv。
2. 样本数据预处理
对给定的样本数据（图片、文本或者数值数据），检测和去除数据集中的噪声数据、重复数据和无关数据，处理遗漏数据，去除空白数据域，标准化、归一化、二元化数据以及特征提取等处理。
3. 传统机器学习算法设计及应用
典型传统机器学习算法的设计应用。包含但不限于逻辑回归、支持向量机、决策树、Kmeans 等，根据题目或场景，通过选用机器学习算法利用 Sklearn 或者其它机器学习框架训练模型，实现分类、回归、聚类算法并解决问题。
4. 深度学习算法设计及应用
包括但不限于卷积神经网络、循环神经网络、对抗生成网络、强化学习算法等。根据题目或场景，通过选用深度学习相关算法，实现如图像、语音、文本分析等结构化 / 非结构化数据的识别检测等。
5. 人工智能技术综合应用
给定现实场景和数据集，综合运用人工智能相关技术解决给定问题。
注意事项
1.比赛是组队形式，最多三个人，题目是5道，比赛开始是三个人分别作答，推荐能力强的写难的，能力差的写点简单的，能帮人分担一点是一点。
2.各题目之间没有影响，但是在答题过程当中需要第三方库相近，有的第三方库版本不一样导致语法不一样，这个需要注意。
3.决赛会在主办方的机房当中，机房电脑配置不高，但是跑神经网络应该够用。
4.竞赛是开卷，开卷，开卷，只能带纸质资料，不能带电子版，不过可以带自己打印的资料，印多少都可以，你甚至可以猜题然后把代码打印出来，看运气好不好，运气好直接抄代码，不过数据集还是要改成决赛的
5.比赛分为网络赛和决赛，网络赛环境自己搭建，决赛用主办方电脑，环境需要重新配。
6.一定要把按照要求将代码，结果复制到需要提交的文件夹当中
3、模块一：人工智能基础环境搭建部署
内容：参赛选手根据题目要求完成指定版本的人工智能相关开发环境的部署，包括但不限于Anaconda、深度学习库PyTorch，并能够根据要求对部署的框架导入需要的相关库，包含但不限于sklearn， opencv。
这里我们不知道我们电脑上的平台是什么样子的，但是大概率是在Linux系统上，而且是离线安装，所以我们按照安装Linux版本的离线安装包来操作。
全部离线包下载地址（直接浏览器打开下载）
这个自己在网上找对应版本的而且都是要相互兼容的离线安装包真的非常麻烦，我也会直接把所有安装包和数据集都上传的
1. Anaconda3（Python 3.8）
文件名： Anaconda3-2020.11-Linux-x86_64.sh
下载地址（清华）：
https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.11-Linux-x86_64.sh2. scikit-learn（Python3.8 Linux）
文件名：scikit_learn-1.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
下载地址：
https://pypi.org/project/scikit-learn/1.0.2/#files
3. OpenCV 3.X（3.4.10，Python3.8 Linux）
文件名： opencv_python-3.4.10.37-cp38-cp38-manylinux2014_x86_64.whl
下载地址：
https://pypi.org/project/opencv-python/3.4.10.37/#files
4. PyTorch 1.8.1（CPU 版，Python3.8 Linux）
文件名： torch-1.8.1+cpu-cp38-cp38-linux_x86_64.whl
下载地址：
https://download.pytorch.org/whl/torch_stable.html
5. torchvision 0.9.1（CPU 版，Python3.8 Linux）
文件名：torchvision-0.9.1+cpu-cp38-cp38-linux_x86_64.whl
下载地址：
https://download.pytorch.org/whl/cpu/torchvision-0.9.1%2Bcpu-cp38-cp38-linux_x86_64.whl6. TensorFlow 2.8.0（Python3.8 Linux）
文件名： tensorflow-2.8.0-cp38-cp38-manylinux2010_x86_64.whl
下载地址：
https://pypi.org/project/tensorflow/2.8.0/#files
最后放到一个文件夹当中
Windows文件传输到Linux当中
我们正常在Linux下载完全不用这么麻烦，直接联网下载就行了
不同于Windows的
pip install 下载链接Linux 里下载是
wget 下载链接而Linux下载这些离线包有不一样的步骤
那么首先我们就要把这些安装包传输到Linux当中
在传输之前，我们再弄一个PyCharm到Linux里面
https://www.jetbrains.com/pycharm/download/other/这里我要说一个坏消息，就是PyCharm现在没有社区版了，现在下载的2025年以后的都是免费，但是2025年以前的都不能下载到community版本了，只能用2025年以后的（不过我个人觉得，新版的代码联想功能真的好用，TAB，TAB就完了。）
这里都是专业版，要收费的
我们下载一个2025年以后的就行
记得和之前文件夹放一起这样就只要传一次
然后我们打开我们的虚拟机终端，新建一个share文件夹
mkdir -p /home/share知识点：ll是Linux系统的查询语。
然后我们要知道自己的ip，可以通过以下代码查询
ifconfig
然后我们可以通过Windows终端将文件夹传到Linux
scp -r "D:\py项目\大数据与人工智能应用竞赛\Task1" root@192.168.253.110:/home/share/scp -r "你的文件夹" （你的用户名如：root）@（你的ip地址如：192.168.253.110）:/home/share/（你想放的地址）
然后红框部分会让你输入密码，记住了，这个密码是不显示的，输完按回车就行。
任务1：Anaconda 3、scikit-learn、OpenCV 3.X、PyTorch 1.8.X、torchvision 0.9.X库的安装与配置。
一、先进入你的安装包目录
cd /home/share/Task1确认所有文件都在：
ll
二、安装 Anaconda3
赋予执行权限
chmod +x Anaconda3-2020.11-Linux-x86_64.sh开始安装
./Anaconda3-2020.11-Linux-x86_64.sh知识点：Linux系统运行 .sh 脚本文件都按照以下格式
chmod +x 文件名.sh
./文件名.sh运行以后一直回车到需要输入‘yes’or‘no’
然后继续回车
这个界面就是正在下载anaconda了
这里是最后步骤，是否希望安装程序通过运行 conda init 来初始化 Anaconda3？，这里选择yes，然后系统会自动修改 ~/.bashrc，配置环境变量，下次打开终端直接可以用 conda 命令
下载完成以后，执行以下命令验证安装是否成功：
# 刷新终端配置
source ~/.bashrc
# 查看 conda 版本
conda --version
# 查看 Python 版本
python --version
三、离线安装所有依赖库
1. 安装 scikit-learn
pip install scikit_learn-1.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl2. 安装 OpenCV
pip install opencv_python-3.4.10.37-cp38-cp38-manylinux2014_x86_64.whl3. 安装 PyTorch
pip install torch-1.8.1+cpu-cp38-cp38-linux_x86_64.whl4.安装 torchvision
pip install torchvision-0.9.1+cpu-cp38-cp38-linux_x86_64.whl四、验证所有库是否安装成功
python -c "import sklearn, cv2, torch, torchvision; print('scikit-learn:', sklearn.__version__); print('OpenCV:', cv2.__version__); print('PyTorch:', torch.__version__); print('torchvision:', torchvision.__version__)"
输出了所有版本号，说明安装成功！
五、运行任务脚本 task1_1.py
1. 先找到脚本路径
先cd进入正确的目录
cd /data/task1/2. 运行脚本
python task1_1.py这里我没有这个脚本，但是我猜这个脚本就是输出所有版本号。
4、准备工作
我们先安装一个PyCharm
解压压缩包
tar -zxvf pycharm-2025.1.6.tar.gz到/bin目录下
cd pycharm-2025.1.6/bin运行PyCharm
./pycharm.sh
然后就是同意下一步就行
我们新建一个项目
找到你的 Anaconda 路径：/root/anaconda3/bin/python
我真要吐槽一下Linux的PyCharm，这个显示是3.14，实际上是3.8.5
后面识别对了他会自动改回Python3.8，不管它显示问题
PyCharm好了，这里我们看一下样题，因为我没有这个数据集，所以我得根据我有的数据集把题目改一下，然后一起上传到Linux当中，省的麻烦了
模块二：样本数据预处理
这个需要信用卡违约数据集，要8列特征，第9列标签，然后age有异常值，还要有缺失值。
我直接从kaggle数据集网站弄了一个相似的。
这个是从100张图像当中，找到与目标img.jpg最相似的，所以我直接下载100张图片，然后挑一张直接给豆包生成一张类似的作为img.jpg，甚至带着豆包的水印我懒得p了
模块三：传统机器学习算法设计及应用
这个数据集要求不高，直接让代码随机生成就行
模块四：深度学习算法设计及应用
这里我也没有猫和狗的数据集，但是我准备用巴旦木和白萝卜的图片作为数据集。
模块五：人工智能技术综合应用
这个数据集我也是在kaggle上面找的，然后自己分为train.txt和test.txt
OK，所有的数据集已经收集完毕了，然后传到Linux当中，我们就可以开始写代码了
scp -r "D:\py项目\大数据与人工智能应用竞赛\Task2" "D:\py项目\大数据与人工智能应用竞赛\Task3" "D:\py项目\大数据与人工智能应用竞赛\Task4" "D:\py项目\大数据与人工智能应用竞赛\Task5" root@192.168.253.110:/home/share/
ll /home/share/这里我们可以看到文件都已经成功上传了
然后打开终端运行PyCharm
先找到PyCharm路径
sudo find / -name "pycharm.sh" 2>/dev/null
然后进入bin目录下
cd /home/share/Task1/pycharm-2025.1.6/bin赋予执行权限
chmod +x pycharm.sh启动 PyCharm
./pycharm.sh
然后新建一个项目
然后将Task文件夹导入到项目里
cp -r /home/share/Task* ~/PycharmProjects/exam/查看有没有成功
ls ~/PycharmProjects/exam/
之后就可以在Linux系统当中写代码了。
我因为Linux如果要输入中文要麻烦一点，所以后续代码我就在Windows的PyCharm当中演示。
5、模块二：样本数据预处理
完整代码
import pandas as pd
import numpy as np
df = pd.read_csv('Task2/task2_data.csv')
# 计算age列有效数值（18~100岁）的中位数
valid_age = df[(df['age'] >= 18) & (df['age'] <= 100)]['age']
age_median = valid_age.median()
# 替换异常值（<18或>100）为中位数
df['age'] = df['age'].apply(lambda x: age_median if x < 18 or x > 100 else x)
# 打印age列中位数
print(f"age列有效数值中位数：{age_median}")
# 计算各列缺失值占比
missing_ratio = (df.isnull().sum() / len(df)) * 100
# 缺失值占比超过10%的列 → 删除包含缺失值的行
high_missing_cols = missing_ratio[missing_ratio > 10].index.tolist()
if high_missing_cols:
df = df.dropna(subset=high_missing_cols)
# 缺失值占比≤10%的列 → 用平均值填充
low_missing_cols = missing_ratio[(missing_ratio > 0) & (missing_ratio <= 10)].index.tolist()
low_missing_cols = [col for col in low_missing_cols if col in df.columns]
for col in low_missing_cols:
mean_val = df[col].mean()
df[col] = df[col].fillna(mean_val)
# 区分特征列（前8列）和标签列（第9列）
feature_cols = df.columns[:-1] # 特征列
label_col = df.columns[-1] # 标签列
# 对特征列进行0~1归一化
for col in feature_cols:
col_min = df[col].min()
col_max = df[col].max()
if col_max != col_min:
df[col] = (df[col] - col_min) / (col_max - col_min)
else:
df[col] = 0.0
df.to_csv('task2_1_result.csv', index=False, encoding='utf-8')
print("数据处理完成，结果已保存为 task2_1_result.csv")代码详解
import pandas as pd
import numpy as np
df = pd.read_csv('Task2/task2_data.csv')导入必要库并读取文件
# 计算age列有效数值（18~100岁）的中位数
valid_age = df[(df['age'] >= 18) & (df['age'] <= 100)]['age']
age_median = valid_age.median()
# 替换异常值（<18或>100）为中位数
df['age'] = df['age'].apply(lambda x: age_median if x < 18 or x > 100 else x)
# 打印age列中位数
print(f"age列有效数值中位数：{age_median}")从数据框 df 中筛选出 age 列中满足 18 ≤ 年龄 ≤ 100 的数据，然后对筛选后的年龄数据计算中位数，遍历 age 列的每一个值，将小于 18 或大于 100 的异常值替换为中位数。
lambda x：临时匿名函数，x 代表每一个年龄值，这个函数的判断规则是如果 x < 18 或 x > 100则替换成中位数 age_median
apply()：对每一个数据执行自定义函数
最终把处理好的整列重新赋值给 df['age']
missing_ratio = (df.isnull().sum() / len(df)) * 100统计数据框中每一列缺失值的百分比。
df.isnull()：判断数据中每个值是否为缺失值，返回布尔矩阵
.sum()：对每列的缺失值进行计数
/ len(df)：除以总行数，得到缺失值比例
* 100：转为百分比形式，便于判断阈值
high_missing_cols = missing_ratio[missing_ratio > 10].index.tolist()然后筛选缺失值占比超过 10% 的列。
missing_ratio > 10：布尔索引，筛选出超过 10% 的列
.index：获取这些列的列名
.tolist()：转为列表格式，方便后续使用
if high_missing_cols:
df = df.dropna(subset=high_missing_cols)再删除高缺失值列中包含缺失值的行
if high_missing_cols：判断是否存在高缺失值列
dropna(subset=...)：只在指定列中检查缺失值，并删除对应行
low_missing_cols = missing_ratio[(missing_ratio > 0) & (missing_ratio <= 10)].index.tolist()找出有缺失但占比 ≤10% 的列。
low_missing_cols = [col for col in low_missing_cols if col in df.columns]过滤掉前面步骤中已被删除的列，避免报错。
for col in low_missing_cols:
mean_val = df[col].mean()
df[col] = df[col].fillna(mean_val)对缺失较少的列，用该列的平均值填充缺失值。
df[col].mean()：计算当前列的平均值
fillna(mean_val)：将所有缺失值替换为平均值
feature_cols = df.columns[:-1] # 特征列
label_col = df.columns[-1] # 标签列区分特征列与标签列
df.columns[:-1]：取除最后一列外的所有列（前 8 列客户特征）
df.columns[-1]：取最后一列（是否拖欠还款的标签）
for col in feature_cols:
col_min = df[col].min()
col_max = df[col].max()遍历所有特征列,获取每列的最大值和最小值,用于 0~1 归一化公式计算.
if col_max != col_min:
df[col] = (df[col] - col_min) / (col_max - col_min)
else:
df[col] = 0.0把所有特征值缩放到 0 ~ 1 之间
公式：归一化数值 = (原始值 − 最小值) / (最大值 − 最小值)
df.to_csv('task2_1_result.csv', index=False, encoding='utf-8')保存处理好的数据
运行结果
import cv2
import numpy as np
import os
# ===================== 路径配置 =====================
img_template_path = r"Task2/image_data/img.jpg"
data_folder = r"Task2/image_data/data"
# ===================== SIFT + 优质匹配 =====================
sift = cv2.SIFT_create()
bf = cv2.BFMatcher(cv2.NORM_L2)
# 读取模板图
img_template = cv2.imread(img_template_path, cv2.IMREAD_GRAYSCALE)
kp_template, des_template = sift.detectAndCompute(img_template, None)
match_results = []
# ===================== 遍历所有图片（使用优质匹配） =====================
print("===== 每张图片与img.jpg的相似特征点个数 =====")
for filename in os.listdir(data_folder):
if filename.endswith('.jpg'):
img_path = os.path.join(data_folder, filename)
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
kp, des = sift.detectAndCompute(img, None)
# 核心修复：使用 knn 匹配 + 比例测试，只保留优质匹配点
matches = bf.knnMatch(des_template, des, k=2)
good_matches = []
for m, n in matches:
if m.distance < 0.75 * n.distance: # 只留好的匹配
good_matches.append(m)
match_count = len(good_matches)
match_results.append((filename, match_count))
print(f"图片: {filename}与img.jpg 相似特征点个数：{match_count}")
# ===================== 找最相似图片 =====================
match_results.sort(key=lambda x: x[1], reverse=True)
best_img_name, best_match_count = match_results[0]
print(f"最相似的图片是：{best_img_name}，匹配特征点个数：{best_match_count}")
# ===================== 拼接融合 =====================
best_img_path = os.path.join(data_folder, best_img_name)
best_img = cv2.imread(best_img_path)
img_original = cv2.imread(img_template_path)
combined_img = np.hstack((img_original, best_img))
cv2.imwrite("拼接结果.jpg", combined_img)
print("\n图像拼接完成，已保存为：拼接融合结果.jpg")
# 显示
cv2.imshow("result", combined_img)
cv2.waitKey(0)
cv2.destroyAllWindows()代码详解
import cv2
import numpy as np
import os
# ===================== 路径配置 =====================
img_template_path = r"Task2/image_data/img.jpg"
data_folder = r"Task2/image_data/data"导入第三方库，100张图片文件夹，和需要匹配的图img.jpg
# ===================== SIFT + 优质匹配 =====================
sift = cv2.SIFT_create()
bf = cv2.BFMatcher(cv2.NORM_L2)1.创建 SIFT 特征检测器
SIFT_create()：初始化 SIFT 算法，用于提取图像关键点和特征描述子
2.创建匹配器
BFMatcher：用于对比两幅图的特征
NORM_L2：使用欧氏距离衡量特征相似度
# 读取模板图
img_template = cv2.imread(img_template_path, cv2.IMREAD_GRAYSCALE)
kp_template, des_template = sift.detectAndCompute(img_template, None)
match_results = []1.读取并灰度化模板图：
2.提取 SIFT 关键点：
kp_template：关键点（位置、大小、方向）
des_template：128 维特征（匹配核心依据）
3.创建结果列表：
match_results：存储每张图片的文件名 + 匹配点数
# ===================== 遍历所有图片（使用优质匹配） =====================
print("===== 每张图片与img.jpg的相似特征点个数 =====")
for filename in os.listdir(data_folder):
if filename.endswith('.jpg'):
img_path = os.path.join(data_folder, filename)
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
kp, des = sift.detectAndCompute(img, None)
# 核心：knn匹配 + 比例过滤，只保留优质匹配点
matches = bf.knnMatch(des_template, des, k=2)
good_matches = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good_matches.append(m)
match_count = len(good_matches)
match_results.append((filename, match_count))
print(f"图片: {filename}与img.jpg 相似特征点个数：{match_count}")1.遍历 data 文件夹所有.jpg 图片，逐个读取并转为灰度图
2.对每张图提取 SIFT 特征
3.KNN 匹配 + 比率测试（精准匹配核心）
knnMatch(k=2)：为每个特征找2 个最佳匹配
0.75比率过滤：只保留高质量匹配点，剔除错误匹配
4.统计优质匹配点数量，匹配点越多，表示图片越相似
# ===================== 找最相似图片 =====================
match_results.sort(key=lambda x: x[1], reverse=True)
best_img_name, best_match_count = match_results[0]
print(f"最相似的图片是：{best_img_name}，匹配特征点个数：{best_match_count}")1.按匹配点数量降序排序。匹配点最多的图片排在第一位
2.取出最相似图片
3.输出最相似图片名称与匹配点数
# ===================== 拼接融合 =====================
best_img_path = os.path.join(data_folder, best_img_name)
best_img = cv2.imread(best_img_path)
img_original = cv2.imread(img_template_path)
combined_img = np.hstack((img_original, best_img))
cv2.imwrite("拼接结果.jpg", combined_img)
print("\n图像拼接完成，已保存为：拼接结果.jpg")
# 显示
cv2.imshow("result", combined_img)
cv2.waitKey(0)
cv2.destroyAllWindows()1.读取模板图与最佳匹配图
2.水平拼接两张图，np.hstack()：左右拼接成一张图
3.保存拼接结果
4.显示最终效果
运行结果
6、模块三：传统机器学习算法设计及应用
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
df = pd.read_csv('Task3/task3.csv')
X = df.values
# 数据标准化（PCA必须）
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# ===================== 2. PCA降维到2维并可视化 =====================
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
# 绘制降维后原始数据
plt.figure(figsize=(8, 6))
plt.scatter(X_pca[:, 0], X_pca[:, 1], s=5, alpha=0.6, color='blue')
plt.title('PCA', fontsize=14)
plt.xlabel('x')
plt.ylabel('y')
plt.grid(alpha=0.3)
plt.show()
# ===================== 3. K-means聚类（聚为4类） =====================
kmeans = KMeans(n_clusters=4, random_state=42)
labels = kmeans.fit_predict(X_pca)
# ===================== 4. 聚类结果可视化（4种不同颜色） =====================
plt.figure(figsize=(8, 6))
colors = ['red', 'green', 'blue', 'orange']
for i in range(4):
plt.scatter(
X_pca[labels == i, 0],
X_pca[labels == i, 1],
c=colors[i],
s=5,
alpha=0.6,
label=f'{i+1}'
)
plt.title('K-means', fontsize=14)
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(alpha=0.3)
plt.show()代码详解
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
df = pd.read_csv('Task3/task3.csv')
X = df.values1.导入所需工具库
2.读取数据集 pd.read_csv：
读取 task3.csv 数据文件
df.values：将数据转为纯数值数组，方便后续算法处理
# 数据标准化（PCA必须）
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# PCA降维到2维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
# 绘制降维后原始数据
plt.figure(figsize=(8, 6))
plt.scatter(X_pca[:, 0], X_pca[:, 1], s=5, alpha=0.6, color='blue')
plt.title('PCA', fontsize=14)
plt.xlabel('x')
plt.ylabel('y')
plt.grid(alpha=0.3)
plt.show()1.数据标准化：
PCA 对数据量纲非常敏感，必须先标准化
StandardScaler 将数据变为均值为 0、方差为 1 的标准分布
2.PCA 降维：
PCA(n_components=2)：创建 PCA 模型，目标降为 2 维
fit_transform：对数据执行降维
输出 X_pca 是二维数组，可直接画图
3.PCA 结果可视化：
plt.scatter：绘制二维散点图
蓝色点表示降维后的所有样本
kmeans = KMeans(n_clusters=4, random_state=42)
labels = kmeans.fit_predict(X_pca)1.创建 K-means 模型
n_clusters=4：指定聚为 4 类（题目要求）
random_state=42：保证结果可复现
2.执行聚类
fit_predict(X_pca)：对降维后的二维数据进行聚类
返回 labels：每个样本的类别编号（0、1、2、3）
plt.figure(figsize=(8, 6))
colors = ['red', 'green', 'blue', 'orange']
for i in range(4):
plt.scatter(
X_pca[labels == i, 0],
X_pca[labels == i, 1],
c=colors[i],
s=5,
alpha=0.6,
label=f'{i+1}'
)
plt.title('K-means', fontsize=14)
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(alpha=0.3)
plt.show()1.设置 4 种颜色
红、绿、蓝、橙分别代表 4 个类别
2.按类别绘制散点图
X_pca[labels == i]：筛选出第 i 类的所有样本
每类使用不同颜色
label 显示类别编号（1、2、3、4）
3.图表设置
显示标题、坐标轴、图例、网格
最终输出一张4 色分类效果图，清晰展示聚类结果
运行结果
7、模块四：深度学习算法设计及应用
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
# ---------------------- 1. 超参数 ----------------------
batch_size = 16
image_size = 225
learning_rate = 0.01
weight_decay = 0.001
epochs = 10
# ---------------------- 2. 图像预处理 ----------------------
train_transform = transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
test_transform = transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# ---------------------- 3. 加载你的巴旦木 & 白萝卜数据集 ----------------------
train_path = r"D:\py项目\PythonProject2\Task4\train"
test_path = r"D:\py项目\PythonProject2\Task4\test"
train_dataset = datasets.ImageFolder(train_path, transform=train_transform)
test_dataset = datasets.ImageFolder(test_path, transform=test_transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
print("训练集类别：", train_dataset.classes)
print("训练集样本数：", len(train_dataset))
print("测试集样本数：", len(test_dataset))
# ---------------------- 4. 自己搭建的纯CNN模型（无警告） ----------------------
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(64 * 28 * 28, 128)
self.fc2 = nn.Linear(128, 1)
self.sigmoid = nn.Sigmoid()
self.relu = nn.ReLU()
def forward(self, x):
x = self.pool(self.relu(self.conv1(x)))
x = self.pool(self.relu(self.conv2(x)))
x = self.pool(self.relu(self.conv3(x)))
x = x.flatten(1)
x = self.relu(self.fc1(x))
x = self.fc2(x)
x = self.sigmoid(x)
return x
model = Net()
# ---------------------- 5. 损失函数 & 优化器 ----------------------
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
# ---------------------- 6. 训练 ----------------------
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
for epoch in range(epochs):
model.train()
train_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.float().unsqueeze(1).to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item() * images.size(0)
train_loss = train_loss / len(train_dataset)
# 测试
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
predicted = (outputs > 0.5).float()
correct += (predicted.squeeze() == labels).sum().item()
total += labels.size(0)
test_acc = correct / total if total != 0 else 0
final_accuracy = test_acc
print(f"Epoch {epoch+1} 训练损失: {train_loss:.4f} 准确率: {test_acc:.2f}")
print(f"模型训练完成，准确率：{final_accuracy:.2%}")代码详解
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms导入库文件
batch_size = 16
image_size = 225
learning_rate = 0.01
weight_decay = 0.001
epochs = 10设置参数：
batch_size：每次训练读入 16 张图片
image_size：统一把图片缩放到 225×225
learning_rate：学习率，控制参数更新步长
weight_decay：权重衰减，防止过拟合
epochs：训练轮数，整个数据集训练 10 次
train_transform = transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
test_transform = transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])统一尺寸：把所有图片缩放到 225×225
随机水平翻转：训练集数据增强，提高泛化能力
转为张量：将图片转为 PyTorch 可用的张量格式
标准化：使用 ImageNet 均值方差归一化，提升训练稳定性
测试集只做缩放、转为张量、标准化的处理
train_path = r"D:\py项目\PythonProject2\Task4\train"
test_path = r"D:\py项目\PythonProject2\Task4\test"
train_dataset = datasets.ImageFolder(train_path, transform=train_transform)
test_dataset = datasets.ImageFolder(test_path, transform=test_transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)指定训练集、测试集图片路径
ImageFolder：自动按文件夹分类读取图片（巴旦木 / 白萝卜）
DataLoader：批量加载数据
训练集打乱：shuffle=True 提高训练效果
测试集不打乱：保证评估顺序一致
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(64 * 28 * 28, 128)
self.fc2 = nn.Linear(128, 1)
self.sigmoid = nn.Sigmoid()
self.relu = nn.ReLU()
def forward(self, x):
x = self.pool(self.relu(self.conv1(x)))
x = self.pool(self.relu(self.conv2(x)))
x = self.pool(self.relu(self.conv3(x)))
x = x.flatten(1)
x = self.relu(self.fc1(x)))
x = self.fc2(x)
x = self.sigmoid(x)
return x3 层卷积：提取图像特征（边缘→纹理→语义）
池化层：下采样，降低维度，防止过拟合
ReLU 激活：增加非线性表达能力
全连接层：将特征映射为分类结果
激活函数采用Sigmoid激活函数
Flatten：将特征图展平，送入全连接层
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)BCELoss：二分类交叉熵损失
Adam 优化器：按照题目要求使用Adam优化器，初始学习率0.01，weight decay为0.001
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
for epoch in range(epochs):
model.train()
train_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.float().unsqueeze(1).to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item() * images.size(0)
train_loss = train_loss / len(train_dataset)
# 测试
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
predicted = (outputs > 0.5).float()
correct += (predicted.squeeze() == labels).sum().item()
total += labels.size(0)
test_acc = correct / total if total != 0 else 0
print(f"Epoch {epoch+1} 训练损失: {train_loss:.4f} 准确率: {test_acc:.2f}")
print(f"模型训练完成，准确率：{test_acc:.2%}")模型训练和测试的代码
运行结果
8、模块五：人工智能技术综合应用
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from collections import Counter
import numpy as np
# ===================== 1. 固定路径（你的文件位置） =====================
TRAIN_PATH = "Task5/train.txt"
TEST_PATH = "Task5/test.txt"
SAVE_PATH = "task5result.txt"
# ===================== 2. 读取数据 =====================
def load_train_data(path):
texts, labels = [], []
with open(path, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if not line: continue
label, text = line.split(maxsplit=1)
texts.append(text)
labels.append(int(label))
return texts, labels
def load_test_data(path):
texts = []
with open(path, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if line: texts.append(line)
return texts
train_texts, train_labels = load_train_data(TRAIN_PATH)
test_texts = load_test_data(TEST_PATH)
# ===================== 3. 构建字符词典 =====================
all_chars = set()
for t in train_texts + test_texts:
for c in t:
all_chars.add(c)
char2idx = {c:i+2 for i,c in enumerate(sorted(all_chars))}
char2idx['<PAD>'] = 0
char2idx['<UNK>'] = 1
vocab_size = len(char2idx)
# ===================== 4. 文本转索引 =====================
max_len = 100
def text2idx(text):
ids = [char2idx.get(c, 1) for c in text]
if len(ids) < max_len:
ids += [0]*(max_len-len(ids))
return ids[:max_len]
train_x = torch.LongTensor([text2idx(t) for t in train_texts])
train_y = torch.FloatTensor(train_labels)
test_x = torch.LongTensor([text2idx(t) for t in test_texts])
# ===================== 5. 数据集 =====================
class TextDataset(Dataset):
def __len__(self): return len(train_x)
def __getitem__(self, i): return train_x[i], train_y[i]
loader = DataLoader(TextDataset(), batch_size=32, shuffle=True)
# ===================== 6. PyTorch 模型（CNN） =====================
class Model(nn.Module):
def __init__(self):
super().__init__()
self.emb = nn.Embedding(vocab_size, 128)
self.conv = nn.Conv1d(128, 64, 3)
self.pool = nn.AdaptiveMaxPool1d(1)
self.fc1 = nn.Linear(64, 32)
self.fc2 = nn.Linear(32, 1)
self.relu = nn.ReLU()
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = self.emb(x).transpose(1,2) # [B, 128, L]
x = self.relu(self.conv(x))
x = self.pool(x).squeeze(-1)
x = self.relu(self.fc1(x))
x = self.sigmoid(self.fc2(x))
return x
model = Model()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# ===================== 7. 训练 + 输出损失 & 准确率 =====================
model.train()
for epoch in range(10):
total_loss = 0.0
correct = 0
total = 0
for x, y in loader:
optimizer.zero_grad()
pred = model(x).squeeze()
loss = criterion(pred, y)
loss.backward()
optimizer.step()
# 累计损失
total_loss += loss.item() * x.size(0)
# 计算准确率
pred_label = (pred > 0.5).float()
correct += (pred_label == y).sum().item()
total += y.size(0)
# 每轮输出
avg_loss = total_loss / total
acc = correct / total
print(f"Epoch {epoch+1:2d} | 损失: {avg_loss:.4f} | 准确率: {acc:.4f}")
print(f"训练完成，准确率: {acc:.4f}")
# ===================== 9. 测试集预测并保存 =====================
model.eval()
with torch.no_grad():
pred_prob = model(test_x).squeeze().numpy()
preds = (pred_prob > 0.5).astype(int)
with open(SAVE_PATH, 'w', encoding='utf-8') as f:
for p in preds:
f.write(f"{p}\n")
print(f"\n结果已保存到：{SAVE_PATH}")代码详解
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from collections import Counter
import numpy as np导入所需库
TRAIN_PATH = "Task5/train.txt"
TEST_PATH = "Task5/test.txt"
SAVE_PATH = "task5result.txt"设置文件路径
def load_train_data(path):
texts, labels = [], []
with open(path, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if not line: continue
label, text = line.split(maxsplit=1)
texts.append(text)
labels.append(int(label))
return texts, labels
def load_test_data(path):
texts = []
with open(path, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if line: texts.append(line)
return texts
train_texts, train_labels = load_train_data(TRAIN_PATH)
test_texts = load_test_data(TEST_PATH)定义数据读取函数
1.load_train_data：读取训练数据，每行按标签 + 文本拆分
2.load_test_data：读取测试数据，只读取文本，无标签
3.自动过滤空行，保证数据干净
4.返回文本列表和标签列表
all_chars = set()
for t in train_texts + test_texts:
for c in t:
all_chars.add(c)
char2idx = {c:i+2 for i,c in enumerate(sorted(all_chars))}
char2idx['<PAD>'] = 0
char2idx['<UNK>'] = 1
vocab_size = len(char2idx)遍历所有字符：收集训练集 + 测试集出现过的所有字符
构建构建字符级词典
<PAD>：填充字符，用于统一句子长度
<UNK>：未知字符，处理未构建的词
vocab_size：字典大小，用于后续嵌入层
max_len = 100
def text2idx(text):
ids = [char2idx.get(c, 1) for c in text]
if len(ids) < max_len:
ids += [0]*(max_len-len(ids))
return ids[:max_len]
train_x = torch.LongTensor([text2idx(t) for t in train_texts])
train_y = torch.FloatTensor(train_labels)
test_x = torch.LongTensor([text2idx(t) for t in test_texts])1.max_len=100：统一文本长度为 100
2.text2idx：
将每个字符转为对应索引
不足 100 上<PAD>
超过 100 截断
3.转换为 PyTorch 张量，用于模型训练
class TextDataset(Dataset):
def __len__(self): return len(train_x)
def __getitem__(self, i): return train_x[i], train_y[i]
loader = DataLoader(TextDataset(), batch_size=32, shuffle=True)自定义数据集类：继承 Dataset
__len__：返回样本数量
__getitem__：按索引返回一条数据
DataLoader：批量加载数据，batch_size=32
class Model(nn.Module):
def __init__(self):
super().__init__()
self.emb = nn.Embedding(vocab_size, 128)
self.conv = nn.Conv1d(128, 64, 3)
self.pool = nn.AdaptiveMaxPool1d(1)
self.fc1 = nn.Linear(64, 32)
self.fc2 = nn.Linear(32, 1)
self.relu = nn.ReLU()
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = self.emb(x).transpose(1,2)
x = self.relu(self.conv(x))
x = self.pool(x).squeeze(-1)
x = self.relu(self.fc1(x))
x = self.sigmoid(self.fc2(x))
return x搭建 CNN 文本分类模型：
Embedding：将字符索引转为 128 维向量
Conv1d：一维卷积，提取文本局部特征
AdaptiveMaxPool1d：自适应池化，固定输出维度
ReLU：增加非线性激活函数
Linear：全连接层，做分类决策
Sigmoid：输出 0~1 概率，用于二分类
model = Model()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)BCELoss：二分类交叉熵损失
Adam：使用Adam学习率优化器
lr=1e-3：学习率，控制参数更新步长
model.train()
for epoch in range(10):
total_loss = 0.0
correct = 0
total = 0
for x, y in loader:
optimizer.zero_grad()
pred = model(x).squeeze()
loss = criterion(pred, y)
loss.backward()
optimizer.step()
total_loss += loss.item() * x.size(0)
pred_label = (pred > 0.5).float()
correct += (pred_label == y).sum().item()
total += y.size(0)
avg_loss = total_loss / total
acc = correct / total
print(f"Epoch {epoch+1:2d} | 损失: {avg_loss:.4f} | 准确率: {acc:.4f}")
print(f"训练完成，准确率: {acc:.4f}")模型训练：
model.train()：开启训练模式
前向传播 → 计算损失 → 反向传播 → 更新参数
累计每轮损失与准确率
输出损失和准确率，实时监控训练效果
model.eval()
with torch.no_grad():
pred_prob = model(test_x).squeeze().numpy()
preds = (pred_prob > 0.5).astype(int)
with open(SAVE_PATH, 'w', encoding='utf-8') as f:
for p in preds:
f.write(f"{p}\n")
print(f"\n结果已保存到：{SAVE_PATH}")按照要求将结果按行写入 task5result.txt
运行结果
我这里只有1553是因为我的数据集和这个样题不一样，我数据集自己找的
以上就是2026年安徽省大数据与人工智能应用竞赛基础知识分享，这个只是对例题的解析，希望能对大家有所帮助。
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
15
0- 0
已为社区贡献1条内容
所有评论(0)