盐析白兔

这个屌丝很懒，什么也没留下！

热门标签

大数据自学笔记_大数据笔记

作者：盐析白兔 | 2024-04-09 03:29:53

踩

大数据笔记

1 学习目的

掌握数据科学的学科地位；理解机器学习、统计学、可视化理论对数据科学的主要影响；了解：数据科学的理论基础—机器学习、统计学、可视化理论—的知识体系及代表性方法。知识点：

2.1数据科学的学科地位
2.2 统计学
2.3 机器学习
2.4 数据可视化

重点：数据科学的学科地位；数据科学视角下的机器学习知识体系；数据科学视角下的统计学知识体系；数据科学视角下可视化理论知识体系。

难点：机器学习、统计学、数据可视化之间的区别及它们在数据科学中的不可替代作用；统计学、机器学习和数据可视化之间的融合。

自主学习总结

1.1 数据科学的学科地位

数据科学是一个融合了多个学科的领域，涉及统计学、计算机科学、应用数学、机器学习、数据库、数据挖掘等多个学科。它的核心目标是利用数据来解决实际问题，从而推动科学、商业和社会的进步。

从学科定位看，数据科学处于数学与统计知识、黑客精神与技能和领域实务知识三大区域的重叠之处，如图2所示。图2是Drew Conway首次提出数据科学韦恩图。图3是后来Jerry Overton提出的另一个版本。

“数据与统计知识”是数据科学的主要理论基础之一，但数据科学与（传统）数学和统计学是有区别的。其主要区别如下：

数据学科中的“数据”不等于“数值”同样“数据”不等于“数值”
数据科学中的“计算”不是“加、减、乘、除等数学运算”，还包括数据的查询、挖掘、洞见、分析、可视化等更多类型
数据科学的问题不是“单一学科”的问题，还涉及到多个学科的研究范畴，它强调的是跨学科视角
数据学科不是纯理论研究以及数据学科不是领域实务知识，它关注和强调的是二者的结合。

“黑客精神与技能”是数据科学家的主要精神追求和技能要求 — 大胆创新、喜欢挑战、追求完美和不断改进。
“领域实务知识”是对数据科学家的特殊要求 — 不仅需要掌握数学与统计知识以及具备黑客精神与技能，而且还需要精通某一个特定领域的实务知识与经验。

1.2 统计学

1.2.1 统计学与数据科学

数据科学的理论、方法、技术和工具往往来源于统计学。统计学在数据科学中具有非常重要的意义，是数据科学的主要理论基础之一。

2.2.2 统计学在数据科学中的重要意义

数据收集与处理：

统计学提供了一系列有效的方法，如概率采样、抽样方法、假设检验、方差分析等，可以帮助我们从大量的数据中抽取代表性的样本，从而更好地理解和分析数据。

数据分析与建模：

统计学提供了一系列经典的方法和模型，如回归分析、方差分析等，可以帮助我们对数据进行分析和建模，从而更好地理解数据、发现规律和趋势，进行预测和决策。

不确定性量化：

统计学提供了一系列方法和指标，如置信区间、标准误、假设检验、p值等，可以帮助我们量化不确定性，提高决策的可靠性和准确性。

数据可视化：

统计学可以将数据转化为可视化的图形和表格，更加生动直观地展现数据的特征和规律，帮助决策者更好地理解和分析数据。

2.2.3数据科学中常用的统计学知识

2.2.4 数据科学视角下的统计学

1.不是随机样本，而是全体数据

2.不是精确性，而是混杂性

3.不是因果关系，而是相关关系

1.3 机器学习

2.3.1 机器学习与数据科学

机器学习为数据科学中充分发挥计算机的自动数据处理能力，拓展人的数据处理能力以及实现人机协同数据处理提供了重要手段。

基本思路：以现有的部分数据（称为训练集）为学习素材（输入），通过特定的学习方法（机器学习算法），让机器学习到（输出）能够处理更多或未来数据的新能力（称为目标函数）。

机器学习三要素

任务（T）
性能指标（P）
经验来源（E）

机器学习的基本思想

2.3.2 数据科学中常用的机器学习知识

基于实例学习

基本思路：事先将训练样本存储下来，然后每当遇到一个新增查询实例时，学习系统分析此新增实例与以前存储的实例之间的关系，并据此把一个目标函数赋给一个新增实例。

