深度学习实践与地统计学入门【二】

文章目录

• 1 深度学习实践
• • 1.1 易混概念
  • • 1.1.1维度
    • 1.1.2求和降维
    • 1.1.3非降维求和
    • 1.1.4矩阵乘法
    • 1.1.5范数
  • 1.2 房价预测实践
  • • 1.2.1数据流水线
    • 1.2.2模型
    • 1.2.3损失函数
    • 1.2.4小批量随机梯度下降优化器
    • 1.2.5训练
    • 1.2.6估计误差
• 2 气象大数据处理
• • 2.1 Hadoop

1 深度学习实践 1.1 易混概念 1.1.1维度

• 向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量
• 张量的维度用来表示张量具有的轴数，张量的某个轴的维数就是这个轴的长度

1.1.2求和降维

指定张量沿哪一个轴来通过求和降低维度A_sum_axis0 = A.sum(axis=0)

1.1.3非降维求和

调用cumsum函数做非降维求和，此函数不会沿任何轴降低输入张量的维度A.cumsum(axis=0)

1.1.4矩阵乘法

可以使用矩阵-向量积来描述在给定前一层的值时，求解神经网络每一层所需的复杂计算。对矩阵A和向量 x x x调用np.dot(A,x)时，会执行矩阵-向量积。

torch.mv(A, x)#矩阵-向量积
torch.mm(A, B)#矩阵-矩阵乘法

1.1.5范数

非正式地说，一个向量的范数告诉我们一个向量有多大。 这里考虑的大小（size）概念不涉及维度，而是分量的大小。在线性代数中，向量范数是将向量映射到标量的函数 f f f。
范数的三条性质：

1. 如果我们按常数因子 훼 缩放向量的所有元素，其范数也会按相同常数因子的绝对值缩放： f ( α x ) = ∣ α ∣ f ( x ) f(alpha x)=|alpha|f(x) f(αx)=∣α∣f(x)
2. 三角不等式: f ( x + y ) < = f ( x ) + f ( y ) f(x+y)<=f(x)+f(y) f(x+y)<=f(x)+f(y)
3. 范数必须是非负的: f ( x ) > = 0 f(x)>=0 f(x)>=0

L 0 L_0 L0​范数指一个向量里非零元素的个数，表示其稀疏度
L 1 L_1 L1​范数表示为向量元素的绝对值之和torch.abs(x).sum()
L 2 L_2 L2​范数表示为向量元素平方和的平方根，也是欧几里得距离torch.norm(x)
更一般的范数：弗罗贝尼乌斯范数

1.2 房价预测实践

定义卧室个数，卫生间和居住面积为x1，x2，x3；定义成交价为关键因素的加权和，表示为y=w1x1+w2x2+w3x3+b

1.2.1数据流水线

导入库

%matplotlib inline       
import random
import torch
from d2l import torch as d2l # 从d2l中选取torch命名为d2l

根据带有噪声的线性模型构造一个数据集，使用参数 w = [ 2 , − 3 , 4 ] T , b = 4.2 w=[2,-3,4]^T,b=4.2 w=[2,−3,4]T,b=4.2和噪声项ε来生成数据集及其标签： y=Xw+b+ε

def synthetic_data(w, b, num_examples):      # 生成y=Xw+b+ε
    
    X = torch.normal(0, 1, (num_examples, len(w))) # 方差为0，均值为1，样本个数为w的列数
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, y.shape)         # 这里是加了噪音，均值为0，方差为0.01，形状同y
    return X, y.reshape((-1, 1))               # y用列向量返回     -1表示所有元素个数         
 
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000) 

print('features:', features[0],'nlabel:', labels[0]) # 查看第0个样本

得到结果
features: tensor([-1.2667, -2.2449])
label: tensor([9.2819])

d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1);   #散点图展示数据

散点图展示数据

定义一个data_iter函数， 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。每个小批量包含一组特征和标签。

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)  #打乱数据下标
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)])   #间隔batch_size取样，如果最后一组不够，就取样本个数num_examples
        yield features[batch_indices], labels[batch_indices] #yield 返回一个值，然后下次继续从返回位置开始

batch_size = 10
 
for X, y in data_iter(batch_size, features, labels):
    print(X, 'n', y)
    break

