第一周学习：深度学习和pytorch基础

part1 视频学习

绪论

人工智能

使一部机器像人一样进行感知、认知、决策、执行的人工程序或系统

逻辑演绎vs归纳总结

知识工程/专家系统

1. 基于手工设计规则建立专家系统
2. 结果容易解释
3. 系统构建费时费力
4. 依赖专家主观经验，难以保证一致性和准确性

机器学习

1. 基于数据自动学习
2. 人工繁杂工作，但结果可能不易解释
3. 提高信息处理的效率，且准确率较高
4. 来源于真实数据，减少人工规则主观性，可信度
   

机器学习的定义

1. 最常用定义：计算机系统能够利用经验提高自身的性能
2. 可操作定义：机器学习本质是一个基于经验数据的函数估计问题
3. 统计学定义：提取重要模式、趋势，并理解数据，即从数据中学习
   总结：从数据中自动提取知识

模型分类

数据标记：监督学习模型（半监督学习模型）、无监督学习模型（强化学习模型）
数据分布：参数模型、非参数模型
建模对象：判别模型、生成模型

数据标记：监督学习模型、无监督学习模型

监督学习的样本具有标记（输出目标）、无监督学习的样本没有标记。

数据分布：参数模型、非参数模型

参数模型优点：数据需求少、训练快速；缺点：模型复杂度有限，与真实目标函数拟合度小
非参数模型优点：对数据适应性强，可拟合不同的函数形式； 缺点：数据需求大、容易过拟合

建模对象：判别模型、生成模型

生成模型：朴素贝叶斯、隐马尔可夫、马尔科夫随机场
判别模型：SVM、逻辑回归、条件随机场、决策树

人工智能>机器学习>深度学习

传统机器学习与深度学习

传统机器学习：

深度学习：

神经网络结构的发展

流行机器学习模型的演变

神经网络的三起两落

深度学习的不能

1. 算法输出不稳定，容易被“攻击”
2. 模型复杂度高，难以纠错和调试
3. 模型层级复合程度高，参数不透明
4. 端到端训练方式对数据依赖性强，模型增量性差
5. 专注直观感知类问题，对开放性推理问题无能为力
6. 人类知识无法有效引入进行监督，机器偏见难以避免

深度学习概述

激活函数

没有激活函数相当于矩阵相乘，多层和一层一样，只能拟合线性函数

万有逼近定理

如果一个隐层包含足够多的神经元，三层前馈神经网络（输入-隐层-输出）能以任意精度逼近任意预定的连续函数。
双隐层感知器逼近非连续函数
当隐层足够宽时，双隐层感知器（输入-隐层1-隐层2-输出）可以逼近任意非连续函数：可以解决任何复杂的分类问题。

深层神经网络的问题：梯度消失

增加深度会造成梯度消失，误差无法传播；多层网络容易陷入局部极值，难以训练。
三层神经网络是主流，预训练、新激活函数使深度成为可能。

part2 代码练习

pytorch基础练习

定义数据

import torch
x=torch.tensor(666)
x=torch.tensor([1,2,3,4,5,6])
print(x)
x=torch.ones(2,3)
x=tensor.empty(5,3)
x=tensor.rand(5,3)
y=x.new_ones(5,3)
print(y)                  

定义操作

基本运算，加减乘除，求幂求余
布尔运算，大于小于，最大最小
线性运算，矩阵乘法，求模，求行列式
基本运算包括： abs/sqrt/div/exp/fmod/pow ，及一些三角函数 cos/ sin/ asin/ atan2/ cosh，及 ceil/round/floor/trunc 等具体在使用的时候可以百度一下
布尔运算包括： gt/lt/ge/le/eq/ne，topk, sort, max/min
线性计算包括： trace, diag, mm/bmm，t，dot/cross，inverse，svd 等

m = torch.Tensor([[2, 5, 3, 7],
                  [4, 2, 1, 9]])
print(m.size(0), m.size(1), m.size(), sep=' -- ')
print(m.numel())
print(m[0][2])
print(m[:, 1])
print(m[0, :])

v = torch.arange(1, 5)
print(v)
print(m @ v)
print(m[[0],:] @ v)
m + torch.rand(2, 4)
print(m.t())
print(m.transpose(0, 1))
torch.linspace(3, 8, 20)

from matplotlib import pyplot as plt
plt.hist(torch.randn(1000).numpy(), 100);

螺旋数据分类

!wget https://raw.githubusercontent.com/Atcold/pytorch-Deep-Learning/master/res/plot_lib.py

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
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('device: ', device)

seed = 12345
random.seed(seed)
torch.manual_seed(seed)

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

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) 
    inner_var = torch.linspace( (2*math.pi/C)*c, (2*math.pi/C)*(2+c), N) + torch.randn(N) * 0.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())

plot_data(X, Y)

1.构建线性模型分类

learning_rate = 1e-3
lambda_l2 = 1e-5

model = nn.Sequential(
    nn.Linear(D, H),
    nn.Linear(H, C)
)
model.to(device) 

criterion = torch.nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=lambda_l2)

for t in range(1000):
    y_pred = model(X)
    loss = criterion(y_pred, Y)
    score, predicted = torch.max(y_pred, 1)
    acc = (Y == predicted).sum().float() / len(Y)
    print('[EPOCH]: %i, [LOSS]: %.6f, [ACCURACY]: %.3f' % (t, loss.item(), acc))
    display.clear_output(wait=True)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

print(y_pred.shape)
print(y_pred[10, :])
print(score[10])
print(predicted[10])

print(model)
plot_model(X, Y, model)

2.构建两层神经网络分类

learning_rate = 1e-3
lambda_l2 = 1e-5
model = nn.Sequential(
    nn.Linear(D, H),
    nn.ReLU(),
    nn.Linear(H, C)
)
model.to(device)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=lambda_l2) # built-in L2

for t in range(1000):
    y_pred = model(X)
    loss = criterion(y_pred, Y)
    score, predicted = torch.max(y_pred, 1)
    acc = ((Y == predicted).sum().float() / len(Y))
    print("[EPOCH]: %i, [LOSS]: %.6f, [ACCURACY]: %.3f" % (t, loss.item(), acc))
    display.clear_output(wait=True)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# Plot trained model
print(model)
plot_model(X, Y, model)