常用方法：K近邻方法、局部加权回归法、基于案例的推理。

概念学习

本质：从有关某个布尔函数的输入输出训练样本中推算出该布尔函数。

具体方法：Find-S算法、候选消除算法等。

决策树学习

本质：一种逼近离散值目标函数的过程。它代表的是一种分类过程。

其中：

根节点：代表分类的开始

叶节点：代表一个实例的结束

中间节点：代表相应实例的某一属性

从根节点到叶节点的每条路径：代表一个具体的实例，同一个路径上的所有所有属性之间是“逻辑与”关系。

核心算法：ID3算法

人工神经网络学习

人工神经元是人工神经网络的最基本的组成部分。

根据连接方式的不同，通常把人工神经网络分为无反馈的向前神经网络和相互连接型网络（反馈网络）。在人工神经网络中，实现人工神经元的方法有很多种，如感知器、线性单元和Sigmoid单元等。

特征学习方法：深度学习

贝叶斯学习

定义：它是一种以贝叶斯法则为基础的，并通过概率手段进行学习的方法。

常用方法：朴素贝叶斯分类器

遗传算法

本质：主要研究“从候选假设空间中搜索出最佳假设”。此处，“最佳假设”指“适应度”指标为最优的假设。

遗传算法借鉴的生物进化的三个基本原则：适者生存、两性繁衍及突变，分别对应遗传算法的三个基本算子：选择、交叉和突变。

遗传算法：GA算法

分析学习

特点：使用先验知识来分析或解释每个训练样本，以推理出样本的哪些特征与目标函数相关或不相关。因此，这些假设能使机器学习系统比单独依靠数据进行泛化有更高的精度。

增强学习

本质：主要研究的是如何协助自治Agent（机器人）的学习活动，进而达到选择最优动作的目的。

基本思路：当Agent在其环境中做出某个动作时，施教者会提供奖赏或惩罚信息，以表示结果状态的正确与否。

根据学习任务的不同，机器学习算法分为：有监督学习、无监督学习和半监督学习。

2.3.3 数据科学视角下的机器学习

机器学习领域所面临的主要挑战有：

过拟合
维度灾难
特征工程
算法的可扩展性
模型集成

1.4 数据可视化

数据可视化在数据科学中的地位：

（1）视觉是人类获得信息的最主要的途径。

视觉感知是人类大脑的最主要的功能之一。

眼睛是感知信息能力最强的人体器官之一。

（2）相对于统计分析，数据可视化的主要优势为：

数据可视化处理可以洞察统计分析无法发现的结构和细节。

数据可视化处理结果的解读对用户知识水平的要求较低。

（3）可视化能够帮助人们提高理解与处理数据的效率。

1.5 机器学习、统计学、数据可视化之间的区别

统计学：

统计学是在资料分析的基础上，自17世纪中叶产生并逐步发展起来的一门学科，它是研究如何测定、收集、整理、归纳和分析反应数据资料，一边给出正确信息的科学。统计学广泛的应用在各门科学，从自然科学、社会科学到人文科学，甚至被用来做工商业和政府的情报决策。随着大数据时代的来临，统计的面貌也逐步被改变，与信息、计算机等领域密切结合，是数据科学（Data Science)中的重要主轴之一。

机器学习：

机器学习被认为是人工智能的一方面：给定一些可用离散术语（例如，在一些行为中，那个行为是正确的）描述的人工智能问题，并给出关于这个世界的大量信息，在没有程序员进行编程的情况下弄清楚「正确」的行为。典型的是，需要一些外部流程判断行为是否正确。在数学术语中，也就是函数：馈入输入，产生正确的输出。所以整个问题就是以自动化的方式建立该数学函数的模型。在二者进行区分时：如果我写出的程序聪明到表现出人类行为，它就是人工智能。但如果它的参数不是自动从数据进行学习，它就不是机器学习。

数据可视化：

数据可视化就是将数据转换成图或表等，以一种更直观的方式展现和呈现数据，让读者能“一眼看懂”你想表达的信息。通过“可视化”的方式，复杂的数据通过图形化的手段进行有效表达，准确高效、简洁全面地传递某种信息，甚至我们帮助发现某种规律和特征，挖掘数据背后的价值。

差异：

统计模型与机器学习在线性回归上的差异

