^-^
Transformer
  1. torch 基础用法
  2. Transformer 相关
    1. self attention
    2. multi-head self attention
  3. 基础操作
    1. 反向传播
    2. LN
    3. BN
    4. 搭建 MLP
    5. 搭建 CNN
    6. numpy 线性回归随机梯度下降
  4. CV 相关
    1. 二维卷积
    2. 池化
  5. 机器学习相关
    1. knn
    2. kmeans
  6. 常见算法题
    1. leetcode hot 100
      1. 160 相交链表
      2. 236 LCA
      3. 234 回文链表
      4. 739 每日温度
      5. 221 最大正方形

速通各种代码, 需要写出能直接跑的代码, 不能用 copilot.

参考:

torch 基础用法

  1. torch.mul 对于一维张量是点积, 高维张量中是矩阵相乘
  2. @
  3. torch.bmm 矩阵相乘,
  4. .transpose(dim_1, dim_2): 交换两个维度, 参数为两个维度的索引
  5. .view() : 将张量变成指定的形状, 需要确保数量对应一致
  6. nn.Parameter:
  7. torch.empty(): 创建使用未初始化值填满的张量.

Transformer 相关

很久没好好看过 torch 了, 需要总结下基础用法.

self attention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import torch
import torch.nn as nn

class SA(nn.Module):
    def __init__(self, scale):
        super().__init__()
        self.scale = scale
        self.softmax = nn.Softmax(dim=2)
    def forward(self, q, k, v, mask = None):
        u = torch.bmm(q, k.transpose(1,2))
        u /= self.scale
        if mask is not None:
            u = u.mask_fill(mask, -torch.inf)
        attn = self.softmax(u)
        out = torch.bmm(attn, v)
        
        return attn, out

multi-head self attention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import torch
import torch.nn as nn
import math

class MSA(nn.Module):
    def __init__(self, num_heads, embed_size):
        super(MSA, self).__init__()
        self.num_heads = num_heads
        self.embed_size = embed_size
        self.head_dim = embed_size // num_heads
        
        self.q_proj = nn.Linear(self.embed_size, self.embed_size, bias=False)
        self.k_proj = nn.Linear(self.embed_size, self.embed_size, bias=False)
        self.v_proj = nn.Linear(self.embed_size, self.embed_size, bias=False)
        self.o_proj = nn.Linear(self.embed_size, self.embed_size, bias=False)
        self.softmax = nn.Softmax(dim=-1)
    def forward(self, x, mask=None):
        '''
        x.shape [bsz, l, _]
        '''
        bsz, l, _ = x.shape
        q=self.q_proj(x).view(bsz, l, num_heads, self.head_dim).transpose(1,2)
        k=self.k_proj(x).view(bsz, l, num_heads, self.head_dim).transpose(1,2)
        v=self.k_proj(x).view(bsz, l, num_heads, self.head_dim).transpose(1,2)
        
        u = torch.matmul(q, k.transpose(-2, -1))/math.sqrt(self.head_dim)
        if mask is not None:
            u.mask_fill(mask == 0, -torch.inf)
        attn = self.softmax(u)
        attn_o = torch.matmul(attn, v)
        attn_o = attn_o.transpose(1,2).contiguous().view(bsz, l, self.embed_size)
        
        out = self.o_proj(attn_o)
        return out
        
embed_size = 256
num_heads = 8
l = 10
bsz = 4

x = torch.randn(bsz, l, embed_size)
msa = MSA(num_heads, embed_size)
mask = None
out = msa(x, mask)
print(out.shape)

基础操作

反向传播

【深度学习理论】纯公式手推+代码撸——神经网络的反向传播+梯度下降 - 知乎 (zhihu.com)

LN

Transformer中的归一化(五)：Layer Norm的原理和实现 & 为什么Transformer要用LayerNorm - 知乎 (zhihu.com)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import torch
from torch import nn

class LN(nn.Module):
    def __init__(self, norm_shape, eps : float = 1e-5, affine : bool = True):
        super(LN, self).__init__()
        self.norm_shape = norm_shape
        self.eps = eps
        self. affine = affine
        if self.affine:
            self.weight = nn.Parameter(torch.empty(self.norm_shape))
            self.bias = nn.Parameter(torch.empty(self.norm_shape))
    def forward(self, x):
        dims = [-(i+1) for i in range(len(self.norm_shape))]
        x_mean = x.mean(dim=dims, keepdims=True)
        x_mean_2 = (x**2).mean(dim=dims, keepdims=True)
        var = x_mean_2 - x_mean**2
        x_norm = (x - x_mean) / torch.sqrt(var + self.eps)
        if self.affine:
            x_norm = self.weight * x_norm + self.bias
        return x_norm

