自学深度学习Pytorch——day01

1.初识Pytorch基本框架

1.1 Pytorch与Tensorflow对比

pytorch的特点： 简洁性、动态计算、visdom、部署不方便

Tensorflow的特点： 接口复杂、静态图、Tensorboard、部署方便

静态图与动态图

动态图：编好程序即可执行；代码编程简单、调试直观
静态图：先搭建计算图，后运行；允许编译器进行优化

1.2 Pytorch的发展

2002年Torch基于Lua语言
2016.19发布PyTorch 0.1，2018.12发布PyTorch 1.0基于CAFFE2后端

Google
Theano->Tensorflow 1->Tensorflow 2+Keras

Facebook
Torch7->PyTorch->PyTorch+caffe

2.机器学习中的分类与回归问题

分类任务：输出值为离散值的概率值
回归任务：输出值为连续值

2.1 机器学习问题的构成元素

样本、模型、训练、测试、推理

样本：属性+标签（x）
模型：f(x) = wx + b
训练：求解w、b
测试：评价模型

2.2 简单回归问题

假设模型为：y = w * x + b + e（e为噪声，e~N（0.01,1））

目标函数（损失函数）：loss = （WX + b - y）^2，求使loss最小值的W与b。

更新W与b：

回归问题实战

import numpy as np
import pandas as pd
from numpy import random

#计算损失（均方误差）
def compute_error_for_line_given_points(b,w,points):
    totalError = 0
    for i in range(0,len(points)):
        x = points[i,0]
        y = points[i,1]
        totalError += (y - (w * x + b)) ** 2
    return totalError / float(len(points))

#更新参数，使参数沿着梯度反方向进行更新
def step_gradient(b_current,w_current,points,learingRate):
    b_gradient = 0
    w_gradient = 0
    N = float(len(points))
    for i in range(0,len(points)):
        x = points[i,0]
        y = points[i,1]
        b_gradient += -(2/N) * (y - (w_current * x) + b_current)
        w_gradient += -(2/N) * x * (y-((w_current * x) + b_current))
    new_b = b_current - (learingRate * b_gradient)
    new_w = w_current - (learingRate * w_gradient)
    return [new_b,new_w]

#多轮迭代，使得损失值最小化，得到最终的权重参数
def gradient_descent_runner(points,starting_b,starting_w,
                            learning_rate,num_iterations):
    b = starting_b
    w = starting_w
    for i in range(num_iterations):
        b,w = step_gradient(b,w,np.array(points),learning_rate)
    return [b,w]

#生成100个y = 2 * x + 3 + e的函数点，存入CSV文件
def get_data():
    w = 2
    b = 3
    x_data = np.random.rand(100)
    error = np.random.randn(*x_data.shape)*0.05
    y_data = w * x_data + b + error
    x_data = x_data.reshape(100,1)
    y_data = y_data.reshape(100,1)

    a = np.concatenate((x_data,y_data),axis=1)
    #a = np.asarray([x_data,y_data])

    print(a.shape)

    np.savetxt("data.csv", a, delimiter=",")
    return None

#运行程序，读入数据，梯度下降迭代，得到权重参数
def run():
    points = np.genfromtxt("data.csv", delimiter=",")
    print(points)
    learning_rate = 0.0001
    initial_b = 0
    initial_w = 0
    num_iterators = 1000
    print("Starting gradient descent at b = {0} , m = {1} , error = {2}".
          format(initial_b,initial_w,compute_error_for_line_given_points(initial_b,initial_w,points)))
    print("Running......")
    [b,w] = gradient_descent_runner(points,initial_b,initial_w,learning_rate,num_iterators)
    print("After {0} iterations b = {1} , w = {2} , error = {3}".
          format(num_iterators,b,w,compute_error_for_line_given_points(b,w,points)))

if __name__ == '__main__':
    get_data()
    run()

2.3 分类问题

设激活函数为F(x)：
H1 = F(XW1 + b1)
H2 = F(XH1 + b2)
H3 = F(XH2 + b3)

目标函数：

3.Pytorch的基本概念与Tensor的基本操作

3.1 张量、变量、Module

张量（Tensor）：n阶数组（深度学习的样本数据可能是多维的）
变量：参数
nn.Module

3.2 Tensor与机器学习的基本概念

Tensor可以用于描述机器学习中的样本与模型。

3.3 Tensor的创建

创建Tensor示例：
示例1: Tensor创建

import torch

a = torch.Tensor([[1,2],[3,4]])
print(a)
print(a.type())

示例2：使用形状，随机创建Tensor

a = torch.Tensor(2,3)
print(a)
print(a.type())

示例3：创建全0或全1的Tensor

a = torch.zeros(2,2)
print(a)
a = torch.ones(2,2)
print(a)

示例4：继承形状的全0或全1的Tensor