机器学习（这里特指有监督学习）的目的是获得一个可反复预测的模型。我们通常不关心模型是否可以解释。机器学习只在乎结果。就好比对公司而言，你的价值只用你的表现来衡量。而统计建模更多的是为了寻找变量之间的关系和确定关系的显著性，恰巧迎合了预测。

统计学和机器学习与数据可视化的区别：

前两者是进行如何测定、收集、整理、归纳和分析反应数据资料，而后者是将数据转换成图或表等，以一种更直观的方式展现和呈现数据。

2.6 统计学、机器学习和数据可视化之间的融合。

2.6.1机器学习是基于统计学：

机器学习基于统计的框架，因为机器学习涉及数据，而数据必须基于统计学框架来进行描述。

机器学习的理论来源于数学和统计学
机器学习算法基于优化理论、矩阵代数和微积分
机器学习的实现来源于计算机科学和工程学概念，比如核映射、特征散列等。

2.6.2统计学习理论——机器学习的统计学基础

统计学和机器学习之间最主要的区别在于统计学完全基于概率空间。你可以从集合论中推导出全部的统计学内容，集合论讨论了我们如何将数据归类（这些类被称为“集”），然后对这个集进行某种测量保证其总和为1.我们将这种方法成为概率空间。统计学除了对这些集合和测量有所定义之外没有其他假设。这就是为什么我们对概率空间的定义非常严谨的原因。一个概率空间，其数学符号写作(Ω,F,P)，包含三部分：

一个样本空间，Ω，也就是所有可能结果的集合。

一个事件集合，F，每个事件都包含0或者其它值。

对每个事件发生的可能性赋予概率，P，这是一个从事件到概率的函数。

机器学习基于统计学习理论，统计学习理论也依旧基于对概率空间的公理化语言。这个理论基于传统的统计学理论，并发展于19世纪60年代。

2.6.3机器学习促进可视化，可视化促进机器学习

从数据分析的角度去看的话，两者都是属于数据分析的工具,只是彼此从不同的角度去看数据。机器学习是从模型的角度，数据可视化是从图像的角度。

2. Pytorch学习

1 pyTorch安装和配置

彻底卸载anaconda

conda install anaconda-clean
anaconda-clean --yes
再用控制面板
1
2
3

anaconda 卸载环境：conda uninstall -n yyy --all

anaconda 安装路径：D:\anaconda3
创建环境： conda create -n pytorch python=3.9
切换环境： conda activate pytorch
查看目前已经安装的工具包：pip list

Q 安装pytorch?

进入pytorch首页下拉，https://pytorch.org/
查看gpu型号：任务管理器-性能 - gpu

首先更改下载源，，然后，使用官网上的指令安装，直接安装torch一直下载不下来
已经测试，速度很慢，30kB/s

conda create -n pytorch python=3.9
conda activate pytorch
conda config --remove-key channels  
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud

pip3 install torch torchvision torchaudio
1
2
3
4
5
6
7
8
9

已经测试，最有效的办法，速度最快,3MB/s

conda create -n pytorch python=3.9
conda activate pytorch


conda config --set show_channel_urls yes
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/ 


# 使用的这个 —— 未成功
conda install pytorch==1.9.1 torchvision==0.10.1 torchaudio==0.9.1 -c pytorch

# 用的这——未成功

pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f https://download.pytorch.org/whl/torch_stable.html

# 这个未成功

pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu111/torch_stable.html

pip install torch==1.10.1+cu102 torchvision==0.11.2+cu102 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu102/torch_stable.html

# 这个可以,但是gpu太low, cuda 版本太高，，gpu上无法训练

pip install torch==1.10.2+cu113 torchvision==0.11.3+cu113 torchaudio===0.10.2+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html  

# 11.1

pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f https://download.pytorch.org/whl/torch_stable.html

pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu111/torch_stable.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2 python 编辑器的安装

pyCharm 安装注意事项

在 Installation Options 中，，勾选 .py

pyCharm 配置

打开
新建项目的过程中
选择 Existing interpreter
手动找到编译器，，选择 conda Environment ->
输入： D:/anaconda/envs/pytroch/python.exe

检测是否正常运行

点 “” python console “”

import torch
torch.cuda.is_available()
1
2

默认 Jupiter 安装在 base 环境中，，所以，现在要在新环境中在安装一遍 jupiter。

新环境中安装jupyter

# open  anaconda命令行

