沐神

01.深度学习介绍

02.深度学习介绍

• 图片分类
• 物体检测和分割
• 样式迁移
• 人脸合成
• 文字生产图片
• 文字生成 gpt-3
• 无人驾驶
• 案例研究（广告点击）
• 特征提取
• 模型预测

三个角色：
领域专家:就是相关领域的知情人.可以理解为提需求的人
数据科学家：将数据转换为模型
AI专家

提问部分：

1. 训练的模型是一个黑盒，不能做出解释，为什么在图片分割领域有效，可解释性是比较差的，因为人的思维无法理解
2. 深度学习的模型可以用数学来表示，但是无法用数学来解释为什么这个模型可以工作
3. 符号学在深度学习是有一定进展的，比如图神经网络，
4. 寻找独特的paper（论文）

03.安装

环境：ubuntu18.04
远程访问之：ssh ubuntu@100.20.65.33
更新下apt : sudo apt update
安装gcc : sudo apt install build-essential
安装python3.8 : sudo apt install python3.10
安装zip： sudo apt install zip

install miniconda fromhttps://docs.conda.io/en/latest/miniconda.html

wget https://repo.anaconda.com/miniconda/Miniconda3-py310_23.1.0-1-Linux-x86_64.shju zhengg
bash Miniconda3-py310_23.1.0-1-Linux-x86_64.sh
# 阅读协议，确定安装，选择路径

python库的安装

pip3 install jupyter d2l  torch torchvision

安装课程备忘录

# 注意这里记事本的安装位置，和下边打开jupyter的位置相一致即可
wget https://zh-v2.d2l.ai/d2l-zh.zip
unzip  d2l-zh.zip
jupyter note

启动jupyter

jupyter notebook

使用端口转发在远程服务器上运行Jupyter Notebook

ssh -L8888:localhost:8888 ubuntu@100.20.65.33

04.数据操作 + 数据预处理

概念

机器学习和神经网络的主要数据结构是 N维数组

表头	表头	例子
0-d （标量）	一个类别	1.0
1-d （向量）	一个特征向量	[1.0,2.0,3.0]
2-d （矩阵）	一个样本-特征矩阵	[[1.0,2.0,3.0][1.0,2.0,3.0][1.0,2.0,3.0]]
### 创建数组

创建数组需要：
- 形状；例如3x4的矩阵
- 每个元素的数据类型：例如32位浮点数
- 每个元素的值，例如全是0，或者随机数

访问元素

访问最后一个元素
x[-1]

访问第二个和第三个元素
x[1:3]

数据操作

tensor(张量)表示一个数值组成的数组，这个数组可能有多个维度

import torch
x=torch.arange(12)

可以通过张量的shape属性来访问其形状，通过numel()(numerElement)方法访问其元素的总数

print(x.shape)
#torch.Size([12])
print(x.numel())
#12

要改变一个张量的形状，而不改变元素数量和元素值，我们可以调用reshape函数，一下将张量变为一个3x4的矩阵,注意其参数是一个元组

x=x.reshape(3,4)
print(x)
#tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

使用全0,全1,其他常量或者从特定的分布中随机采样的数字创建
参数传入想要的形状，是一个元组

torch.zeros((2,3,4))
#tensor([[[0., 0., 0., 0.],
#         [0., 0., 0., 0.],
#         [0., 0., 0., 0.]],
#         [[0., 0., 0., 0.],
#         [0., 0., 0., 0.],
#         [0., 0., 0., 0.]]])
````