b = torch.Tensor(2,2)
b = torch.ones_like(b)
print(b)
b = torch.zeros_like(b)
print(b)

示例5：创建初始化随机数的Tensor

a = torch.rand(2,2)
print(a)
a = torch.normal(mean=torch.rand(5),std=torch.rand(5))#正态分部，均值和标准差由自定义
print(a)
a = torch.Tensor(2,2).uniform_(-1,1)#[-1,1]的均匀分布随机值
print(a)

示例6：创建序列

a = torch.arange(0,11,3)
print(a)
a = torch.linsapce(2,10,4)#从[2,10]等间隔的4个数字
print(a)
a = torch.randperm(10)#[0,10)的随机打乱序列
print(a)

3.4 Tensor的属性

每一个Tensor都有torch.dtype、torch.device、torch.layout三种属性。
torch.device：Tensor对象存储的设备名称（cpu、cuda:0、cuda:1）
torch.layout：Tensor的内存布局的对象

定义稀疏的张量：

torch.sparse_coo_tensor
示例代码：

i = torch.tensor([[0,1,1],[2,0,2]])
v = torch.tensor([3,4,5],dtype = torch.float32)
x = torch.sparse_coo_tensor(i,v,[2,4])

print(a)

3.5 Tensor的算术运算

1.求和：

c = a + b
c = torch.add(a,b)
c = a.add(b)
c = a.add_(b)

前三种一致，第四种方式会将计算结果传给a

2.哈达玛积：对应元素相乘

c = a * b
c = torch.mul(a,b)
c = a.mul(b)

3.二维矩阵乘法运算

a = torch.ones(2,1)
b = torch.ones(1,2)
print(torch.mm(a,b))
print(a @ b)
print(torch.matmul(a,b))#三种方式等价

对于高维的Tensor，仅在最后的两个维度上做矩阵乘法，前面的维度必须保持一致

4.幂运算

print(torch.pow(a,2))
print(torch.exp(a))
print(a.sqrt())

5.对数运算

print(torch.log2(a))

3.6 in-place的概念和广播机制

in-place操作

就地操作：x = x + y（之前提到的add_、sub_等等）

广播机制

广播机制：张量参数可以自动扩展为相同大小

广播机制应满足的条件：
1.每个张量至少有一个维度
2.满足右对齐

例如torch.rand(2,1,1) + torch.rand(3) 最后会扩展为（2,1,3）维度的Tensor

3.7 Tensor的比较运算

3.8 Tensor高等操作

torch,sort(input,dim=None,descending=False,out=None)#对input进行排序
torch.kthvalue(input,k,dim=None,out=None)#沿着指定维度返回第k个最小值及索引值
torch.isfinite(tensor)/torch.isnan(tensor)/torch.isinf(tensor)#判断是否有界、是否有空值、是否无界

3.9 Tensor的三角函数

3.10 Tensor中的其他数学函数

4.Pytorch的数学问题

4.1 Tensor中统计学方法

示例：

import torch

a = torch.rand(2,2)

print(a)

print(torch.mean(a))
print(torch.sum(a))
print(torch,prod(a))

print(torch.mean(a,dim=0))
print(torch.sum(a,dim=0))
print(torch,prod(a,dim=0))

4.2 分布函数

distributions包含可参数化的概率分布和采样函数
得分函数：强化学习中策略梯度方法的基础
pathwise derivative估计器：变分自动编码器中的重新参数化技巧

4.3 随机抽样

定义随机种子：
torch.manual_seed(seed)
定义随机数满足的分布：
torch.normal()

import torch
torch.manual_seed(1)
mean = torch.rand(1,2)
std = torch.rand(1,2)
print(torch.normal(mean,std))

4.4 范数运算

范数：
1.在泛函分析中，它定义在赋范线性空间中，并满足一定的条件，即①非负性；②齐次性；③三角不等式。
2.常用来度量某个向量空间中的每个向量的长度或大小。

API：
torch.dist(input,other,p=2)#计算p范数
torch.norm()#计算2范数

4.5 Tensor中的矩阵分解

特征值分解（EVD）

特征值分解： 将矩阵分解为由其特征值和特征向量表示的矩阵之积的方法。

目标：A = QΣQ^(-1)

PCA与特征值分解：
PCA：将n维特征映射到k维上，这k维时全新的正交特征也被称为主成分，在原有n维特征的基础上重新构造出来的k维特征。

PCA算法的优化目标：
1.降维后同一维度的方差最大
2.不同维度之间的相关性为0
3.协方差矩阵

奇异值分解（SVD）

当矩阵不是方阵的时候，使用奇异值分解。

目标：A = UΣV^(T)

LDA：
同类别间距尽可能小，不同类别间距尽可能大。

J = 类间/类内（不断优化，使J的值变大）