conda activate pytorch
conda list
conda install nb_conda
jupyter notebook
1
2
3
4
5
6

jupyter 使用指南

import torch
torch.cuda.is_available()
1
2

shift + 回车：表示创建一个新的代码块，并且运行上一个代码块

3 为什么返回 false

我的是true ，跳过

4 python 学习中的两个法宝函数

dir() : 打开
help() : 说明书

dir(pytorch)
1

5 pyCharm 和 Jupyter使用及对比

6 pytorch 加载数据

Dataset
提供获取数据及其lable的方法
能得到总共有多少数据
能获取每一个数据及其 label

Dataloader
把数据打包，，方便后续使用

代开 Jupyter

conda activate pytorch
jupyter notebook
1
2

7 Dataset 实战

安装opencv

conda activate pytorch
conda install opencv-python
1
2

from torch.utils.data import Dataset
from PIL import Image
import os


class MyData(Dataset):

def __init__(self, root_dir, label_dir):
    self.root_dir = root_dir
    self.label_dir = label_dir
    self.path = os.path.join(self.root_dir, self.label_dir)
    self.img_path = os.listdir(self.path)

def __getitem__(self, idx):
    img_name = self.img_path[idx]
    img_item_path = os.path.join( self.root_dir, self.label_dir, img_name )
    img = Image.open(img_item_path)
    label = self.label_dir
    return img, label

def __len__(self):
    return len(self.img_path)

root_dir = "hymenoptera_data/hymenoptera_data/train"
ants_label_dir = "ants"
bees_label_dir = "bees"
ants_dataset = MyData(root_dir, ants_label_dir)
bees_dataset = MyData(root_dir, bees_label_dir)

train_dataset = ants_dataset + bees_dataset
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

8 Tensorboard 使用数据可视化

SummaryWriter使用

安装tensorboard

pip install tensorboard
1

报错

包不匹配,解决办法如下
```
pip install setuptools==59.5.0
conda install tensorboard
1
2
```
运行结果是，，多了一个Logs文件夹

数据可视化：
一定要切换到Logs的上一层目录中

conda activate pytorch

D:
cd D:\pycharm-workplace\pythonProject

# 切换到 Logs的上一层目录中

tensorboard --logdir=logs
1
2
3
4
5
6
7
8

9 tensorboard使用2

利用opencv读取文件，转化为Numpy数组

pip install opencv-python
1

from torch.utils.tensorboard import SummaryWriter
import numpy as np
from PIL import Image

writer = SummaryWriter("logs")
image_path = "hymenoptera_data/hymenoptera_data/train/ants/0013035.jpg"
img_PIL = Image.open(image_path)
img_array = np.array(img_PIL)


writer.add_image("lyy", img_array, 1, dataformats='HWC')

for i in range(100):
    writer.add_scalar("y=2x", 3*i, i)

writer.close()

print("end")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

10 Transfroms 使用1——主要是对图片进行变换

ToTensor（）使用—— 把 imgge 或 numpy 转换为 tensor

from PIL import Image
from torchvision import transforms

img_path = "hymenoptera_data/hymenoptera_data/train/ants/0013035.jpg"
img = Image.open(img_path)

# tensor_trans 是一个类

tensor_trans = transforms.ToTensor() # 吧 imgge 或 numpy 转换为 tensor
tensor_img = tensor_trans(img)

print(tensor_img)
1
2
3
4
5
6
7
8
9
10
11
12

11 Transfroms 使用2——主要是对图片进行变换

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

img_path = "hymenoptera_data/hymenoptera_data/train/ants/0013035.jpg"
img = Image.open(img_path)


writer = SummaryWriter("logs")


tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)

# print(tensor_img)

writer.add_image("lyy", tensor_img)
writer.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

12 常见transforms使用

normalize

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

img_path = "hymenoptera_data/16.jpg"
img = Image.open(img_path)

writer = SummaryWriter("logs")

# totensor使用

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)
writer.add_image("lyy", tensor_img)

# Normalize 使用

trans_norm = transforms.Normalize([111,111,111],[10,10,10])
img_norm = trans_norm(tensor_img)
writer.add_image("normalize", img_norm, 2)

writer.close()

print("end")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

13 常见transforms使用2

注意事项

关注输入输出，看官方文档，关注方法的参数

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

img_path = "hymenoptera_data/16.jpg"
img = Image.open(img_path)