x = torch.rand(2,3,4)
ln = LN(x.shape[1:],affine=False)
ln_torch = nn.LayerNorm(x.shape[1:],elementwise_affine=False)
x_norm = ln(x)
x_norm_torch = ln_torch(x)
print(x_norm)
print(x_norm_torch) # 结果完全一致

BN

详解Pytorch中的BatchNorm模块 | 天天教程 (foobarweb.net)

怎么网上的代码都是乱七八糟的.

按照 nn.Batchnorm1d, 对于三维张量, 应该是这样算的, 对于张量 , 其中 是通道数, 或者说特征数, 对 展平后的 上的向量求均值 方差 , 对 中的每个元素 , 一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
x = torch.tensor([
    [[1.0, 2.0, 3.0, 4.0],
     [5.0, 6.0, 7.0, 8.0],
     [9.0, 10.0, 11.0, 12.0]],

    [[13.0, 14.0, 15.0, 16.0],
     [17.0, 18.0, 19.0, 20.0],
     [21.0, 22.0, 23.0, 24.0]]
])
bn_torch = nn.BatchNorm1d(x.shape[1], affine=False)
x_bn_torch = bn_torch(x)
print(x_bn_torch)
# 输出
#tensor([[[-1.2288, -1.0650, -0.9012, -0.7373],
#         [-1.2288, -1.0650, -0.9012, -0.7373],
#         [-1.2288, -1.0650, -0.9012, -0.7373]],
#
#        [[ 0.7373,  0.9012,  1.0650,  1.2288],
#         [ 0.7373,  0.9012,  1.0650,  1.2288],
#         [ 0.7373,  0.9012,  1.0650,  1.2288]]])
1
2
3
4
5
tmp = x[:,0,:] # 形状为 [2,4] 
print(tmp.shape)
print(tmp.mean(), tmp.mean().shape)
print(tmp.var(unbiased=False).sqrt(), tmp.var(unbiased=False).shape)
print((tmp - tmp.mean()) / (tmp.var(unbiased=False).sqrt()+1e-5))

输出:

1
2
3
4
tensor(8.5000) torch.Size([])
tensor(6.1033) torch.Size([])
tensor([[-1.2288, -1.0650, -0.9012, -0.7373],
        [ 0.7373,  0.9012,  1.0650,  1.2288]])

搭建 MLP

搭建 CNN

numpy 线性回归随机梯度下降

CV 相关

二维卷积

池化

机器学习相关

knn

kmeans

常见算法题

实战中总结的125道面试高频算法题！再也不怕手撕代码了！---校招干货_牛客博客 (nowcoder.net)

Xiangyu-CAS/CV_interview_in_a_day: 一天准备好CV算法面试，个人经过面试阿里，字节，美团，滴滴，百度，快手等公司后，整理的面经，只包含高频内容,保证在一天之内可以放心食用完毕。 (github.com)

leetcode hot 100

大部分题只写思路. 主要做 middle.

160 相交链表

遍历两次链表获取长度, 然后挪到同一起点, 再继续遍历一次, 指针相等时即为相交处.

236 LCA

应该不用倍增.

获取每个节点的高度, 然后往上移动到同一高度, 再同时往上移, 相遇处即为最近公共祖先.

234 回文链表

空间复杂度: 开一个辅助数组.

空间复杂度: 快慢指针. 快节点到达尾部时慢节点刚好到达中间, 此时可以反转后半部分链表, 再分别从头节点尾节点遍历即可判断是否回文.

739 每日温度

暴力 , 过不了 . 单调栈.

单调队列还没学会.

221 最大正方形

, 估计是动态规划.

状态设计: 表示矩形 中只包含 的最大正方形的边长. ? 明天再看.

状态转移: 取决于

2024-06-18 该篇文章被 Baoduo Xu 归为分类: AI

以上
©
Too Young Too Naive 本站由Hexo驱动｜使用Hexo-theme-A4主题