取样结果
tensor([[-0.5324, -1.6136],
[-2.6294, -0.9994],
[-0.4457, 0.6833],
[ 1.4551, -1.5200],
[-1.9652, 0.9456],
[-0.9287, -0.4363],
[ 0.3737, 0.2971],
[ 0.2519, -0.4232],
[-0.0633, -0.2671],
[-1.4967, 0.5712]])
tensor([[ 8.6099],
[ 2.3372],
[ 0.9755],
[12.2857],
[-2.9439],
[ 3.8236],
[ 3.9451],
[ 6.1456],
[ 4.9711],
[-0.7451]])

1.2.2模型

定义初始化模型参数

w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

定义线性回归模型

def linreg(X, w, b):
    return torch.matmul(X, w) + b

1.2.3损失函数

def squared_loss(y_hat, y): 
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2       #防止预测值和真实值类型不同，转换类型
    #loss函数：1/2(y_hat-y)²

1.2.4小批量随机梯度下降优化器

def sgd(params, lr, batch_size): 
    with torch.no_grad():      
        for param in params:  #对于参数中，每一个参数
            param -= lr * param.grad / batch_size   #参数-=学习率*参数梯度/批量
            param.grad.zero_()    # 梯度手动归零

1.2.5训练

lr = 0.03
num_epochs = 3
net = linreg         #网络：线性回归
loss = squared_loss  #loss函数：平方损失
 
for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):  # `X`和`y`的小批量损失
        l = loss(net(X, w, b), y)  
        # 因为`l`形状是(`batch_size`, 1)，而不是一个标量。`l`中的所有元素被加到一起，
        # 并以此计算关于[`w`, `b`]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():           # 计算每次更新后的损失函数
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

epoch 1, loss 0.026487
epoch 2, loss 0.000090
epoch 3, loss 0.000050

1.2.6估计误差

比较真实参数和通过训练学到的参数，来评估训练的成功程度

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

w的估计误差: tensor([-0.0001, 0.0008], grad_fn=)
b的估计误差: tensor([0.0006], grad_fn=)

2 气象大数据处理

适合监测站点的大数据技术相关理论：分布式处理框架Hadoop、分布式数据库Hbase、数据仓库Hive和Sqoop

2.1 Hadoop

Hadoop是一个分布式系统基础架构，解决海量数据的存储和海量数据的分析计算问题。Hadoop能容灾备份、动态增加和删除服务器集群、集群并行计算加快任务处理速度、能够自动将失败的任务重新分配。

Hadoop的组成如上图所示，各个模块介绍如下：

1. HDFS模块
   HDFS将大文件分块后进行分布式存储，突破了服务器硬盘容量的限制，解决了单台机器无法存储超过硬盘容量大小的文件这一问题。HDFS是个相对独立的模块，可以为Yarn提供服务，也可以为Hbase等其他模块提供服务。
   HDFS是一个主从结构(Master/Slave)的体系，集群中的节点有两种类型：DataNode节点和NameNode节点。

• NameNode(NN)：记录每个文件的块列表，以及每一个文件块都存储在什么位置。NameNode节点在部署时一般仅有一个，它是主控服务器，执行文件系统的命名空间打开、关闭、重命名文件或目录等操作，维护和管理着文件系统元数据信息，同时还需要决定数据块映射到具体NameNode节点上。

元数据包括文件名，文件目录结构，文件属性（生成时间、副本数、文件权限）等

• DataNode(DN)：具体存储数据。DataNode节点在部署时可以有多个，存储运行过程中需要调度的实际数据，以及块数据的校验和。在接收NameNode的指令后，DataNode执行数据块的创建、复制和删除等操作，同时还要处理客户的读写请求。
• Secondary NameNode(2NN)：防止NameNode挂掉导致集群崩溃，在NameNode挂掉时，代理其工作。每隔一段时间对NameNode元数据备份。

2. Yarn模块
   Yarn是一个通用的资源协同和任务调度框架，是为了解决Hadoop1.x中MapReduce里NameNode负载太大等问题而创建的一个框架。(见图1)
   不仅可以运行MapReduce，还可以运行Spark、Storm等其他计算框架。
3. MapReduce模块
   MapReduce是一个计算框架，它给出了一种数据处理的方式，即“任务的分解和结果的汇总”，通过Map映射阶段、Reduce散列阶段来分布式地流式处理数据。Map把一个工作分解成多个小任务，可以认为从HDFS中读取的待处理的海量环境数据，把它分割成很多小数据集片段。它只适用于大数据的离线处理，对实时性要求很高的应用不适用。