通过提供包含数组的python列表（或嵌套函数),来为所需张量中的每个元素赋予确定值，注意逗号
```python
torch.tensor([[1,2,3][4,5,6]])
#tensor([[1, 2, 3],
#        [4, 5, 6]])

常见的标准算术运算符都可以被升级为按元素运算

x=torch.tensor([1,2,3,4])
y=torch.tensor([2,3,4,5])
x+y
x-y
x*y
x/y
x**y
#**运算符是求幂运算

连接两个张量
torch.cat 是 PyTorch 中的一个函数，用于将多个张量沿指定维度拼接起来。
torch.cat(seq, dim=0, out=None) -> Tensor
其中，seq 是一个张量序列，dim 参数是指定拼接维度的整数值，默认是 0，即沿第一维进行拼接。out 参数是可选的输出张量。

x=torch.arange(12,dtype=torch.float32).reshape((3,4))
y=torch.tensor([[2.0,1,4,3],[1,2,3,4]])
z=torch.cat((x,y),dim=0)
print(z)
#tensor([[ 0.,  1.,  2.,  3.],
#        [ 4.,  5.,  6.,  7.],
#        [ 8.,  9., 10., 11.],
#        [ 2.,  1.,  4.,  3.],
#        [ 1.,  2.,  3.,  4.]])

z=torch.cat((x,y),dim=1)

通过逻辑运算符构建二元张量

x=torch.arange(12,dtype=torch.float32).reshape((3,4))
y=torch.tensor([[2.0,1,4,3],[1,2,3,4]])
x==y
#tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

对张量中的所有元素进行求和，会产生一个只有一个元素的张量

x.sum()

广播机制
即使形状不同，我们仍然可以利用广播机制（broadcasting mechanism）来执行按元素操作,可能会导致意想不到结果

在NumPy中，广播机制是一种灵活的数组操作方式，可以在不增加内存使用的情况下，使不同形状的数组进行二元算术运算。

广播机制的基本规则是当两个数组的每个维度的大小相等或其中一个数组的维度大小为1时，这两个数组是可广播的，可以使用广播机制实现二元算术运算。 这样，较小的数组将被广播到较大数组的大小以匹配其形状，使它们具有兼容的形状，然后就可以进行逐元素的运算。

比如，如果我们有两个数组a和b，形状分别为(3, 5)和(5,)，那么广播机制会将b扩展为(1, 5)，然后将a和b各自扩展为(3, 5)和(1, 5)，使它们形状兼容，然后使用逐元素的方式进行二元运算。

#在这个示例中，数组b被广播成了(1, 5)，然后与数组a进行乘法运算，得到了形状为(3, 5)的新数组c。可以看到，数组b的每个元素都被逐个乘以了a数组对应位置的元素，从而得到新数组c。
a = np.ones((3, 5))
b = np.array([1, 2, 3, 4, 5])
c = a * b
print(c)

#array([[1., 2., 3., 4., 5.], [1., 2., 3., 4., 5.], [1., 2., 3., 4., 5.]])

元素提取

提取最后一个元素： x[-1]
提取第二个和第三个元素： x[1：3]

通过指定索引将元素写入矩阵

x[1,2]=9 #将第一行第二列的元素赋进去
x[0:2,:]=9 #

# 创建一个 3 行 4 列的 2 维数组
x = np.array([[1, 2, 3, 4], 
              [5, 6, 7, 8], 
              [9, 10, 11, 12]])
-------------------------
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
-------------------------
# 将数组中第 0 行到第 1 行（不包括第 2 行）所有列的元素设为 9
x[0:2, :] = 9
print(x)
----------------
[[9 9 9 9]
 [9 9 9 9]
 [9 10 11 12]]
----------------

内存问题

有些操作可能会为结果分配内存
id()函数可以告诉你当前变量在内存中的唯一标识号

before=id（y）
y=y+x
id(y)==before
#false

原地操作
z[:]=new data

x = np.array([[1, 2, 3, 4], 
              [5, 6, 7, 8], 
              [9, 10, 11, 12]])

z=torch.zeros_like(x)
print('id(z):',id(z))
z[:]=x+y

数据预处理

创建一个人工数据集，并存储在csv（逗号分割值）文件

import csv

rows = [
    ["房价", "年份", "地点"],
    ["100万元", "2020年", "北京"],
    ["80万元", "2020年", "上海"],
    ["50万元", "2020年", "广州"]
]

with open('house_price.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(rows)