Skip to content

人
人工智能系统实战第三期
Commit c2bf04ba by 前钰
Options

Merge branch 'master' of https://gitlab.diantouedu.cn/QY/test1

parents b762a8ce 36d80780
Showing with 2016 additions and 0 deletions
README.md 0 → 100644
## 第三期课程资料会随着课程更新哦
项目数据集链接：[数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI) （若对数据集有疑惑请查看对应项目readme）
提取码：DTAI
环境配置链接：[环境配置教程](https://github.com/buluslee/DT-AI)
**注：** 在环境配置链接中，您可以找到以下内容：
- Anaconda、VSCode 和 PyCharm 的安装教程。
- Anaconda 的一些基础命令以及换源方法。
- 机器学习传统算法的开源项目。
- 深度学习中的自然语言处理 (NLP) 开源项目。
- 深度学习中的计算机视觉 (CV) 开源项目。
\ No newline at end of file
人工智能系统实战第三期/实战代码/ SKlearn基于降维聚类数据可视化/Dataset/GuoData.csv 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
人工智能系统实战第三期/实战代码/ SKlearn基于降维聚类数据可视化/answer.ipynb.ipynb 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
人工智能系统实战第三期/实战代码/ SKlearn基于降维聚类数据可视化/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题1\n",
"\n",
"使用sklearn库中的PCA并可视化数据使用 PCA 可视化单细胞表达数据\n",
"\n",
"在本实验中，您将使用 PCA 可视化来自Guo 等人的一些单细胞基因表达数据。 “从受精卵到囊胚的单细胞基因表达分析揭示细胞命运决定的解决方案”，《发育细胞》，第 18 卷，第 4 期，2010 年 4 月 20 日，第 675-685 页，可从 http://dx.doi.org/10.1016 获取 /j.devcel.2010.02.012。 论文 pdf 版本可在第 4 周的讲义文件夹中找到。\n",
"\n",
"数据来自小鼠 qPCR TaqMan 阵列单细胞实验。 数据取自胚泡形成时的早期发育阶段。 在 32 细胞阶段，数据已被分离成滋养外胚层 (TE)，进而形成胎盘和内细胞团 (ICM)。 ICM 进一步分化为外胚层 (EPI)（产生内胚层、中胚层和外胚层）以及发育成羊膜袋的原始内胚层 (PE)。 郭等人选择了48个基因进行表达测量。 他们标记了生成的细胞，并将其标签作为可视化的辅助工具。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题2\n",
"\n",
"需要多少个主成分（PC）才能解释数据中80%以上的数据？"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题3\n",
"\n",
"您认为哪种 PC 对于区分 TE 单元类型（32TE 和 64TE）与其他单元最有用？"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题4\n",
"\n",
"哪对组合的 PC 1,2 和 3 能够最好地将 2 细胞阶段与其余阶段分开（例如 PC 1&2、1&3 或 2&3）？"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题5\n",
"\n",
"使用肘部法则来确定最佳聚类数。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题6\n",
"\n",
"使用KMeans算法，DBSCAN算法和高斯混合模型进行聚类"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题7\n",
"\n",
"对问题6的结果进行二维和三维的可视化"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "pytorch20.1",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.4"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/ SKlearn基于降维聚类数据可视化/readme.md 0 → 100644
## 数据集在Dataset文件夹中
## 数据集在Dataset文件夹中
\ No newline at end of file
人工智能系统实战第三期/实战代码/AAAI会议论文聚类分析/answer.ipynb 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
人工智能系统实战第三期/实战代码/AAAI会议论文聚类分析/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 任务介绍\n",
"\n",
"每年国际上召开的大大小小学术会议不计其数，发表了非常多的论文。在计算机领域的一些大型学术会议上，一次就可以发表涉及各个方向的几百篇论文。按论文的主题、内容进行聚类，有助于人们高效地查找和获得所需要的论文。本案例数据来源于AAAI 2014上发表的约400篇文章，由[UCI](https://archive.ics.uci.edu/ml/datasets/AAAI+2014+Accepted+Papers!)公开提供，提供包括标题、作者、关键词、摘要在内的信息，希望大家能根据这些信息，合理地构造特征向量来表示这些论文，并设计实现或调用聚类算法对论文进行聚类。最后也可以对聚类结果进行观察，看每一类都是什么样的论文，是否有一些主题。\n",
" \n",
"\n",
"注：数据中的group和topic也不能完全算是标签，因为\n",
"1. 有些文章作者投稿时可能会选择某个group/topic但实际和另外group/topic也相关甚至更相关；\n",
"2. 一篇文章可能有多个group和topic，作为标签会出现有的文章同属多个类别，这里暂不考虑这样的聚类； "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题一\n",
"\n",
"将文本转化为向量，实现或调用无监督聚类算法，对论文聚类，例如10类（可使用已有工具包例如sklearn）；"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题二\n",
"\n",
"并将聚类结果可视化成散点图"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题三\n",
"\n",
"高维向量的降维旨在去除一些高相关性的特征维度，尝试使用PCA进行降维后，再聚类"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题四\n",
"\n",
"尝试使用一些评价指标，对聚类后的结果进行评价"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.4"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/AAAI会议论文聚类分析/readme.md 0 → 100644
## 数据集在Dataset文件夹中
## 数据集在Dataset文件夹中
\ No newline at end of file
人工智能系统实战第三期/实战代码/python面向对象编程/.gitkeep 0 → 100644
++ "b/\344\272\272\345\267\245\346\231\272\350\203\275\347\263\273\347\273\237\345\256\236\346\210\230\347\254\254\344\270\211\346\234\237/\345\256\236\346\210\230\344\273\243\347\240\201/python\351\235\242\345\220\221\345\257\271\350\261\241\347\274\226\347\250\213/.gitkeep"
人工智能系统实战第三期/实战代码/python面向对象编程/readme.md 0 → 100644
### 这里是九月三号课程的代码
### 这里是九月三号课程的代码
\ No newline at end of file
人工智能系统实战第三期/实战代码/强化学习相关资料/.gitkeep 0 → 100644
++ "b/\344\272\272\345\267\245\346\231\272\350\203\275\347\263\273\347\273\237\345\256\236\346\210\230\347\254\254\344\270\211\346\234\237/\345\256\236\346\210\230\344\273\243\347\240\201/\345\274\272\345\214\226\345\255\246\344\271\240\347\233\270\345\205\263\350\265\204\346\226\231/.gitkeep"
人工智能系统实战第三期/实战代码/数学作业/.gitkeep 0 → 100644
++ "b/\344\272\272\345\267\245\346\231\272\350\203\275\347\263\273\347\273\237\345\256\236\346\210\230\347\254\254\344\270\211\346\234\237/\345\256\236\346\210\230\344\273\243\347\240\201/\346\225\260\345\255\246\344\275\234\344\270\232/.gitkeep"
人工智能系统实战第三期/实战代码/数学作业/readme.md 0 → 100644
## 这里面是九月九号的数学部分相关知识，具体答案请看老师博客
## 这里面是九月九号的数学部分相关知识，具体答案请看老师博客
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/K近邻车牌识别/README.md 0 → 100644
# K近邻车牌识别
# K近邻车牌识别
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI) (内有一个data_s文件夹为缩小后的数据集，使用data数据集跑的较慢可以换data_s数据集)
**数据集介绍：** 使用已经分割好的车牌图片作为数据集，包括数字 0-9、字母 A-Z（不包含O和I）以及省份简称共 65 个类，编号从0到 64。数据已经分成了训练集和测试集，里面的文件夹用label编号命名，一个文件夹下的所有图片都属于该文件夹对应的类，每个图片都是20 * 20的二值化灰度图。
## 基础任务（80分）：
1. 数据预处理任务：将图片数据读入，标准化，将每个图像表示为一维向量，同时保留其对应的标签。这是进行模型训练之前的重要步骤。
2. 模型训练任务：使用 sklearn 库的 KNeighborsClassifier 类，构建 K-NN 模型，并对训练集进行训练。
3. 模型评估任务：使用模型对测试集进行预测，然后计算模型的准确率。可以使用 sklearn 库的 accuracy_score 函数来实现。
4. 参数分析任务：探究当 K 值变化时，模型在测试集上的准确率如何变化。可以绘制一个图表，显示不同 K 值对应的准确率。
5. 数据集大小影响任务：分析当训练集大小变化时，测试结果如何变化。可以尝试不同大小的训练集，记录并分析结果。
## 扩展任务（20分）：
1. 距离度量分析任务：分析在 K-NN 中使用不同的距离度量方式（如欧氏距离、曼哈顿距离等）对模型效果的影响。
2. 方法对比任务：对比平权 K-NN 与加权 K-NN 的预测效果，分析不同权重设置对结果的影响。平权 K-NN 认为所有邻居的投票权重相同，而加权 K-NN 则根据距离远近来确定权重，更近的邻居有更大的投票权。
3. 数据增强任务：考虑到车牌字符可能在不同的光照、角度和大小下出现，可以尝试进行数据增强，如旋转、缩放、剪切等操作，以提高模型的泛化能力。
4. 数据均衡任务：如果数据集中的各类别样本数量不平衡，可能会对 K-NN 的性能产生影响。可以尝试使用过采样或者欠采样的方法，来使得各类别样本数量均衡。
## Tips：
- 尝试用 K-NN 的方法对分割好的字符图像进行自动识别和转化。可以使用 sk-learn 等第三方库，不要求自己实现 K-NN。
- 图片数据的特征之一是冗余性，即一张 128x128 的图片降维到 64x64 依然不影响识别，因为图像的像素矩阵中的某个像素值与周边的像素值的相关性很强，因此相差并不大。所以，可以考虑对图像数据进行降维来增加模型的训练速度和精度。
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/K近邻车牌识别/answer.ipynb 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
人工智能系统实战第三期/实战代码/机器学习项目实战/K近邻车牌识别/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 基于K-近邻的车牌号识别"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 一、案例简介\n",
"\n",
"图像的智能处理一直是人工智能领域广受关注的一类技术，在人工智能落地的进程中发挥着重要作用。其中车牌号识别作为一个早期应用场景，已经融入日常生活中，为我们提供了诸多便利，在各地的停车场和出入口都能看到它的身影。车牌号识别往往分为字符划分和字符识别两个子任务，本案例我们将关注字符识别的任务.\n",
"\n",
"## 二、作业说明\n",
"本次我们使用已经分割好的车牌图片作为数据集，包括数字 0-9、字母 A-Z（不包含 O 和 I）以及省份简称共 65 个类，编号从 0 到 64。数据已经分成了训练集和测试集，里面的文件夹用 label 编号命名，一个文件夹下的所有图片都属于该文件夹对应的类，每个图片都是 20 * 20 的二值化灰度图。尝试用 K-NN 的方法对分割好的字符图像进行自动识别和转化。 可以使用 sk-learn 等第三方库，不要求自己实现K-NN。\n",
"\n",
"### 基础任务（80分）：\n",
"1. 数据预处理任务：将图片数据读入，标准化，将每个图像表示为一维向量，同时保留其对应的标签。这是进行模型训练之前的重要步骤。\n",
"\n",
"2. 模型训练任务：使用 sklearn库的KNeighborsClassifier类，构建K-NN模型，并对训练集进行训练。\n",
"\n",
"3. 模型评估任务：使用模型对测试集进行预测，然后计算模型的准确率。可以使用 sklearn库的accuracy_score函数来实现。\n",
"\n",
"4. 参数分析任务：探究当K值变化时，模型在测试集上的准确率如何变化。可以绘制一个图表，显示不同K值对应的准确率。\n",
"\n",
"5. 数据集大小影响任务：分析当训练集大小变化时，测试结果如何变化。可以尝试不同大小的训练集，记录并分析结果。\n",
"\n",
" \n",
"\n",
"### 扩展任务（20分）：\n",
"1. 距离度量分析任务：分析在K-NN中使用不同的距离度量方式（如欧氏距离、曼哈顿距离等）对模型效果的影响。\n",
"\n",
"2. 方法对比任务：对比平权K-NN与加权K-NN的预测效果，分析不同权重设置对结果的影响。平权K-NN认为所有邻居的投票权重相同，而加权K-NN则根据距离远近来确定权重，更近的邻居有更大的投票权。\n",
"\n",
"3. 数据增强任务：考虑到车牌字符可能在不同的光照、角度和大小下出现，可以尝试进行数据增强，如旋转、缩放、剪切，亮度，对比度等操作，以提高模型的泛化能力。可调包（from PIL import Image,ImageEnhance ）\n",
"\n",
"4. 数据均衡任务：如果数据集中的各类别样本数量不平衡，可能会对K-NN的性能产生影响。可以尝试使用过采样或者欠采样的方法，来使得各类别样本数量均衡。可调包（from imblearn.over_sampling import SMOTE ）"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"tips：\n",
"\n",
"图片数据的特征之一是冗余性，即一张128x128的图片降维到64x64依然不影响识别，因为图像的像素矩阵中的某个像素值与周边的像素值的相关性很强，因此相差并不大。所以，可以考虑对图像数据进行降维来增加模型的训练速度和精度."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.5 64-bit (conda)",
"name": "python385jvsc74a57bd007efdcd4b820c98a756949507a4d29d7862823915ec7477944641bea022f4f62"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
人工智能系统实战第三期/实战代码/机器学习项目实战/基于SVM的乳腺癌预测/readme.md 0 → 100644
## 这里是10.28课程的代码
## 这里是10.28课程的代码
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/基于决策树的英雄联盟胜负预测/README.md 0 → 100644
# 基于决策树算法的英雄联盟游戏胜负预测
# 基于决策树算法的英雄联盟游戏胜负预测
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
**数据集说明：** 本数据集来自Kaggle，包含了9879场钻一到大师段位的单双排对局，对局双方几乎是同一水平。每条数据是前10分钟的对局情况，每支队伍有19个特征，红蓝双方共38个特征。这些特征包括英雄击杀、死亡，金钱、经验、等级情况等等。一局游戏一般会持续30至40分钟，但是实际前10分钟的局面很大程度上影响了之后胜负的走向。
## 基本任务（80）：
1. 合理的进行特征工程处理。
2. 划分训练集和测试集。
3. 使用决策树算法完成游戏胜负的预测。
4. 对比不同特征组合对模型效果的影响。
5. 提交代码和实验报告。
## 扩展任务（20）：
1. 尝试自行实现决策树算法细节。
2. 决策树算法的调参。
## Tips：
- 可以舍去无用特征以及构建差值特征。
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/基于决策树的英雄联盟胜负预测/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 基于决策树算法的英雄联盟游戏胜负预测"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 一、任务介绍\n",
"\n",
"英雄联盟（League of Legends，LoL）是一款多人在线竞技游戏，由拳头游戏（Riot Games）公司出品。游戏中，每位玩家控制一位拥有独特技能的英雄，红蓝两支队伍各有五位玩家进行对战，目标是摧毁对方的基地水晶。水晶有多座防御塔保护，通常需要先摧毁一些防御塔再摧毁水晶。玩家所控制的英雄起初较弱，需要击杀小兵、野怪和对方英雄来获得金币和经验。经验可以提升英雄等级和技能等级，金币可用来购买装备提升攻击、防御等属性。对战中没有己方单位附近的地点会没有视野，即无法看到对面单位。双方可以通过使用守卫来监视某个地点，洞察对面走向并制定战术。\n",
"\n",
"本数据集来自Kaggle，包含了9879场钻一到大师段位的单双排对局，对局双方几乎是同一水平。每条数据是前10分钟的对局情况，每支队伍有19个特征，红蓝双方共38个特征。这些特征包括英雄击杀、死亡，金钱、经验、等级情况等等。一局游戏一般会持续30至40分钟，但是实际前10分钟的局面很大程度上影响了之后胜负的走向。作为最成功的电子竞技游戏之一，对局数据、选手数据的量化与研究具有重要意义，可以启发游戏将来的发展和改进。\n",
"\n",
"## 二、作业说明\n",
"### 基础任务（80）：\n",
"1.合理的进行特征工程处理\n",
"\n",
"2.划分训练集和测试集\n",
"\n",
"3.使用决策树算法完成游戏胜负的预测\n",
"\n",
"4.对比不同特征组合对模型效果的影响\n",
"\n",
"5.提交代码和实验报告\n",
"\n",
"### 扩展任务（20）：\n",
"1.尝试自行实现决策树算法细节\n",
"\n",
"2.决策树算法的调参"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "pytorch_gpu",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.3"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/机器学习项目实战/基于回归分析的大学综合得分预测/README.md 0 → 100644
# 基于回归分析的大学综合得分预测
# 基于回归分析的大学综合得分预测
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
项目中将使用Kaggle的数据集，利用线性回归模型，依据大学各项排名的指标来预测其综合得分。可以使用sk-learn等第三方库，不要求自己实现线性回归。
## 基础任务（80分）：
1. 观察和可视化数据，揭示数据的特性。
2. 训练集和测试集应按照7:3的比例随机划分，采用RMSE（均方根误差）作为模型的评估标准，计算并获取测试集上的线性回归模型的RMSE值。
3. 对线性回归模型中的系数进行分析。
4. 尝试使用其他类型的回归模型，并比较其效果。
## 进阶任务（20分）：
1. 尝试将地区的离散特征融入到线性回归模型中，然后比较并分析结果。
2. 利用R2指标和VIF指标进行模型评价和特征筛选，尝试是否可以增加模型精度。
## Tips：
- 需要查看数据，对数据做简单的清洗
- 选取的重要特征为：'quality_of_faculty', 'publications', 'citations', 'alumni_employment', 'influence', 'quality_of_education', 'broad_impact', 'patents'
- 标签为：'score'
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/基于回归分析的大学综合得分预测/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 基于回归分析的大学综合得分预测\n",
"\n",
"## 1.案例简介\n",
"\n",
"大学排名的问题具有显著的重要性，同时也充满了挑战和争议。一所大学的全方位能力包括科研、师资和学生等多个因素。现在，全球有多达百家的评估机构致力于评估并排列大学的综合评分，然而，这些机构的评分结果经常存在不一致的情况。在这些机构当中，世界大学排名中心（Center for World University Rankings，简称CWUR）以其评估教育质量、校友就业、研究产出和引用，而非依赖调查和大学提交的数据的方式而著名，其影响力十分显著。\n",
"在本项目中，我们将依据CWUR提供的全球知名大学的各项排名（包括师资和科研等）来进行工作。一方面，我们将通过数据可视化来探究各个大学的独特性。另一方面，我们希望利用机器学习模型（例如线性回归）来预测大学的综合得分。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.作业说明\n",
"我们将使用Kaggle的数据集，利用线性回归模型，依据大学各项排名的指标来预测其综合得分。可以使用 sk-learn 等第三方库，不要求自己实现线性回归.\n",
"\n",
"基础任务（80分）：\n",
"- 1.观察和可视化数据，揭示数据的特性。\n",
"- 2.训练集和测试集应按照7:3的比例随机划分，采用RMSE（均方根误差）作为模型的评估标准，计算并获取测试集上的线性回归模型的RMSE值。\n",
"- 3.对线性回归模型中的系数进行分析。\n",
"- 4.尝试使用其他类型的回归模型，并比较其效果。\n",
"\n",
"进阶任务（20分）：\n",
"- 1.尝试将地区的离散特征融入到线性回归模型中，然后比较并分析结果。\n",
"- 2.利用R2指标和VIF指标进行模型评价和特征筛选, 尝试是否可以增加模型精度。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. 数据展示"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>world_rank</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>institution</th>\n",
" <td>Harvard University</td>\n",
" <td>Massachusetts Institute of Technology</td>\n",
" <td>Stanford University</td>\n",
" </tr>\n",
" <tr>\n",
" <th>region</th>\n",
" <td>USA</td>\n",
" <td>USA</td>\n",
" <td>USA</td>\n",
" </tr>\n",
" <tr>\n",
" <th>national_rank</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>quality_of_education</th>\n",
" <td>7</td>\n",
" <td>9</td>\n",
" <td>17</td>\n",
" </tr>\n",
" <tr>\n",
" <th>...</th>\n",
" <td>...</td>\n",
" <td>...</td>\n",
" <td>...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>citations</th>\n",
" <td>1</td>\n",
" <td>4</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>broad_impact</th>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>patents</th>\n",
" <td>5</td>\n",
" <td>1</td>\n",
" <td>15</td>\n",
" </tr>\n",
" <tr>\n",
" <th>score</th>\n",
" <td>100.0</td>\n",
" <td>91.67</td>\n",
" <td>89.5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>year</th>\n",
" <td>2012</td>\n",
" <td>2012</td>\n",
" <td>2012</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"<p>14 rows × 3 columns</p>\n",
"</div>"
],
"text/plain": [
" 0 \\\n",
"world_rank 1 \n",
"institution Harvard University \n",
"region USA \n",
"national_rank 1 \n",
"quality_of_education 7 \n",
"... ... \n",
"citations 1 \n",
"broad_impact NaN \n",
"patents 5 \n",
"score 100.0 \n",
"year 2012 \n",
"\n",
" 1 \\\n",
"world_rank 2 \n",
"institution Massachusetts Institute of Technology \n",
"region USA \n",
"national_rank 2 \n",
"quality_of_education 9 \n",
"... ... \n",
"citations 4 \n",
"broad_impact NaN \n",
"patents 1 \n",
"score 91.67 \n",
"year 2012 \n",
"\n",
" 2 \n",
"world_rank 3 \n",
"institution Stanford University \n",
"region USA \n",
"national_rank 3 \n",
"quality_of_education 17 \n",
"... ... \n",
"citations 2 \n",
"broad_impact NaN \n",
"patents 15 \n",
"score 89.5 \n",
"year 2012 \n",
"\n",
"[14 rows x 3 columns]"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import pandas as pd\n",
"import numpy as np \n",
" \n",
"pd.set_option('display.max_rows', 10) # 设置显示最大行 \n",
"np.set_printoptions(threshold=10)\n",
"\n",
"\n",
"data_df = pd.read_csv('./cwurData.csv') # 读入 csv 文件为 pandas 的 DataFrame\n",
"data_df.head(3).T # 观察前几列并转置方便观察"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"---\n",
"---\n",
"# <center>答案区</center>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"tips\n",
"\n",
"# 1. 数据可视化和分析\n",
"# 2. 注意特征工程，特征的相关性分析，特征的组合，重建和舍弃\n",
"# 3. 注意不同回归模型的选择，模型的参数调整，模型的比较"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.3"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/机器学习项目实战/基于集成学习的Amazon用户评论质量预测/.gitkeep 0 → 100644
++ "b/\344\272\272\345\267\245\346\231\272\350\203\275\347\263\273\347\273\237\345\256\236\346\210\230\347\254\254\344\270\211\346\234\237/\345\256\236\346\210\230\344\273\243\347\240\201/\346\234\272\345\231\250\345\255\246\344\271\240\351\241\271\347\233\256\345\256\236\346\210\230/\345\237\272\344\272\216\351\233\206\346\210\220\345\255\246\344\271\240\347\232\204Amazon\347\224\250\346\210\267\350\257\204\350\256\272\350\264\250\351\207\217\351\242\204\346\265\213/.gitkeep"
人工智能系统实战第三期/实战代码/机器学习项目实战/基于集成学习的Amazon用户评论质量预测/README.md 0 → 100644
# 基于集成学习的 Amazon 用户评论质量预测
# 基于集成学习的 Amazon 用户评论质量预测
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
**案例简介：** 在进行线上商品挑选时，评论往往是我们十分关注的一个方面。然而目前电商网站的评论质量参差不齐，甚至有水军刷好评或者恶意差评的情况出现，严重影响了顾客的购物体验。因此，对于评论质量的预测成为电商平台越来越关注的话题，如果能自动对评论质量进行评估，就能根据预测结果避免展现低质量的评论。本案例中我们将基于集成学习的方法对Amazon现实场景中的评论质量进行预测。
## 作业说明：
本案例中需要大家完成两种集成学习算法的实现（Bagging、AdaBoost），其中基分类器要求使用 SVM 和决策树两种，因此，一共需要对比四组结果（AUC 作为评价指标）：
1. Bagging + SVM
2. Bagging + 决策树
3. AdaBoost + SVM
4. AdaBoost + 决策树
## 基本作业（80分）
1. 根据数据格式设计特征的表示。
2. 汇报不同组合下得到的 AUC。
3. 结合不同集成学习算法的特点分析结果之间的差异。
（使用 sklearn 等第三方库的集成学习算法会酌情扣分）
## 扩展作业（20分）
1. 尝试其他基分类器（如 k-NN、朴素贝叶斯，神经网络）分析不同特征的影响。
2. 分析集成学习算法参数的影响。
## Tips：
- 分析数据集
- reviewID是用户ID
- asin是商品ID
- reviewText是评论内容
- overall是用户对商品的打分
- votes_up是认为评论有用的点赞数
- votes_all是该评论得到的总点赞数
- label是标签
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/基于集成学习的Amazon用户评论质量预测/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 基于集成学习的 Amazon 用户评论质量预测\n",
"\n",
"## 案例简介\n",
"在进行线上商品挑选时，评论往往是我们十分关注的一个方面。然而目前电商网站的评论质量参差不齐，甚至有水军刷好评或者恶意差评的情况出现，严重影响了顾客的购物体验。因此，对于评论质量的预测成为电商平台越来越关注的话题，如果能自动对评论质量进行评估，就能根据预测结果避免展现低质量的评论。本案例中我们将基于集成学习的方法对Amazon现实场景中的评论质量进行预测。\n",
"\n",
"## 作业说明\n",
"本案例中需要大家完成两种集成学习算法的实现（Bagging、AdaBoost），其中基分类器要求使用 SVM 和决策树两种，因此，一共需要对比四组结果（AUC 作为评价指标）：\n",
"1.Bagging + SVM\n",
"\n",
"2.Bagging + 决策树\n",
"\n",
"3.AdaBoost + SVM\n",
"\n",
"4.AdaBoost + 决策树\n",
"\n",
"注意集成学习的核心算法需要手动进行实现，基分类器可以调库。\n",
"\n",
"### 基本作业（80分）\n",
"1.根据数据格式设计特征的表示\n",
"\n",
"2.汇报不同组合下得到的 AUC\n",
"\n",
"3.结合不同集成学习算法的特点分析结果之间的差异\n",
"\n",
"（使用 sklearn 等第三方库的集成学习算法会酌情扣分）\n",
"\n",
"### 扩展作业（20分）\n",
"1.尝试其他基分类器（如 k-NN、朴素贝叶斯，神经网络）分析不同特征的影响\n",
"\n",
"2.分析集成学习算法参数的影响"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"train_df = pd.read_csv('train.xlsx', sep='\\t')\n",
"test_df = pd.read_csv('test.xlsx', sep='\\t',index_col=False)\n",
"train_df.describe()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"分析数据集\n",
"\n",
"reviewID是用户ID\n",
"\n",
"asin是商品ID\n",
"\n",
"reviewText是评论内容\n",
"\n",
"overall是用户对商品的打分\n",
"\n",
"votes_up是认为评论有用的点赞数\n",
"\n",
"votes_all是该评论得到的总点赞数\n",
"\n",
"label是标签"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "pytorch_gpu",
"language": "python",
"name": "python3"
},
"language_info": {
"name": "python",
"version": "3.11.3"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/机器学习项目实战/某闯关类手游用户流失预测/.gitkeep 0 → 100644
++ "b/\344\272\272\345\267\245\346\231\272\350\203\275\347\263\273\347\273\237\345\256\236\346\210\230\347\254\254\344\270\211\346\234\237/\345\256\236\346\210\230\344\273\243\347\240\201/\346\234\272\345\231\250\345\255\246\344\271\240\351\241\271\347\233\256\345\256\236\346\210\230/\346\237\220\351\227\257\345\205\263\347\261\273\346\211\213\346\270\270\347\224\250\346\210\267\346\265\201\345\244\261\351\242\204\346\265\213/.gitkeep"
人工智能系统实战第三期/实战代码/机器学习项目实战/某闯关类手游用户流失预测/README.md 0 → 100644
# 某闯关类手游用户流失预测
# 某闯关类手游用户流失预测
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
## 作业说明：
根据给出的实际数据（包括用户游玩历史，关卡特征等），预测测试集中的用户是否为流失用户（二分类）；
方法不限，使用百度云进行评测，评价指标使用 AUC；
提交代码与实验报告，报告展示对数据的观察、分析、最后的解决方案以及不同尝试的对比等；
最终评分会参考达到的效果以及对所尝试方法的分析。
## 数据概览：
- 本次使用的是一个休闲类闯关手游的数据，用户在游戏中不断闯关，每一关的基本任务是在限定步数内达到某个目标。
- 次周的留存情况是公司关注的一个重点，数据选取了 2020.2.1 注册的所有用户在 2.1-2.4 的交互数据，数据经过筛选保证这些注册用户在前四日至少有两日登录。
- 流失的定义参照次周（2.7-2.13）的登录情况，如果没有登录为流失。
- 数据以更原始的数据记录形式呈现，共包含 5 个文件：
- train.csv
训练集用户,包括用户 id(从 1 开始)以及对应是否为流失用户的 label(1:流失,0:留存)。这里对应了2774~10931的user_id。
- dev.csv
验证集格式和训练集相同,主要为了方便离线测试与模型选择。这里对应了10932~13589的user_id。
- test.csv
测试集只包含用户 id,任务就是要预测这些用户的流失概率。要预测的是1~2773的user_id。
- level_seq.csv
这个是核心的数据文件,包含用户游玩每个关卡的记录,每一条记录是对某个关卡的一次尝试,具体每列的含义如下:
- user_id :用户 id,和训练、验证、测试集中的可以匹配
- level_id :关卡 id
- f_success :是否通关(1:通关,0:失败)
- f_duration :此次尝试所用的时间(单位 s)
- f_reststep :剩余步数与限定步数之比(失败为 0)
- f_help :是否使用了道具、提示等额外帮助(1:使用,0:未使用)
- time :时间戳
- level_meta.csv
每个关卡的一些统计特征,可用于表示关卡,具体每列的含义如下:
- f_avg_duration :平均每次尝试花费的时间(单位 s,包含成功与失败的尝试)
- f_avg_passrate :平均通关率
- f_avg_win_duration :平均每次通关花费的时间(单位 s,只包含通关的尝试)
- f_avg_retrytimes :平均重试次数(第二次玩同一关算第 1 次重试)
- level_id :关卡 id,可以和 level_seq.csv 中的关卡匹配
## Tips：
- 基本的分析和建模思路可以是：根据用户的评论内容和其他相关信息为每个用户提取特征 → 接下来结合标签（例如评论质量）构建表格式的数据集 → 然后使用不同的机器学习模型（例如集成学习方法）进行训练和测试。
- 如果数据量太大，导致运行时间过长，可以考虑先在一个采样的小训练集上进行模型调参和验证，然后再应用到整个数据集。
- 集成多种模型通常可以提高预测性能，达到更优的效果。例如，使用 Bagging 和 AdaBoost 等集成方法可以整合多个基分类器的强项，增强模型的泛化能力。
- 还可以考虑使用各种开源工具和库（例如 scikit-learn）来加速开发和实验过程，这些工具通常提供了许多预处理、特征工程和模型训练的便捷功能。
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/某闯关类手游用户流失预测/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 某闯关类手游用户流失预测"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 一、案例简介\n",
"\n",
"手游在当下的日常娱乐中占据着主导性地位，成为人们生活中放松身心的一种有效途径。近年来，各种类型的手游，尤其是闯关类的休闲手游，由于其对碎片化时间的利用取得了非常广泛的市场。然而在此类手游中，新用户流失是一个非常严峻的问题，有相当多的新用户在短暂尝试后会选择放弃，而如果能在用户还没有完全卸载游戏的时候针对流失可能性较大的用户施以干预（例如奖励道具、暖心短信），就可能挽回用户从而提升游戏的活跃度和公司的潜在收益，因此用户的流失预测成为一个重要且挑战性的问题。在毕业项目中我们将从真实游戏中非结构化的日志数据出发，构建用户流失预测模型，综合已有知识设计适合的算法解决实际问题。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 二、作业说明\n",
"\n",
"* 根据给出的实际数据（包括用户游玩历史，关卡特征等），预测测试集中的用户是否为流失用户（二分类）；\n",
"* 方法不限，使用百度云进行评测，评价指标使用 AUC；\n",
"* 提交代码与实验报告，报告展示对数据的观察、分析、最后的解决方案以及不同尝试的对比等；\n",
"* 最终评分会参考达到的效果以及对所尝试方法的分析。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 三、数据概览\n",
"\n",
"本次使用的是一个休闲类闯关手游的数据，用户在游戏中不断闯关，每一关的基本任务是在限定步数内达到某个目标。每次闯关可能成功也可能失败，一般情况下用户只在完成一关后进入下一关，闯关过程中可以使用道具或提示等帮助。\n",
"\n",
"对大多数手游来说，用户流失往往发生在早期，因此次周的留存情况是公司关注的一个重点。本次数据选取了 2020.2.1 注册的所有用户在 2.1-2.4 的交互数据，数据经过筛选保证这些注册用户在前四日至少有两日登录。流失的定义则参照次周（2.7-2.13）的登录情况，如果没有登录为流失。\n",
"\n",
"本次的数据和以往结构化的形式不同，展现的是更原始的数据记录，更接近公司实际日志的形式，共包含 5 个文件："
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### train.csv\n",
"训练集用户，包括用户 id（从 1 开始）以及对应是否为流失用户的 label（1：流失，0：留存）。这里对应了2774~10931的user_id\n",
"\n",
"### test.csv \n",
"测试集只包含用户 id，任务就是要预测这些用户的流失概率。要预测的是1~2773的user_id\n",
"\n",
"### dev.csv \n",
"验证集格式和训练集相同，主要为了方便离线测试与模型选择。这里对应了10932~13589的user_id\n",
"\n",
"### level_seq.csv \n",
"这个是核心的数据文件，包含用户游玩每个关卡的记录，每一条记录是对某个关卡的一次尝试，具体每列的含义如下\n",
"user_id ：用户 id，和训练、验证、测试集中的可以匹配\n",
"\n",
"level_id ：关卡 id\n",
"\n",
"f_success ：是否通关（1：通关，0：失败）\n",
"\n",
"f_duration ：此次尝试所用的时间（单位 s）\n",
"\n",
"f_reststep ：剩余步数与限定步数之比（失败为 0）\n",
"\n",
"f_help ：是否使用了道具、提示等额外帮助（1：使用，0：未使用）\n",
"\n",
"time ：时间戳\n",
"\n",
"### level_meta.csv\n",
"每个关卡的一些统计特征，可用于表示关卡，具体每列的含义如下\n",
"\n",
"f_avg_duration ：平均每次尝试花费的时间（单位 s，包含成功与失败的尝试）\n",
"\n",
"f_avg_passrate ：平均通关率\n",
"\n",
"f_avg_win_duration ：平均每次通关花费的时间（单位 s，只包含通关的尝试）\n",
"\n",
"f_avg_retrytimes ：平均重试次数（第二次玩同一关算第 1 次重试）\n",
"\n",
"level_id ：关卡 id，可以和 level_seq.csv 中的关卡匹配"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 四、Tips\n",
"\n",
"基本的分析和建模思路可以是：首先根据用户的评论内容和其他相关信息为每个用户提取特征 → 接下来结合标签（例如评论质量）构建表格式的数据集 → 然后使用不同的机器学习模型（例如集成学习方法）进行训练和测试。\n",
"\n",
"如果数据量太大，导致运行时间过长，可以考虑先在一个采样的小训练集上进行模型调参和验证，然后再应用到整个数据集。\n",
"\n",
"集成多种模型通常可以提高预测性能，达到更优的效果。例如，使用Bagging和AdaBoost等集成方法可以整合多个基分类器的强项，增强模型的泛化能力。\n",
"\n",
"还可以考虑使用各种开源工具和库（例如scikit-learn）来加速开发和实验过程，这些工具通常提供了许多预处理、特征工程和模型训练的便捷功能。"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "pytorch_gpu",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
人工智能系统实战第三期/实战代码/机器学习项目实战/贝叶斯垃圾邮件分类/README.md 0 → 100644
# 贝叶斯垃圾邮件分类
# 贝叶斯垃圾邮件分类
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
### 本次作业以垃圾邮件分类任务为基础，要求提取文本特征并使用朴素贝叶斯算法进行垃圾邮件识别（调用已有工具包或自行实现）。
### 任务介绍
电子邮件是互联网的一项重要服务，在大家的学习、工作和生活中会广泛使用。但是大家的邮箱常常被各种各样的垃圾邮件填充了。有统计显示，每天互联网上产生的垃圾邮件有几百亿近千亿的量级。因此，对电子邮件服务提供商来说，垃圾邮件过滤是一项重要功能。而朴素贝叶斯算法在垃圾邮件识别任务上一直表现非常好，至今仍然有很多系统在使用朴素贝叶斯算法作为基本的垃圾邮件识别算法。
本次实验
基本作业（80分）：
1. 提取正文部分的文本特征；
2. 划分训练集和测试集
3. 使用朴素贝叶斯算法完成垃圾邮件的分类与预测，要求计算测试集准确率Accuracy、精准率Precision、召回率Recall
4. 对比特征数目（词表大小）对模型效果的影响；
5. 提交代码和实验报告。
扩展作业（20分）：
1. 尝试使用邮件头信息协助判断垃圾邮件
2. 尝试自行实现朴素贝叶斯算法细节；
\ No newline at end of file
人工智能系统实战第三期/实战代码/机器学习项目实战/贝叶斯垃圾邮件分类/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"本次作业以垃圾邮件分类任务为基础，要求提取文本特征并使用朴素贝叶斯算法进行垃圾邮件识别（调用已有工具包或自行实现）。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 任务介绍\n",
"电子邮件是互联网的一项重要服务，在大家的学习、工作和生活中会广泛使用。但是大家的邮箱常常被各种各样的垃圾邮件填充了。有统计显示，每天互联网上产生的垃圾邮件有几百亿近千亿的量级。因此，对电子邮件服务提供商来说，垃圾邮件过滤是一项重要功能。而朴素贝叶斯算法在垃圾邮件识别任务上一直表现非常好，至今仍然有很多系统在使用朴素贝叶斯算法作为基本的垃圾邮件识别算法。\n",
"\n",
"\n",
"\n",
"本次实验\n",
"\n",
"基本作业（80分）：\n",
"1. 提取正文部分的文本特征；\n",
"2. 划分训练集和测试集 \n",
"3. 使用朴素贝叶斯算法完成垃圾邮件的分类与预测，要求计算测试集准确率Accuracy、精准率Precision、召回率Recall\n",
"4. 对比特征数目（词表大小）对模型效果的影响；\n",
"5. 提交代码和实验报告。\n",
"\n",
"扩展作业（80分）：\n",
"1. 尝试使用邮件头信息协助判断垃圾邮件 \n",
"2. 尝试自行实现朴素贝叶斯算法细节； "
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.5 64-bit (virtualenv)",
"name": "python385jvsc74a57bd007efdcd4b820c98a756949507a4d29d7862823915ec7477944641bea022f4f62"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
人工智能系统实战第三期/实战代码/深度学习项目实战/.gitkeep 0 → 100644
++ "b/\344\272\272\345\267\245\346\231\272\350\203\275\347\263\273\347\273\237\345\256\236\346\210\230\347\254\254\344\270\211\346\234\237/\345\256\236\346\210\230\344\273\243\347\240\201/\346\267\261\345\272\246\345\255\246\344\271\240\351\241\271\347\233\256\345\256\236\346\210\230/.gitkeep"
人工智能系统实战第三期/实战代码/深度学习项目实战/神经网络实现鸢尾花分类/Iris_data.txt 0 → 100644
5.1,3.5,1.4,0.2,Iris-setosa
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
5.4,3.9,1.7,0.4,Iris-setosa
4.6,3.4,1.4,0.3,Iris-setosa
5.0,3.4,1.5,0.2,Iris-setosa
4.4,2.9,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.4,3.7,1.5,0.2,Iris-setosa
4.8,3.4,1.6,0.2,Iris-setosa
4.8,3.0,1.4,0.1,Iris-setosa
4.3,3.0,1.1,0.1,Iris-setosa
5.8,4.0,1.2,0.2,Iris-setosa
5.7,4.4,1.5,0.4,Iris-setosa
5.4,3.9,1.3,0.4,Iris-setosa
5.1,3.5,1.4,0.3,Iris-setosa
5.7,3.8,1.7,0.3,Iris-setosa
5.1,3.8,1.5,0.3,Iris-setosa
5.4,3.4,1.7,0.2,Iris-setosa
5.1,3.7,1.5,0.4,Iris-setosa
4.6,3.6,1.0,0.2,Iris-setosa
5.1,3.3,1.7,0.5,Iris-setosa
4.8,3.4,1.9,0.2,Iris-setosa
5.0,3.0,1.6,0.2,Iris-setosa
5.0,3.4,1.6,0.4,Iris-setosa
5.2,3.5,1.5,0.2,Iris-setosa
5.2,3.4,1.4,0.2,Iris-setosa
4.7,3.2,1.6,0.2,Iris-setosa
4.8,3.1,1.6,0.2,Iris-setosa
5.4,3.4,1.5,0.4,Iris-setosa
5.2,4.1,1.5,0.1,Iris-setosa
5.5,4.2,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.0,3.2,1.2,0.2,Iris-setosa
5.5,3.5,1.3,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
4.4,3.0,1.3,0.2,Iris-setosa
5.1,3.4,1.5,0.2,Iris-setosa
5.0,3.5,1.3,0.3,Iris-setosa
4.5,2.3,1.3,0.3,Iris-setosa
4.4,3.2,1.3,0.2,Iris-setosa
5.0,3.5,1.6,0.6,Iris-setosa
5.1,3.8,1.9,0.4,Iris-setosa
4.8,3.0,1.4,0.3,Iris-setosa
5.1,3.8,1.6,0.2,Iris-setosa
4.6,3.2,1.4,0.2,Iris-setosa
5.3,3.7,1.5,0.2,Iris-setosa
5.0,3.3,1.4,0.2,Iris-setosa
7.0,3.2,4.7,1.4,Iris-versicolor
6.4,3.2,4.5,1.5,Iris-versicolor
6.9,3.1,4.9,1.5,Iris-versicolor
5.5,2.3,4.0,1.3,Iris-versicolor
6.5,2.8,4.6,1.5,Iris-versicolor
5.7,2.8,4.5,1.3,Iris-versicolor
6.3,3.3,4.7,1.6,Iris-versicolor
4.9,2.4,3.3,1.0,Iris-versicolor
6.6,2.9,4.6,1.3,Iris-versicolor
5.2,2.7,3.9,1.4,Iris-versicolor
5.0,2.0,3.5,1.0,Iris-versicolor
5.9,3.0,4.2,1.5,Iris-versicolor
6.0,2.2,4.0,1.0,Iris-versicolor
6.1,2.9,4.7,1.4,Iris-versicolor
5.6,2.9,3.6,1.3,Iris-versicolor
6.7,3.1,4.4,1.4,Iris-versicolor
5.6,3.0,4.5,1.5,Iris-versicolor
5.8,2.7,4.1,1.0,Iris-versicolor
6.2,2.2,4.5,1.5,Iris-versicolor
5.6,2.5,3.9,1.1,Iris-versicolor
5.9,3.2,4.8,1.8,Iris-versicolor
6.1,2.8,4.0,1.3,Iris-versicolor
6.3,2.5,4.9,1.5,Iris-versicolor
6.1,2.8,4.7,1.2,Iris-versicolor
6.4,2.9,4.3,1.3,Iris-versicolor
6.6,3.0,4.4,1.4,Iris-versicolor
6.8,2.8,4.8,1.4,Iris-versicolor
6.7,3.0,5.0,1.7,Iris-versicolor
6.0,2.9,4.5,1.5,Iris-versicolor
5.7,2.6,3.5,1.0,Iris-versicolor
5.5,2.4,3.8,1.1,Iris-versicolor
5.5,2.4,3.7,1.0,Iris-versicolor
5.8,2.7,3.9,1.2,Iris-versicolor
6.0,2.7,5.1,1.6,Iris-versicolor
5.4,3.0,4.5,1.5,Iris-versicolor
6.0,3.4,4.5,1.6,Iris-versicolor
6.7,3.1,4.7,1.5,Iris-versicolor
6.3,2.3,4.4,1.3,Iris-versicolor
5.6,3.0,4.1,1.3,Iris-versicolor
5.5,2.5,4.0,1.3,Iris-versicolor
5.5,2.6,4.4,1.2,Iris-versicolor
6.1,3.0,4.6,1.4,Iris-versicolor
5.8,2.6,4.0,1.2,Iris-versicolor
5.0,2.3,3.3,1.0,Iris-versicolor
5.6,2.7,4.2,1.3,Iris-versicolor
5.7,3.0,4.2,1.2,Iris-versicolor
5.7,2.9,4.2,1.3,Iris-versicolor
6.2,2.9,4.3,1.3,Iris-versicolor
5.1,2.5,3.0,1.1,Iris-versicolor
5.7,2.8,4.1,1.3,Iris-versicolor
6.3,3.3,6.0,2.5,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
7.1,3.0,5.9,2.1,Iris-virginica
6.3,2.9,5.6,1.8,Iris-virginica
6.5,3.0,5.8,2.2,Iris-virginica
7.6,3.0,6.6,2.1,Iris-virginica
4.9,2.5,4.5,1.7,Iris-virginica
7.3,2.9,6.3,1.8,Iris-virginica
6.7,2.5,5.8,1.8,Iris-virginica
7.2,3.6,6.1,2.5,Iris-virginica
6.5,3.2,5.1,2.0,Iris-virginica
6.4,2.7,5.3,1.9,Iris-virginica
6.8,3.0,5.5,2.1,Iris-virginica
5.7,2.5,5.0,2.0,Iris-virginica
5.8,2.8,5.1,2.4,Iris-virginica
6.4,3.2,5.3,2.3,Iris-virginica
6.5,3.0,5.5,1.8,Iris-virginica
7.7,3.8,6.7,2.2,Iris-virginica
7.7,2.6,6.9,2.3,Iris-virginica
6.0,2.2,5.0,1.5,Iris-virginica
6.9,3.2,5.7,2.3,Iris-virginica
5.6,2.8,4.9,2.0,Iris-virginica
7.7,2.8,6.7,2.0,Iris-virginica
6.3,2.7,4.9,1.8,Iris-virginica
6.7,3.3,5.7,2.1,Iris-virginica
7.2,3.2,6.0,1.8,Iris-virginica
6.2,2.8,4.8,1.8,Iris-virginica
6.1,3.0,4.9,1.8,Iris-virginica
6.4,2.8,5.6,2.1,Iris-virginica
7.2,3.0,5.8,1.6,Iris-virginica
7.4,2.8,6.1,1.9,Iris-virginica
7.9,3.8,6.4,2.0,Iris-virginica
6.4,2.8,5.6,2.2,Iris-virginica
6.3,2.8,5.1,1.5,Iris-virginica
6.1,2.6,5.6,1.4,Iris-virginica
7.7,3.0,6.1,2.3,Iris-virginica
6.3,3.4,5.6,2.4,Iris-virginica
6.4,3.1,5.5,1.8,Iris-virginica
6.0,3.0,4.8,1.8,Iris-virginica
6.9,3.1,5.4,2.1,Iris-virginica
6.7,3.1,5.6,2.4,Iris-virginica
6.9,3.1,5.1,2.3,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
6.8,3.2,5.9,2.3,Iris-virginica
6.7,3.3,5.7,2.5,Iris-virginica
6.7,3.0,5.2,2.3,Iris-virginica
6.3,2.5,5.0,1.9,Iris-virginica
6.5,3.0,5.2,2.0,Iris-virginica
6.2,3.4,5.4,2.3,Iris-virginica
5.9,3.0,5.1,1.8,Iris-virginica
人工智能系统实战第三期/实战代码/深度学习项目实战/神经网络实现鸢尾花分类/data_loader.py 0 → 100644
from torch.utils.data import Dataset
from torch.utils.data import Dataset
import os
import pandas as pd
import numpy as np
import torch
class iris_dataload(Dataset):
def __init__(self, data_path: str, transform=None):
self.data_path = data_path
self.transform = transform
assert os.path.exists(data_path), "dataset root: {} does not exist.".format(data_path)
df = pd.read_csv(self.data_path , names=[0,1,2,3,4])
d = {'Iris-setosa':0, 'Iris-versicolor':1, 'Iris-virginica':2}
df[4]=df[4].map(d)
data=df.iloc[:,0:4]
label=df.iloc[:,4:]
data=np.array(data)
data = (data - np.mean(data) )/ np.std(data)
label=np.array(label)
self.data=torch.from_numpy(np.array(data,dtype='float32') )
self.label= torch.from_numpy(np.array(label,dtype='int64') )
self.data_num = len(label) # 存储训练集的所有图片路径
print("{} images were found in the dataset.".format(self.data_num))
def __len__(self):
return self.data_num
def __getitem__(self, idx):
self.data = list(self.data)
self.label = list(self.label)
return self.data[idx], self.label[idx]
# if __name__ == '__main__':
# custom_dataset = iris_dataload( "./Iris_data.txt")
# print(custom_dataset)
\ No newline at end of file
人工智能系统实战第三期/实战代码/深度学习项目实战/神经网络实现鸢尾花分类/fully_connected_network.py 0 → 100644
import os
import os
import argparse
import sys
from torch.utils.data import DataLoader
from tqdm import tqdm
import torch
import torch.optim as optim
import torch.nn as nn
from data_loader import iris_dataload
parser = argparse.ArgumentParser()
parser.add_argument('--num_classes', type=int, default=100, help='the number of classes')
parser.add_argument('--epochs', type=int, default=20, help='the number of training epoch')
parser.add_argument('--batch_size', type=int, default=16, help='batch_size for training')
parser.add_argument('--lr', type=float, default=0.005, help='star learning rate')
parser.add_argument('--data_path', type=str, default="/mnt/d/Codes/GNN/NN/Iris_data.txt")
parser.add_argument('--device', default='cuda', help='device id (i.e. 0 or 0,1 or cpu)')
opt = parser.parse_args()
# 初始化神经网络
class Neuralnetwork(nn.Module):
def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
super(Neuralnetwork, self).__init__()
self.layer1 = nn.Linear(in_dim, n_hidden_1)
self.layer2 = nn.Linear(n_hidden_1, n_hidden_2)
self.layer3 = nn.Linear(n_hidden_2, out_dim)
def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x
# 定义当前模型的训练环境
device = torch.device(opt.device if torch.cuda.is_available() else "cpu")
# device = torch.device("cpu")
# 划分数据集并加载
custom_dataset = iris_dataload( "./Iris_data.txt")
train_size = int(len(custom_dataset) * 0.7)
validate_size = int(len(custom_dataset) * 0.2)
test_size = len(custom_dataset) - validate_size - train_size
train_dataset, validate_dataset, test_dataset = torch.utils.data.random_split(custom_dataset, [train_size, validate_size, test_size])
train_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=False )
validate_loader = DataLoader(validate_dataset, batch_size=1, shuffle=False )
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False )
print("Training set data size:", len(train_loader)*opt.batch_size, ",Validating set data size:", len(validate_loader), ",Testing set data size:", len(test_loader))
# 定义推理过程，返回准确率。用于验证阶段和测试阶段
def infer(model, dataset, device):
model.eval()
acc_num = 0.0
with torch.no_grad():
for data in dataset:
datas, labels = data
outputs = model(datas.to(device))
predict_y = torch.max(outputs, dim=1)[1]
acc_num += torch.eq(predict_y, labels.to(device)).sum().item()
accuratcy = acc_num / len(dataset)
return accuratcy
# 定义训练，验证和测试过程
def main(args):
print(args)
model = Neuralnetwork(4, 12, 6, 3).to(device) # 实例化模型
loss_function = nn.CrossEntropyLoss() # 定义损失函数
pg = [p for p in model.parameters() if p.requires_grad] # 定义模型参数
optimizer = optim.Adam(pg, lr=args.lr) # 定义优化器
# 定义模型权重存储地址
save_path = os.path.join(os.getcwd(), 'results/weights')
if os.path.exists(save_path) is False:
os.makedirs(save_path)
# 开始训练过程
for epoch in range(opt.epochs):
############################################################## train ######################################################
model.train()
acc_num = torch.zeros(1).to(device) # 初始化，用于计算训练过程中预测正确的数量
sample_num = 0 # 初始化，用于记录当前迭代中，已经计算了多少个样本
# tqdm是一个进度条显示器，可以在终端打印出现在的训练进度
train_bar = tqdm(train_loader, file=sys.stdout, ncols=100)
for datas in train_bar :
data, label = datas
label = label.squeeze(-1)
sample_num += data.shape[0]
optimizer.zero_grad()
outputs = model(data.to(device)) # output_shape: [batch_size, num_classes]
pred_class = torch.max(outputs, dim=1)[1] # torch.max 返回值是一个tuple，第一个元素是max值，第二个元素是max值的索引。
acc_num += torch.eq(pred_class, label.to(device)).sum()
loss = loss_function(outputs, label.to(device)) # 求损失
loss.backward() # 自动求导
optimizer.step() # 梯度下降
# print statistics
train_acc = acc_num.item() / sample_num
train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1, opt.epochs, loss)
############################################################## validate ######################################################
val_accurate = infer(model = model, dataset=validate_loader, device=device)
print('[epoch %d] train_loss: %.3f train_acc: %.3f val_accuracy: %.3f' % (epoch + 1, loss, train_acc, val_accurate))
torch.save(model.state_dict(), os.path.join(save_path, "NN.pth") )
# 每次迭代后清空这些指标，重新计算
train_acc = 0.0
val_accurate = 0.0
print('Finished Training')
################################################################# test ############################################################
test_accurate = infer(model = model, dataset = test_loader, device= device)
print(' test_accuracy: %.3f' % ( test_accurate))
if __name__ == '__main__':
main(opt)
\ No newline at end of file
人工智能系统实战第三期/实战代码/深度学习项目实战/神经网络实现鸢尾花分类/perception.py 0 → 100644
from functools import reduce
from functools import reduce
class VectorOp(object):
"""
实现向量计算操作
"""
@staticmethod
def dot(x, y):
"""
计算两个向量x和y的内积
"""
# 首先把x[x1,x2,x3...]和y[y1,y2,y3,...]按元素相乘 ----> 变成[x1*y1, x2*y2, x3*y3]
# 然后利用reduce求和
return reduce(lambda a, b: a + b, VectorOp.element_multiply(x, y), 0.0)
@staticmethod
def element_multiply(x, y):
"""
将两个向量x和y按元素相乘
"""
# 首先 zip(x,y) ---> 把x[x1,x2,x3...]和y[y1,y2,y3,...]打包在一起 ---->变成[(x1,y1),(x2,y2),(x3,y3),...]
# 然后利用map函数计算[x1*y1, x2*y2, x3*y3]
return list(map(lambda x_y: x_y[0] * x_y[1], zip(x, y)))
@staticmethod
def element_add(x, y):
"""
将两个向量x和y按元素相加
"""
# 首先把x[x1,x2,x3...]和y[y1,y2,y3,...]打包在一起
# 变成[(x1,y1),(x2,y2),(x3,y3),...]
# 然后利用map函数计算[x1+y1, x2+y2, x3+y3]
return list(map(lambda x_y: x_y[0] + x_y[1], zip(x, y)))
@staticmethod
def scala_multiply(v, s):
"""
将向量v中的每个元素和标量s相乘
"""
return map(lambda e: e * s, v)
class Perceptron():
def __init__(self, input_num, activator):
"""
初始化感知器，设置输入参数的个数，以及激活函数。
激活函数的类型为double -> double
"""
self.activator = activator
# 权重向量初始化为0
self.weights = [0.0] * input_num
# 偏置项初始化为0
self.bias = 0.0
def __str__(self):
"""
打印学习到的权重、偏置项
"""
return 'weights\t:%s\nbias\t:%f\n' % (self.weights, self.bias)
def predict(self, input_vec):
"""
输入向量，输出感知器的计算结果
"""
# 计算向量input_vec[x1,x2,x3...]和weights[w1,w2,w3,...]的内积
# 然后加上bias
return self.activator( VectorOp.dot(input_vec, self.weights) + self.bias)
def f(x):
"""
定义激活函数f
"""
return 1 if x > 0 else 0
def train( input_vecs, labels, iteration, rate):
"""
输入训练数据: 一组向量、与每个向量对应的label; 以及训练轮数、学习率
"""
#初始化模型, 创建感知器，输入参数个数为2（因为and是二元函数），激活函数为f
Perceptron_Model = Perceptron(2, f)
for _ in range(iteration):
# 把输入和输出打包在一起，成为样本的列表[(input_vec, label), ...]
# 而每个训练样本是(input_vec, label)
samples = zip(input_vecs, labels)
# 对每个样本，按照感知器规则更新权重
for (input_vec, label) in samples:
# 计算感知器在当前权重下的输出
output = Perceptron_Model.predict(input_vec)
# 根据梯度下降算法求更新权重
delta = label - output
Perceptron_Model.weights = VectorOp.element_add( Perceptron_Model.weights, VectorOp.scala_multiply(input_vec, rate * delta))
# 更新bias
Perceptron_Model.bias += rate * delta
return Perceptron_Model
def get_training_dataset():
"""
基于and真值表构建训练数据和标签
"""
# 构建训练数据
# 输入向量列表
input_vecs = [[1, 1], [0, 0], [1, 0], [0, 1]]
# 期望的输出列表，注意要与输入一一对应
# [1,1] -> 1, [0,0] -> 0, [1,0] -> 0, [0,1] -> 0
labels = [1, 0, 0, 0]
return input_vecs, labels
def train_and_perceptron():
"""
使用and真值表训练感知器
"""
# 训练，迭代10轮, 学习速率为0.1
input_vecs, labels = get_training_dataset()
p = train(input_vecs, labels, 10, 0.1)
# 返回训练好的感知器
return p
if __name__ == '__main__':
# 训练and感知器
and_perception = train_and_perceptron()
# 打印训练获得的权重
print(and_perception)
# 测试
print('1 and 1 = %d' % and_perception.predict([1, 1]))
print('0 and 0 = %d' % and_perception.predict([0, 0]))
print('1 and 0 = %d' % and_perception.predict([1, 0]))
print('0 and 1 = %d' % and_perception.predict([0, 1]))
\ No newline at end of file
人工智能系统实战第三期/实战代码/深度学习项目实战/神经网络实现鸢尾花分类/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 一、案例简介\n",
"\n",
"Iris数据集是常用的分类实验数据集，由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。数据集包含150个数据样本，分为3类，每类50个数据，每个数据包含4个属性。可通过花萼长度，花萼宽度，花瓣长度，花瓣宽度4个属性预测鸢尾花卉属于（Setosa，Versicolour，Virginica）三个种类中的哪一类。\n",
"\n",
"注意：本项目提供一大一小两个数据集（data，data_s）。请根据个人电脑配置选择不同的数据集，如果电脑配置一般，建议选择小数据集\n",
"\n",
"## 二、作业说明\n",
"具体数据详见文件 Iris_data.txt\n",
"\n",
"鸢尾花卉数据集的读取方法是自定义的，继承了pytorch的Dataset类，详见文件 data_loader.py。要求在fully_connected_network.py中完成模型的搭建，训练，验证和测试。 \n",
"\n",
"### 基础任务（80分）：\n",
"1. 完成神经网络模型的搭建\n",
"\n",
"2. 完成模型训练脚本\n",
"\n",
"3. 完成模型验证脚本\n",
"\n",
"4. 完成模型测试脚本\n",
" \n",
"\n",
"\n",
"### 扩展任务（20分）：\n",
"1. 使用python脚本实现的感知机模型，不依赖于pytorch"
]
}
],
"metadata": {
"language_info": {
"name": "python"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/深度学习项目实战/神经网络实现鸢尾花分类/神经网络解决异或.py 0 → 100644
import numpy as np
import numpy as np
# 定义激活函数（Sigmoid）
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 输入数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
# 目标输出
y = np.array([[0], [1], [1], [0]])
# 设置随机种子，以确保结果可重复
np.random.seed(42)
# 初始化权重和偏置
W1 = np.random.random((2, 2))
b1 = np.zeros((1, 2))
W2 = np.random.random((2, 1))
b2 = np.zeros((1, 1))
# 定义学习率和迭代次数
learning_rate = 0.1
epochs = 10000
# 训练网络
for epoch in range(epochs):
# 前向传播
hidden_layer_input = np.dot(X, W1) + b1
hidden_layer_output = sigmoid(hidden_layer_input)
# hidden_layer_output = hidden_layer_input
output_layer_input = np.dot(hidden_layer_output, W2) + b2
# output_layer_output = output_layer_input
output_layer_output = sigmoid(output_layer_input)
# 计算损失值
# loss = np.mean((output_layer_output - y) ** 2)
# 反向传播
output_error = (output_layer_output - y) * output_layer_output * (1 - output_layer_output)
hidden_layer_error = np.dot(output_error, W2.T) * hidden_layer_output * (1 - hidden_layer_output)
# 更新权重和偏置
W2 -= learning_rate * np.dot(hidden_layer_output.T, output_error)
b2 -= learning_rate * np.sum(output_error, axis=0, keepdims=True)
W1 -= learning_rate * np.dot(X.T, hidden_layer_error)
b1 -= learning_rate * np.sum(hidden_layer_error, axis=0, keepdims=True)
# 用训练好的网络进行预测
hidden_layer_input = np.dot(X, W1) + b1
hidden_layer_output = sigmoid(hidden_layer_input)
output_layer_input = np.dot(hidden_layer_output, W2) + b2
output_layer_output = sigmoid(output_layer_input)
# 输出每个输入对应的计算数值
for i in range(len(X)):
print("输入:", X[i])
print("hidden_layer_input", hidden_layer_input[i])
print("hidden_layer_output", hidden_layer_output[i])
print("output_layer_input", output_layer_input[i])
print("output_layer_output", output_layer_output[i])
print("输出:", output_layer_output[i][0])
print()
print('W1-----')
print(W1)
print('b1-----')
print(b1)
print('W2-----')
print(W2)
print('b2-----')
print(b2)
\ No newline at end of file
人工智能系统实战第三期/实战代码/爱尔兰杀菌剂数据分析/answer.ipynb 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
人工智能系统实战第三期/实战代码/爱尔兰杀菌剂数据分析/question.ipynb 0 → 100644
{
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题一\n",
"\n",
"读取Data1中成对的ha和ac表格数据，组合成下表形式columns=['Year', 'Crop Type', 'Crop', 'Fungicide', 'Hectares', 'Active Substance'] 其中，Year和Crop Type取自表格名(e.g. 1987_Orchards_fruit_ha.xlsx) Crop列对应ha或ac表格中的行名；Fungicide列对应ha或ac表格中的列名 Hectares对应ha表格中的值；Active Substance对应ac表格中的值\n",
"\n",
"\n",
"注意：开始分析之前，首先需要对数据进行清洗和预处理。这一步是必要的，因为清洗后的数据会让后续的统计和可视化更准确。\n",
"\n",
"例如：\n",
"1.Hectares和Active Substance是应该数值类型，请处理缺失值、异常值， 将原始数据中的空值替换为0.0， 并将原始数据中的“<1”替换为0.1。 这将确保所有数据都是数字类型， 便于以后的计算和处理。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题二\n",
"\n",
"删除Other Fungicide等综合基数的值。且文件夹中文件名可能格式不唯一。导致提取的新表格中，同类作物在Crop type列可能存在不同的命名。因此，请将名称包含 'Arable' 的值重命名为 'Arable_crops'，以此类推"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题三\n",
"\n",
"使用散点图说明不同作物类型报告和年份之间的关系。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题四\n",
"\n",
"用柱状图表示不同作物类型中，年份和杀菌剂使用的关系"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题五\n",
"\n",
"在同一张柱状图中，表示不同作物类型在每年中使用的杀菌剂公顷数"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题六\n",
"\n",
"用折线图表示不同作物类型每年使用杀菌剂的密度"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题七\n",
"\n",
"用柱状图表示所有杀菌剂中使用周期（last year - first year）排名前十的使用情况"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 问题八\n",
"\n",
"用折线图表示不同作物类型中每年使用的杀菌剂的数量变化"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.4"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}
人工智能系统实战第三期/实战代码/爱尔兰杀菌剂数据分析/readme.md 0 → 100644
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
**项目数据集链接：** [数据集下载链接](https://pan.baidu.com/s/1AgHi10abQqI689pMeRGxbQ?pwd=DTAI)
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment