毕业设计Week1

这次学习分为了2个部分。第一个部分是视频学习部分，第二个部分是代码学习部分。

Part1 视频学习

视频1 引论

1️⃣ 图灵测试
在黑盒外判断盒内是一个人还是一个机器。
Ex：验证码系统。
2️⃣ GAN
二战中盟军破解了德国的Enigma系统：通过模拟Enigma密码生成的过程来破解，这种思路体现在了今天的对抗式生成网络（GAN）中。
Keywords：深度学习模型，无监督学习，（至少）两个模块（生成模型（Generative Model）、判别模型（Discriminative Model））
原始 GAN 理论中，并不要求 G 和 D 都是神经网络，只需要是能拟合相应生成和判别的函数即可。但实用中一般均使用深度神经网络作为 G 和 D。
判别模型：给定一张图，判断这张图里的动物是猫还是狗
生成模型：给一系列猫的图片，生成一张新的猫咪（不在数据集里）
3️⃣ 人工智能的三个层面

4️⃣ 人工智能 > 机器学习 > 深度学习

5️⃣ 逻辑演绎 与 归纳总结

6️⃣ 机器学习
keywords：解出一个 近似解。
实际应用中，特征往往比分类器更重要。

1. 模型、策略、方法。
   模型（对要学习问题映射的假设）

2. 机器学习的常见方法
   
3. 人工设计特征

特征提取：从原始数据中提取一些有效的特征。
特征转换：对特征进行一定的加工，如升维降维。

4. 传统机器学习 与 深度学习
   A.Rule-based systems
   Hand-designed program
   B.Classic machine learning
   Hand-designed feature
   Mapping from features
   C.Simple representation learning
   Features
   Mapping from features
   D.Deep learning
   Simple features
   More complex features
   Mapping from features

视频2 深度学习概述

1️⃣ 深度学习的“不能”
1.算法输出不稳定，容易被“攻击”
Ex：对抗样本，改变一个像素值。
2. 模型复杂度高，难以纠错和调试
3. 模型层级复合程度高，参数不透明
Ex：Inception（GoogLeNet），残差，门结构
Inception

残差（ResNet）

4.端到端训练方式对数据依赖性强，模型增量性差
$$Testloss-Trainingloss\le \sqrt{\frac{N}{m}}$$
m：训练样本
N：模型有效容量
5. 专注直观感知类问题，对开放性推理问题无能为力
6. 人类无法有效引入进行监督，机器偏见难以避免
2️⃣ 解释性 与 泛化性
3️⃣ M-P神经元
y = f(${\sum }_1^n$w_ix_i - $\Theta$)
4️⃣ 激活函数
1.线性函数（Ex：恒等函数）
2.斜面函数
3.阈值函数（Ex：阶跃函数）
4.符号函数
5️⃣ Sigmoid函数
y(x) = $\frac{1}{1+e^-x}$
y(x)’ = y(x)(1 - y(x))
6️⃣ 单层感知机

6️⃣ 多层感知机

7️⃣ 万有逼近定理
如果一个隐层包含足够多的神经元，三层前馈神经网络（输入-隐层-输出）能以任意精度逼近任意预定的连续函数。

更深、更宽，并不一定能增强效果。
8️⃣ 梯度消失

9️⃣ 误差反向传播
F(x) = f_n(f_n-1…f₂(f(x) * $\Theta$₁ + b) * $\Theta$₂ +b)…)

Part2 代码学习

Pytorch中的基本操作

import torch
x = torch.tensor(666)
print(x)

# 一维
x = torch.tensor([1, 2, 3, 4, 5, 6])
# 二维
# 二行三列的矩阵
x = torch.ones(2, 3)
# 任意维度
x = torch.ones(2,3, 4)
# 创建一个空张量, x行y列

x = torch.empty(x, y)

# 创建一个随机初始化的张量

x = torch.rand(5, 3)

# 创建一个全0的张量，里面的数据类型为 long
x = torch.zeros(5,3,dtype=torch.long)

# 用已知的张量初始化一个新的张量

y = x.new_ones(5,3）

# 重新定义原来tensor的类型

z = torch.randn_like(x, dtype = torch.float)

# 输出

print(m\[0][2])

print(m[:, 1])

# 矩阵相乘

m @ v

# 矩阵转置（3种方法）

print(m.t())

print(m.transpose(0, 1))

print(m.permute(1, 0))

Spiral classifciation

import random
import torch
from torch import nn, optim
import math
from IPython import display
from plot_lib import plot_data, plot_model, set_default

# 因为colab是支持GPU的，torch 将在 GPU 上运行
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('device: ', device)

# 初始化随机数种子。神经网络的参数都是随机初始化的，
# 不同的初始化参数往往会导致不同的结果，当得到比较好的结果时我们通常希望这个结果是可以复现的，
# 因此，在pytorch中，通过设置随机数种子也可以达到这个目的
seed = 12345
random.seed(seed)
torch.manual_seed(seed)

N = 1000  # 每类样本的数量
D = 2  # 每个样本的特征维度
C = 3  # 样本的类别
H = 100  # 神经网络里隐层单元的数量

多GPU时

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

model = Model()

if torch.cuda.device_count() > 1:

  model = nn.DataParallel(model，device_ids=[0,1,2])

model.to(device)

X = torch.zeros(N * C, D).to(device)
Y = torch.zeros(N * C, dtype=torch.long).to(device)
for c in range(C):
    index = 0
    t = torch.linspace(0, 1, N) # 在[0，1]间均匀的取10000个数，赋给t
    # 下面的代码不用理解太多，总之是根据公式计算出三类样本（可以构成螺旋形）
    # torch.randn(N) 是得到 N 个均值为0，方差为 1 的一组随机数，注意要和 rand 区分开
    inner_var = torch.linspace( (2*math.pi/C)*c, (2*math.pi/C)*(2+c), N) + torch.randn(N) * 0.2
    
    # 每个样本的(x,y)坐标都保存在 X 里
    # Y 里存储的是样本的类别，分别为 [0, 1, 2]
    for ix in range(N * c, N * (c + 1)):
        X[ix] = t[index] * torch.FloatTensor((math.sin(inner_var[index]), math.cos(inner_var[index])))
        Y[ix] = c
        index += 1

print("Shapes:")
print("X:", X.size())
print("Y:", Y.size())