writer = SummaryWriter("logs")

# totensor使用

tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)
writer.add_image("lyy", tensor_img)

# Normalize 使用

trans_norm = transforms.Normalize([111,111,111],[10,10,10])
img_norm = trans_norm(tensor_img)
writer.add_image("normalize", img_norm, 2)

# resize

trans_resize = transforms.Resize( (512, 512))
img_resize = trans_resize(img) # 输入的是Image类型的图像
img_resize_tensor = transforms.ToTensor()

tensor_img = tensor_trans(img_resize)
writer.add_image("resize", tensor_img, 0)

# compose 用法

trans_resize_2 =transforms.Resize(123)
trans_compose = transforms.Compose([trans_resize_2, tensor_trans])
img_resize_2 = trans_compose(img)
writer.add_image("resize2", img_resize_2,1)

# randomCrop

trans_random = transforms.RandomCrop((20,50))
trans_compose_2 = transforms.Compose([trans_random, tensor_trans])
for i in range(10):
    img_crop = trans_compose_2(img)
    writer.add_image("randomCrop", img_crop, i)


writer.close()

print("end")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

14 torchvision数据集使用

下载网上的数据集，及使用

import torchvision
from torch.utils.tensorboard import SummaryWriter

dataset_transfrom = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])

train_set = torchvision.datasets.CIFAR10(root="./cifar10", train=True, transform=dataset_transfrom, download=True)
test_set = torchvision.datasets.CIFAR10(root="./cifar10", train=False, transform=dataset_transfrom, download=True)

writer = SummaryWriter("p10")
for i in range(10):
    img, target = test_set[i]
    writer.add_image("test_set", img, i)

writer.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

15 DataLoader 使用

Dataset 有数据，和标签
DataLoader，吧数据加载到神经网络

import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

test_data = torchvision.datasets.CIFAR10("./cifar10", train=False, transform=torchvision.transforms.ToTensor())
test_loader = DataLoader(dataset=test_data, batch_size=64, shuffle=True, num_workers=0, drop_last=False)

writer = SummaryWriter("dataloader")

step = 0
for data in test_loader:
    imgs, targets = data
    writer.add_images("dataloader", imgs, step)
    step = step + 1

writer.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在使用 DataLoader 加载数据集时，每个样本被处理成一个元素为 (data, label) 的 tuple。其中 data 代表输入数据，label 代表数据对应的标签。当我们对 DataLoader 进行 for 循环迭代时，每次得到的是一个批次(batch)的数据，也是一个 tuple，其中包含了一个大小为 (batch_size, *) 的张量 data 和一个大小为 (batch_size,) 的张量 label。这样设计的优点是更方便数据的并行处理。

但是，在这个代码中，我们只需要获取输入数据进行预测，而不需要标签数据。因此，使用了 img[0] 取出了每个样本中的第 1 个元素，即图像数据，而忽略了标签数据。这样，img[0] 的大小即为 (batch_size, C, H, W)，其中 batch_size 是批次大小，C 是通道数，H 和 W 是图像的高度和宽度。这是因为图像数据通常是一个 CxHxW 的三维张量，其中 C 是通道数，H 和 W 分别是图像的高和宽。

需要注意的是，在具体的实现中，根据数据集的实际情况，每个样本可能包含更多元素。因此，在读取数据时需要根据自己的数据集和需求进行调整。

17 卷积操作

import torch
import torch.nn.functional as F

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]])
kernal = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])

input = torch.reshape(input, (1,1,5,5))
kernal = torch.reshape(kernal, (1,1,3,3))

print(input.shape)
print(kernal.shape)

output = F.conv2d(input, kernal, stride=2, padding=1)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

参数:

input – input tensor of shape形状的输入张量 (minibatch,in_channels,��,��)(minibatch,in_channels,i**H,iW)
weight – filters of shape形状过滤器 (out_channels,in_channelsgroups,��,��)(out_channels,groupsin_channels,k**H,kW)
bias – optional bias tensor of shape形状的可选偏差张量 (out_channels)(out_channels). Default: None
stride – the stride of the convolving kernel. Can be a single number or a tuple卷积内核的步幅。可以是单个数字或元组 (sH, sW). Default: 1
padding –

implicit paddings on both sides of the input. 输入两侧的隐式填充。Can be a string {‘valid’, ‘same’}, single number or a tuple (padH, padW). Default: 0 padding='valid' is the same as no padding. padding='same' pads the input so the output has the same shape as the input. However, this mode doesn’t support any stride values other than 1.
dilation – the spacing between kernel elements. 内核元素之间的间距。Can be a single number or a tuple 可以是单个数字或元组 (dH, dW). Default: 1
groups – split input into groups,将输入拆分为组， in_channelsin_channels should be divisible by the number of groups. Default: 1

18 神经网络 —— 卷积层

import torch
import torchvision
from torch.utils.data import DataLoader
from torch.nn import Conv2d
from torch import nn
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../data",train=False,transform=torchvision.transforms.ToTensor(), download=False)
dataloader = DataLoader(dataset, batch_size=64)

class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        self.conv1 = Conv2d(3, 6, 3, 1)

	def forward(self, x):
    	x = self.conv1(x)
   		return x

lyy = Lyy()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, targets = data
    output = lyy(imgs)
    writer.add_images("input", imgs, step)
    
	output = torch.reshape(output, (-1,3,30,30))
	writer.add_images("output", output, step)
	
	step += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在这里插入图片描述

卷积，把原图片的三成chanel卷积成63个chanel，同时224*224不变，则说明在卷积的时候padding要填充，保证相同
https://neurohive.io/en/popular-networks/vgg16/

19 最大池化层

移动步长，默认是卷积核的大小

import torch
from torch.nn import Conv2d, MaxPool2d
from torch import nn
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10('./cifar10', train=False, transform=torchvision.transforms.ToTensor(),download=False)
dataloader = DataLoader(dataset, 64, False)


input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]], dtype=torch.float32)
kernal = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])

input = torch.reshape(input, (1,1,5,5))

kernal = torch.reshape(kernal, (1,1,3,3))

class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
         # self.conv1 = Conv2d(3, 3, 3, 1,padding=1)
        self.maxpool =MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, x):
        # x = self.conv1(x)
        x = self.maxpool(x)
        return x

lyy = Lyy()

output = lyy(input)

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, tagerts = data
    writer.add_images("input", imgs, step)
    output = lyy(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

20 非线性激活

import torch
import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]], dtype=torch.float32)

input = torch.reshape(input, (-1,1, 5, 5))


dataset = torchvision.datasets.CIFAR10("./cifar10", False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, 64)


class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        self.relu1 = ReLU()
        self.sigmoid = Sigmoid()

    def forward(self, input):
        return self.sigmoid(input)

lyy = Lyy()


step = 0
writer = SummaryWriter("logs")

for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = lyy(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()

print("end")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

21 线性层和其它层

为正确运行

import torch
import torchvision
from torch.nn import Linear
from torch.utils.data import DataLoader
from torch import nn
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)


class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        super.linear1 = Linear(196608,10)

    def forward(self, input):
        output = self.linear1(input)
        return output

lyy = Lyy()

write = SummaryWriter("logs")

step = 0
for data in dataloader:
    imgs, targers = data
    print(imgs.shape)
    write.add_images("input", imgs, step)
    output = torch.reshape(imgs, (1,1,1, -1))
    print(output.shape)

    write.add_images("output", output, step)

write.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

22 神经网络搭建小实战

计算 Padding 和 Stride 是多少？
Dilation 默认等于 1

在这里插入图片描述

RuntimeError: mat1 and mat2 shapes cannot be multiplied (64x1024 and 10240x64) 原因

在这里插入图片描述

原因：网络参数设置不合适！！

from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torch

class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        self.conv1 = Conv2d(3, 32, 5, padding=2)
        self.maxpool1 = MaxPool2d(2)
        self.conv2 = Conv2d(32, 32, 5, padding=2)
        self.maxpool2 = MaxPool2d(2)
        self.conv3 = Conv2d(32, 64, 5, padding=2)
        self.maxpool3 = MaxPool2d(2)
        self.flatten = Flatten()
        self.linear1 = Linear(1024, 64)
        self.linear2 = Linear(64, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.flatten(x)
        x = self.linear1(x)
        x = self.linear2(x)
        return x

lyy = Lyy()
input = torch.ones((64,3,32,32))
print(input.shape)
output = lyy(input)
print(output.shape)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

上述代码的，等价替换版本

from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torch

class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

lyy = Lyy()
input = torch.ones((64,3,32,32))
print(input.shape)
output = lyy(input)
print(output.shape)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

可以用tensorboard绘制流程图

writer = SummaryWriter('logs')
writer.add_graph(lyy, input)
writer.close()
1
2
3

23 损失函数与反向传播

分类问题经常用交叉熵损失函数

import torch
from torch.nn import L1Loss
from torch import nn

inputs = torch.tensor([1,2,3], dtype=float)
outputs = torch.tensor([1,2,5], dtype=float)

inputs = torch.reshape(inputs, [1,1,1,3])
outputs = torch.reshape(outputs, (1,1,1,3))

loss = L1Loss(reduction='sum')
result = loss(inputs, outputs)
print(result)


loss_mse = nn.MSELoss()
result = loss_mse(inputs, outputs)
print(result)

交叉熵损失函数

x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))
loss_cross = nn.CrossEntropyLoss()
print(loss_cross)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)

class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

loss = nn.CrossEntropyLoss()
lyy=Lyy()
for data in dataloader:
    imgs, targets = data
    outputs = lyy(imgs)
    result_loss = loss(outputs, targets)
    result_loss.backward()
    print(result_loss)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

24 优化器

import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader
import torch


dataset = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)


class Lyy(nn.Module):
    def __init__(self):
        super(Lyy, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x

loss = nn.CrossEntropyLoss()
lyy=Lyy()
optis = torch.optim.SGD(lyy.parameters(), lr=0.1)

for epoch in range(10):
    running_loss = 0
    for data in dataloader:
        imgs, targets = data
        outputs = lyy(imgs)
        result_loss = loss(outputs, targets)

        optis.zero_grad()
        result_loss.backward() # 设置对应的梯度
        optis.step()
        running_loss += result_loss
    print(running_loss)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

25 现有网络模型的使用及修改

AGG模型 + imageNet数据集

安装 scipy包
pretrained参数，表示，网络是否训练好

import torchvision.models
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torch

dataset = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor())
#dataloader = DataLoader(dataset, batch_size=64)

vgg16_true = torchvision.models.vgg16(pretrained=True)
vgg16_false = torchvision.models.vgg16(pretrained=False)

# 改造vgg16

print(vgg16_false)

# 更改 vgg16， 增加一层

vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)

print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)
print(vgg16_false)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

26 网络模型的保存与读取

方式1 和方式2 都差不多，推荐方式2

model_save

import torchvision
import torch

vgg16 = torchvision.models.vgg16(pretrained=False)

保存方式1 ： 即保存模型结构，，也保存了参数

torch.save(vgg16, "vgg16_model1.pth")

保存方式2 ： 把参数保存成字典，不保存结构 (官方推荐)

torch.save(vgg16.state_dict(), "vgg16_model2.pth")

print("end")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

model_load

import torch
import torchvision

加载方式1 - 保存方式1

model = torch.load("vgg16_model1.pth")

print(model)

加载方式2

vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_model2.pth"))
print(vgg16)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

27,28,29 完整的训练套路

argmax() 针对分类问题很有效

在这里插入图片描述

import torch
from torch.utils.tensorboard import SummaryWriter

from model_self import *
import torchvision
from torch.nn import Conv2d
from torch.optim import SGD
from torch.utils.data import DataLoader
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear

# 准备数据及

train_data = torchvision.datasets.CIFAR10('./cifar10', True, transform=torchvision.transforms.ToTensor(),download=False)
test_data = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor(),download=False)

# 求长度

train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据及长度:{}".format(train_data_size))
print("测试数据集长度:{}".format(test_data_size))

# 加载数据集

train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 搭建网络

# 创建网络模型

lyy = Lyy()

# 创建损失函数

loss_fn = nn.CrossEntropyLoss()

# 优化器

learning_rate = 1e-2
optimizer = torch.optim.SGD(lyy.parameters(),lr=learning_rate)

# 设置训练网络参数

total_train_step = 0
total_test_step = 0
# 训练的轮数
epoch = 10

# 添加tensorboard

writer = SummaryWriter("logs")


for i in range(epoch):
    print("-----第{}轮训练开始了-----".format(i+1))

    # 训练步骤开始
    for data in train_dataloader:
        imgs, tragets = data
        output = lyy(imgs)
        loss = loss_fn(output, tragets)
    	
        # 优化器优化模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    	
        total_train_step += 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss:{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)
    
    # 测试步骤开始
    total_test_loss = 0
    total_accuracy = 0
    
    # 使训练中没有梯度
    with torch.no_grad():
        for data in test_dataloader:
            imgs, tragets = data
            output = lyy(imgs)
            loss = loss_fn(output, tragets)
            total_test_loss += loss
    
            accuracy = (output.argmax(1) -- tragets).sum()
            total_accuracy += accuracy
    
    print("整体测试机上误差：{}".format(total_test_loss))
    print("整体测试机上的正确率：{}".format(total_accuracy/test_data_size))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/total_test_step)
    total_test_step += 1
    
    # torch.save(lyy, "lyy_{}.pth".format(i))
    # print("模型已保存")

writer.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

30 利用GPU训练

for i in range(epoch):
print(“-----第{}轮训练开始了-----”.format(i+1))

# 训练步骤开始
for data in train_dataloader:
    imgs, tragets = data
    output = lyy(imgs)
    loss = loss_fn(output, tragets)
	
    # 优化器优化模型
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
	
    total_train_step += 1
    if total_train_step % 100 == 0:
        print("训练次数：{}，Loss:{}".format(total_train_step, loss.item()))
        writer.add_scalar("train_loss", loss.item(), total_train_step)

# 测试步骤开始
total_test_loss = 0
total_accuracy = 0

# 使训练中没有梯度
with torch.no_grad():
    for data in test_dataloader:
        imgs, tragets = data
        output = lyy(imgs)
        loss = loss_fn(output, tragets)
        total_test_loss += loss

        accuracy = (output.argmax(1) -- tragets).sum()
        total_accuracy += accuracy

print("整体测试机上误差：{}".format(total_test_loss))
print("整体测试机上的正确率：{}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/total_test_step)
total_test_step += 1

# torch.save(lyy, "lyy_{}.pth".format(i))
# print("模型已保存")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

writer.close()




## 30 利用GPU训练

找到 网络模型， 数据， 损失函数，调用.cuda()
1
2
3
4
5
6

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/390003

大数据自学笔记_大数据笔记

1 学习目的

1.1 数据科学的学科地位

1.2 统计学

1.2.1 统计学与数据科学

数据科学的理论、方法、技术和工具往往来源于统计学。统计学在数据科学中具有非常重要的意义，是数据科学的主要理论基础之一。

1.3 机器学习

2.3.2 数据科学中常用的机器学习知识

2.3.3 数据科学视角下的机器学习

1.4 数据可视化

1.5 机器学习、统计学、数据可视化之间的区别

统计学：

机器学习：

数据可视化：

差异：

2.6 统计学、机器学习和数据可视化之间的融合。

2.6.1机器学习是基于统计学：

2.6.2统计学习理论——机器学习的统计学基础

2.6.3机器学习促进可视化，可视化促进机器学习

2. Pytorch学习

1 pyTorch安装和配置

彻底卸载anaconda

Q 安装pytorch?

2 python 编辑器的安装

pyCharm 安装注意事项

pyCharm 配置

检测是否正常运行

新环境中安装jupyter

jupyter 使用指南

3 为什么 返回 false

4 python 学习中的两个 法宝函数

5 pyCharm 和 Jupyter使用及对比

6 pytorch 加载数据

代开 Jupyter

7 Dataset 实战

安装opencv

8 Tensorboard 使用 数据可视化

SummaryWriter使用

9 tensorboard使用2

利用opencv读取文件，转化为Numpy数组

10 Transfroms 使用1——主要是对图片进行变换

ToTensor（）使用—— 把 imgge 或 numpy 转换为 tensor

11 Transfroms 使用2——主要是对图片进行变换

12 常见transforms使用

normalize

13 常见transforms使用2

注意事项

14 torchvision数据集使用

15 DataLoader 使用

17 卷积操作

18 神经网络 —— 卷积层

19 最大池化层

20 非线性激活

21 线性层 和 其它层

22 神经网络搭建小实战

23 损失函数与反向传播

分类问题经常用 交叉熵损失函数

24 优化器

25 现有网络模型的使用及修改

26 网络模型的保存与读取

27,28,29 完整的训练 套路

30 利用GPU训练

3 为什么返回 false

4 python 学习中的两个法宝函数

8 Tensorboard 使用数据可视化

21 线性层和其它层

分类问题经常用交叉熵损失函数

27,28,29 完整的训练套路