【Megatron-DeepSpeed】张量并行工具代码mpu详解(三):张量并行层的实现及测试

相关博客
【Megatron-DeepSpeed】张量并行工具代码mpu详解(三):张量并行层的实现及测试
【Megatron-DeepSpeed】张量并行工具代码mpu详解(一):并行环境初始化
【Megatron-DeepSpeed】张量并行工具代码mpu详解(二):Collective通信操作的封装mappings
【深度学习】【分布式训练】DeepSpeed:AllReduce与ZeRO-DP
【深度学习】混合精度训练与显存分析
【深度学习】【分布式训练】Collective通信操作及Pytorch示例
【自然语言处理】【大模型】大语言模型BLOOM推理工具测试
【自然语言处理】【大模型】GLM-130B:一个开源双语预训练语言模型
【自然语言处理】【大模型】用于大型Transformer的8-bit矩阵乘法介绍
【自然语言处理】【大模型】BLOOM:一个176B参数且可开放获取的多语言模型

Megatron-DeepSpeed:张量并行的实现及测试

​ Megatron-DeepSpeed是DeepSpeed版本的NVIDIA Megatron-LM。像BLOOM、GLM-130B等主流大模型都是基于Megatron-DeepSpeed开发的。这里以BLOOM版本的Megetron-DeepSpeed为例,介绍其模型并行代码mpu的细节(位于megatron/mpu下)。

​ 理解该部分的代码需要对模型并行的原理以及集合通信有一定的理解,可以看文章:

  • 【深度学习】【分布式训练】Collective通信操作及Pytorch示例
  • 【深度学习】【分布式训练】一文捋顺千亿模型训练技术:流水线并行、张量并行和3D并行
  • 【深度学习】【分布式训练】DeepSpeed:AllReduce与ZeRO-DP

强烈建议阅读,不然会影响本文的理解:

  • 【Megatron-DeepSpeed】张量并行工具代码mpu详解(一):并行环境初始化
  • 【Megatron-DeepSpeed】张量并行工具代码mpu详解(二):Collective通信操作的封装mappings

阅读建议:

  1. 本文仅会解析核心代码,并会不介绍所有代码;
  2. 本文会提供一些测试脚本来展现各部分代码的功能;
  3. 建议实际动手实操来加深理解;
  4. 建议对Collective通信以及分布式模型训练有一定理解,再阅读本文;

一、总览

​ mpu目录下核心文件有:

  • initialize.py:负责数据并行组、张量并行组和流水线并行组的初始化,以及获取与各类并行组相关的信息;
  • data.py:实现张量并行中的数据广播功能;
  • cross_entropy.py:张量并行版本的交叉熵;
  • layers.py:并行版本的Embedding层,以及列并行线性层和行并行线性层;
  • mappings.py:用于张量并行的通信操作;

二、1D张量并行原理

​ Megatron-DeepSpeed中的并行是1D张量并行,这里做简单的原理介绍。希望更深入全面的理解并行技术,可以阅读上面“千亿模型训练技术”的文章。
请添加图片描述

​ 以全链接层 Y = X A Y=XA Y=XA为例,介绍1D张量并行。其中, X X X Y Y Y是输入和输出向量, A A A是权重矩阵。总量来说1D张量并行可以分为列并行和行并行(以权重矩阵的分割方式命名),上图展示了两种并行。

  • 列并行

    将矩阵行列划分为n份(不一定必须相等大小)可以表示为 A = [ A 1 , A 2 , … , A n ] A=[A_1,A_2, \dots, A_n] A=[A1,A2,,An],那么矩阵乘法表示为
    X A = X [ A 1 , A 2 , … , A n ] = [ X A 1 , X A 2 , … , X A n ] XA=X[A_1,A_2,\dots,A_n]=[XA_1,XA_2,\dots,XA_n] XA=X[A1,A2,,An]=[XA1,XA2,,XAn]
    显然,仅需要对权重进行划分

  • 行并行

    对权重进行划分,那么必须对输入矩阵也进行划分。假设要将 A A A水平划分为 n n n份,则输入矩阵 X X X必须垂直划分为 n n n份,矩阵乘法表示为
    X A = [ X 1 , X 2 , … , X n ] [ A 1 A 2 … A n ] = X 1 A 1 + X 2 A 2 + ⋯ + X n A n XA=[X_1,X_2,\dots,X_n] \left[ \begin{array}{l} A_1 \\ A_2 \\ \dots \\ A_n \end{array} \right] = X_1A_1+X_2A_2+\dots+X_nA_n XA=[X1,X2,,Xn] A1A2An =X1A1+X2A2++XnAn

三、张量并行的实现及测试

1. 列并行

​ 列并行在前向传播时,张量并行组中的进程独立前向传播即可。假设张量并行度为2,则神经网络的前向传播可以简单表示为:
loss = f ( Y ) = f ( [ Y 1 , Y 2 ] ) = f ( [ X A 1 , X A 2 ] ) \begin{aligned} \text{loss}&=f(Y) = f([Y_1,Y_2]) \\ &=f([XA_1,XA_2]) \\ \end{aligned} loss=f(Y)=f([Y1,Y2])=f([XA1,XA2])
反向传播时, loss \text{loss} loss对输入 X X X的梯度为
KaTeX parse error: Undefined control sequence: \part at position 8: \frac{\̲p̲a̲r̲t̲ ̲f}{\part X}=\fr…
因此,反向传播时需要对张量并行组中各个独立的梯度进行求和。

源代码

class ColumnParallelLinear(torch.nn.Module):"""列并行线性层.线性层定义为Y=XA+b. A沿着第二维进行并行,A = [A_1, ..., A_p]参数:input_size: 矩阵A的第一维度.output_size: 矩阵A的第二维度.bias: 若为true则添加bias.gather_output: 若为true,在输出上调用all-gather,使得Y对所有GPT都可访问.init_method: 随机初始化方法.stride: strided线性层."""def __init__(self, input_size, output_size, bias=True, gather_output=True,init_method=init.xavier_normal_, stride=1,keep_master_weight_for_test=False,skip_bias_add=False):super(ColumnParallelLinear, self).__init__()self.input_size = input_sizeself.output_size = output_sizeself.gather_output = gather_output# 获得张量并行组的world_sizeworld_size = get_tensor_model_parallel_world_size()# 按照张量并行度(world_size)划分输出维度self.output_size_per_partition = divide(output_size, world_size)self.skip_bias_add = skip_bias_add# Parameters.# Note: torch.nn.functional.linear 执行 XA^T+bargs = get_args()if args.use_cpu_initialization:# 初始化张量. 若完整权重矩阵A为n*m,张量并行度为k,这里初始化的张量为n*(m/k)# 也就是张量并行组中的进程各自初始化持有的部分张量self.weight = Parameter(torch.empty(self.output_size_per_partition,self.input_size,dtype=args.params_dtype))# 使用init_method对权重矩阵self.weight进行随机初始化(CPU版)# self.master_weight在测试中使用,这里不需要关注self.master_weight = _initialize_affine_weight_cpu(self.weight, self.output_size, self.input_size,self.output_size_per_partition, 0, init_method,stride=stride, return_master_weight=keep_master_weight_for_test)else:self.weight = Parameter(torch.empty(self.output_size_per_partition, self.input_size,device=torch.cuda.current_device(), dtype=args.params_dtype))# 使用init_method对权重矩阵self.weight进行随机初始化(GPU版)_initialize_affine_weight_gpu(self.weight, init_method,partition_dim=0, stride=stride)if bias:# 实例化一个biasif args.use_cpu_initialization:self.bias = Parameter(torch.empty(self.output_size_per_partition, dtype=args.params_dtype))else:self.bias = Parameter(torch.empty(self.output_size_per_partition,device=torch.cuda.current_device(),dtype=args.params_dtype))# 将张量并行的相关信息追加至self.biasset_tensor_model_parallel_attributes(self.bias, True, 0, stride)# bias初始化为0with torch.no_grad():self.bias.zero_()else:self.register_parameter('bias', None)def forward(self, input_):# 前向传播时input_parallel就等于input_# 反向传播时在张量并在组内将梯度allreduceinput_parallel = copy_to_tensor_model_parallel_region(input_)bias = self.bias if not self.skip_bias_add else Noneoutput_parallel = F.linear(input_parallel, self.weight, bias)if self.gather_output:# 收集张量并行组内的张量并进行拼接# 此时,output是非张量并行情况下前向传播的输出# 张量并行组中的进程都持有完全相同的outputoutput = gather_from_tensor_model_parallel_region(output_parallel)else:# 此时,output是张量并行情况下的前向传播输出# 张量并行组中的进程持有不同的outputoutput = output_paralleloutput_bias = self.bias if self.skip_bias_add else Nonereturn output, output_bias

测试代码

​ 测试遵循文章【Megatron-DeepSpeed】张量并行工具代码mpu详解(一):并行环境初始化 中的设置,张量并行度为2,且流水线并行度为2。

def test_column_parallel_linear():global_rank = torch.distributed.get_rank()tensor_model_parallel_size = mpu.get_tensor_model_parallel_world_size()# 设置随机数种子seed = 12345set_random_seed(seed)# 张量并行组中,各个进程持有张量的input_sizeinput_size_coeff = 4 ## 张量并行组中,各个进程持有张量的output_sizeinput_size = input_size_coeff * tensor_model_parallel_sizeoutput_size_coeff = 2output_size = output_size_coeff * tensor_model_parallel_size# 初始化一个产生二维张量的模拟网络,输入的张量为(batch_size, input_size)batch_size = 6identity_layer = IdentityLayer2D(batch_size, input_size).cuda()# 初始化一个列并行线性层linear_layer = mpu.ColumnParallelLinear(input_size, output_size, keep_master_weight_for_test=True, gather_output=False).cuda()# 随机初始化一个loss权重# 主要是为了计算标量的loss,从而验证梯度是否正确loss_weight = torch.randn([batch_size, output_size]).cuda()## 前向传播input_ = identity_layer()# 此时,张量并行组中各个进程持有的output仅是完整输出张量的一部分output = linear_layer(input_)[0]if torch.distributed.get_rank() == 0:print(f"> Output size without tensor parallel is ({batch_size},{output_size})")torch.distributed.barrier()info = f"*"*20 + \f"\n> global_rank={global_rank}\n" + \f"> output size={output.size()}\n"print(info, end="")

测试结果

在这里插入图片描述

可以看到,没有并行情况下的期望输出为(6,4)。张量并行度为2的情况下,各个rank的输出维度为(6,2)

2. 行并行

​ 行并行在前向传播时,张量并行组中各个进程不仅要持有部分权重,也还持有部分的输入张量。前向传播的过程可以简单表示为
loss = f ( Y ) = f ( X A ) = f ( [ X 1 , X 2 ] [ A 1 A 2 ] ) = f ( [ X 1 A 1 + X 2 A 2 ] ) \begin{aligned} \text{loss}&=f(Y) =f(XA)\\ &= f([X_1,X_2]\left[ \begin{array}{l} A_1 \\ A_2 \\ \end{array} \right]) \\ &=f([X_1A_1+X_2A_2]) \\ \end{aligned} loss=f(Y)=f(XA)=f([X1,X2][A1A2])=f([X1A1+X2A2])
张量并行组中Rank0持有 X 1 X_1 X1 A 1 A_1 A1,Rank1持有 X 2 X_2 X2 A 2 A_2 A2,并在各自的GPU上完成前向传播后再合并起来。

​ 反向传播的过程
KaTeX parse error: Undefined control sequence: \part at position 8: \frac{\̲p̲a̲r̲t̲ ̲f}{\part X_1} =…

源代码

class RowParallelLinear(torch.nn.Module):"""行并行线性层.线性层的定义为Y = XA + b. xA沿着第一个维度并行,X沿着第二个维度并行. 即-   -| A_1 || .   |A = | .   |        X = [X_1, ..., X_p]| .   || A_p |-   -参数:input_size: 矩阵A的第一维度.output_size: 矩阵A的第二维度.bias: 若为true则添加bias.input_is_parallel:  若为true,则认为输入应用被划分至各个GPU上,不需要进一步的划分.init_method: 随机初始化方法.stride: strided线性层."""def __init__(self, input_size, output_size, bias=True,input_is_parallel=False,init_method=init.xavier_normal_, stride=1,keep_master_weight_for_test=False,skip_bias_add=False):super(RowParallelLinear, self).__init__()self.input_size = input_sizeself.output_size = output_sizeself.input_is_parallel = input_is_parallel# 获得张量并行组的world_sizeworld_size = get_tensor_model_parallel_world_size()# 按照张量并行度(world_size)划分输出维度self.input_size_per_partition = divide(input_size, world_size)self.skip_bias_add = skip_bias_add# Parameters.# Note: torch.nn.functional.linear 执行 XA^T+bargs = get_args()if args.use_cpu_initialization:# 初始化张量. 若完整权重矩阵A为n*m,张量并行度为k,这里初始化的张量为n*(m/k)# 也就是张量并行组中的进程各自初始化持有的部分张量self.weight = Parameter(torch.empty(self.output_size,self.input_size_per_partition,dtype=args.params_dtype))# 使用init_method对权重矩阵self.weight进行随机初始化(CPU版)# self.master_weight在测试中使用,这里不需要关注self.master_weight = _initialize_affine_weight_cpu(self.weight, self.output_size, self.input_size,self.input_size_per_partition, 1, init_method,stride=stride, return_master_weight=keep_master_weight_for_test)else:self.weight = Parameter(torch.empty(self.output_size, self.input_size_per_partition,device=torch.cuda.current_device(), dtype=args.params_dtype))# 使用init_method对权重矩阵self.weight进行随机初始化(GPU版)_initialize_affine_weight_gpu(self.weight, init_method,partition_dim=1, stride=stride)if bias:# 实例化一个biasif args.use_cpu_initialization:self.bias = Parameter(torch.empty(self.output_size,dtype=args.params_dtype))else:self.bias = Parameter(torch.empty(self.output_size, device=torch.cuda.current_device(),dtype=args.params_dtype))# Always initialize bias to zero.with torch.no_grad():self.bias.zero_()else:self.register_parameter('bias', None)self.bias_tp_auto_sync = args.sync_tp_duplicated_parametersdef forward(self, input_):if self.input_is_parallel:input_parallel = input_else:# 前向传播时,将input_分片至张量并行组中的各个进程中# 反向传播时,将张量并行组中持有的部分input_梯度合并为完整的梯度# 此时,_input是完整的输入张量,input_parallel则是分片后的张量,即input_parallel!=_inputinput_parallel = scatter_to_tensor_model_parallel_region(input_)output_parallel = F.linear(input_parallel, self.weight)# 对张量并行组中的输出进行allreduce,即操作X1A1+X2A2output_ = reduce_from_tensor_model_parallel_region(output_parallel)if self.bias_tp_auto_sync:torch.distributed.all_reduce(self.bias, op=torch.distributed.ReduceOp.AVG, group=mpu.get_tensor_model_parallel_group())if not self.skip_bias_add:output = output_ + self.bias if self.bias is not None else output_output_bias = Noneelse:output = output_output_bias = self.biasreturn output, output_bias

测试代码

​ 由于列并行层RowParallelLinear完成屏蔽了内部的并行细节,无法从输入输出中理解其执行过程。因此,这里的测试会对其forward方法进行重写,以便展现细节。

class MyRowParallelLinear(mpu.RowParallelLinear):def forward(self, input_):global_rank = torch.distributed.get_rank()# 输入X,权重A和输出Y的形状X_size = list(input_.size())A_size = [self.input_size, self.output_size]Y_size = [X_size[0], A_size[1]]if self.input_is_parallel:input_parallel = input_else:input_parallel = mpu.scatter_to_tensor_model_parallel_region(input_)Xi_size = list(input_parallel.size())Ai_size = list(self.weight.T.size())info = f"*"*20 + \f"\n> global_rank={global_rank}\n" + \f"> size of X={X_size}\n" + \f"> size of A={A_size}\n" + \f"> size of Y={Y_size}\n" + \f"> size of Xi={Xi_size}\n" + \f"> size of Ai={Ai_size}\n"output_parallel = F.linear(input_parallel, self.weight)# 通过在output_parallel保证不同rank的output_parallel,便于观察后续的结果output_parallel = output_parallel + global_rankYi_size = list(output_parallel.size())info += f"> size of Yi={Yi_size}\n" + \f"> Yi={output_parallel}\n"output_ = mpu.reduce_from_tensor_model_parallel_region(output_parallel)info += f"> Y={output_}"if self.bias_tp_auto_sync:torch.distributed.all_reduce(self.bias, op=torch.distributed.ReduceOp.AVG, group=mpu.get_tensor_model_parallel_group())if not self.skip_bias_add:output = output_ + self.bias if self.bias is not None else output_output_bias = Noneelse:output = output_output_bias = self.biasprint(info)return output, output_biasdef test_row_parallel_linear():global_rank = torch.distributed.get_rank()tensor_model_parallel_size = mpu.get_tensor_model_parallel_world_size()# 设置随机种子seed = 12345set_random_seed(seed)# 张量并行组中,各个进程持有张量的input_sizeinput_size_coeff = 4input_size = input_size_coeff * tensor_model_parallel_size# 张量并行组中,各个进程持有张量的output_sizeoutput_size_coeff = 2output_size = output_size_coeff * tensor_model_parallel_size# 初始化一个产生二维张量的模拟网络,输入的张量为(batch_size, input_size)batch_size = 6identity_layer = IdentityLayer2D(batch_size, input_size).cuda()# 初始化一个行并行线性层linear_layer = MyRowParallelLinear(input_size, output_size, keep_master_weight_for_test=True).cuda()# 前向传播input_ = identity_layer()output = linear_layer(input_)

测试结果

在这里插入图片描述

四、完整测试代码

# test_layers.py
import sys
sys.path.append("..")import os
import torch.nn.functional as F
from megatron import get_args
from megatron.mpu import layers
from megatron.initialize import _initialize_distributed
from megatron.global_vars import set_global_variables
from commons import set_random_seed
from commons import print_separator
from commons import initialize_distributed
import megatron.mpu as mpu
import torch.nn.init as init
from torch.nn.parameter import Parameter
import torch
import randomclass IdentityLayer2D(torch.nn.Module):"""模拟一个输入为二维张量的神经网络"""def __init__(self, m, n):super(IdentityLayer2D, self).__init__()self.weight = Parameter(torch.Tensor(m, n))torch.nn.init.xavier_normal_(self.weight)def forward(self):return self.weightdef test_column_parallel_linear():global_rank = torch.distributed.get_rank()tensor_model_parallel_size = mpu.get_tensor_model_parallel_world_size()# 设置随机数种子seed = 12345set_random_seed(seed)# 张量并行组中,各个进程持有张量的input_sizeinput_size_coeff = 4 ## 张量并行组中,各个进程持有张量的output_sizeinput_size = input_size_coeff * tensor_model_parallel_sizeoutput_size_coeff = 2output_size = output_size_coeff * tensor_model_parallel_size# 初始化一个产生二维张量的模拟网络,输入的张量为(batch_size, input_size)batch_size = 6identity_layer = IdentityLayer2D(batch_size, input_size).cuda()# 初始化一个列并行线性层linear_layer = mpu.ColumnParallelLinear(input_size, output_size, keep_master_weight_for_test=True, gather_output=False).cuda()# 随机初始化一个loss权重# 主要是为了计算标量的loss,从而验证梯度是否正确loss_weight = torch.randn([batch_size, output_size]).cuda()## 前向传播input_ = identity_layer()# 此时,张量并行组中各个进程持有的output仅是完整输出张量的一部分output = linear_layer(input_)[0]if torch.distributed.get_rank() == 0:print(f"> Output size without tensor parallel is ({batch_size},{output_size})")torch.distributed.barrier()info = f"*"*20 + \f"\n> global_rank={global_rank}\n" + \f"> output size={output.size()}\n"print(info, end="")class MyRowParallelLinear(mpu.RowParallelLinear):def forward(self, input_):global_rank = torch.distributed.get_rank()# 输入X,权重A和输出Y的形状X_size = list(input_.size())A_size = [self.input_size, self.output_size]Y_size = [X_size[0], A_size[1]]if self.input_is_parallel:input_parallel = input_else:input_parallel = mpu.scatter_to_tensor_model_parallel_region(input_)Xi_size = list(input_parallel.size())Ai_size = list(self.weight.T.size())info = f"*"*20 + \f"\n> global_rank={global_rank}\n" + \f"> size of X={X_size}\n" + \f"> size of A={A_size}\n" + \f"> size of Y={Y_size}\n" + \f"> size of Xi={Xi_size}\n" + \f"> size of Ai={Ai_size}\n"output_parallel = F.linear(input_parallel, self.weight)# 通过在output_parallel保证不同rank的output_parallel,便于观察后续的结果output_parallel = output_parallel + global_rankYi_size = list(output_parallel.size())info += f"> size of Yi={Yi_size}\n" + \f"> Yi={output_parallel}\n"output_ = mpu.reduce_from_tensor_model_parallel_region(output_parallel)info += f"> Y={output_}"if self.bias_tp_auto_sync:torch.distributed.all_reduce(self.bias, op=torch.distributed.ReduceOp.AVG, group=mpu.get_tensor_model_parallel_group())if not self.skip_bias_add:output = output_ + self.bias if self.bias is not None else output_output_bias = Noneelse:output = output_output_bias = self.biasprint(info)return output, output_biasdef test_row_parallel_linear():global_rank = torch.distributed.get_rank()tensor_model_parallel_size = mpu.get_tensor_model_parallel_world_size()# 设置随机种子seed = 12345set_random_seed(seed)# 张量并行组中,各个进程持有张量的input_sizeinput_size_coeff = 4input_size = input_size_coeff * tensor_model_parallel_size# 张量并行组中,各个进程持有张量的output_sizeoutput_size_coeff = 2output_size = output_size_coeff * tensor_model_parallel_size# 初始化一个产生二维张量的模拟网络,输入的张量为(batch_size, input_size)batch_size = 6identity_layer = IdentityLayer2D(batch_size, input_size).cuda()# 初始化一个行并行线性层linear_layer = MyRowParallelLinear(input_size, output_size, keep_master_weight_for_test=True).cuda()# 前向传播input_ = identity_layer()output = linear_layer(input_)def main():set_global_variables(ignore_unknown_args=True)_initialize_distributed()world_size = torch.distributed.get_world_size()print_separator('Test test_column_parallel_linear')test_column_parallel_linear()print_separator('Test test_row_parallel_linear')test_row_parallel_linear()if __name__ == '__main__':main()

启动脚本

# 除了tensor-model-parallel-size和pipeline-model-parallel-size以外,
# 其余参数仅为了兼容原始代码,保存没有报错.
options=" \--tensor-model-parallel-size 2 \--pipeline-model-parallel-size 2 \--num-layers 10 \--hidden-size 768 \--micro-batch-size 2 \--num-attention-heads 32 \--seq-length 512 \--max-position-embeddings 512\--use_cpu_initialization True"cmd="deepspeed test_layers.py $@ ${options}"eval ${cmd}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/26274.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

SOME/IP学习笔记1

SOA概念 在SOA中,每个服务就好像我们每一个人在社会中扮演的角色,在对别人提供着服务的同时,同时也享受着别人提供出来的服务,人与人之间,既是彼此独立的,又是需要互相通讯的。服务提供者将功能具象为一组接口,这样使用者就能知道如何调用服务,完成某件事情,得到某个…

Windows下调试UEFI程序:Visual Studio调试

以edk2\MdeModulePkg\Application\HelloWorld这个项目作为调试目标。 1. 使用VS2017建立Makefile工程 VS2017, 新建 project,取名X64dbg_vs。 Visual C > Other > Makefile Project, 注意项目路径为HelloWord程序路径。 随便填写config中的字符串&#xff…

【并发编程】ShenyuAdmin里面数据同步用到的无锁环形队列LMAX Disruptor并发框架

并发,数据同步往往是业务开发中比较重要的部分。 shenyu网关数据同步设计方案图 shenyu官网给出的同步设计方案图如下: 基于事件异步并发框架com.lmax.disruptor 下载下示例代码,跑起来发现,在shenyuAdmin模块里面用到了com.lma…

【2.2】Java微服务:nacos的使用

✅作者简介:大家好,我是 Meteors., 向往着更加简洁高效的代码写法与编程方式,持续分享Java技术内容。 🍎个人主页:Meteors.的博客 💞当前专栏: 深度学习 ✨特色专栏: 知识分享 &…

Leetcode.2034 股票价格波动

题目链接 Leetcode.2034 股票价格波动 rating : 1832 题目描述 给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。 不巧的是,由于股票市场内在的波动性,股票价格记录可能不是按时间顺序到来的。某些情况下&a…

HTR-01 桌式4英寸快速退火炉

HTR-01 桌式4英寸快速退火炉 HTR-01A快速退火炉系列采用红外辐射加热技术,可实现4寸晶圆片吋样品快速升温和降温,同时搭配超高精度温度控制系统,可达到极佳的温场均匀性,对材料的快速热处理(RTP)、快速退火(RTA)、快速热氮化(RTN)…

观测数据建模

观测数据 观测数据 / 样本空间覆盖均匀 psm 观测数据建模 因果模型得到什么样的值 base 0/1 gmv uplift delat 模型可以得到 confounder 的表征,而 NN 可以支持更个性化的结构。在这里给出两种思路: 思路1: 使用树模型生成的 confounder embedd…

大规模数据处理的技术的五个时代和四代引擎

石器时代 随着互联网的蓬勃发展,数据量在呈指数型增长。早在2003年之前,各大厂商都已经严重面临大规模数据的处理难题,比如Google就已经面对大于600亿的搜索量。如何从海量的原始数据中挖掘出有效的信息,如何保证数据挖掘程序的容…

react组件编写最佳实践

react组件编写最佳实践 作为 React.js 开发的新手,理解基本原则并坚持实用性对于更好地快速开发至关重要。无论我们是在处理简单的任务(例如构建初学者待办事项应用程序)还是更复杂的项目(例如建立电子商务平台)&…

【Java】-【tomcat部署项目】

Tomcat 的目录结构 bin:Tomcat 的启动、关闭脚本。 conf:Tomcat 配置文件。 lib:Tomcat 需要的类库(jar 包)。 logs:日志目录。 temp:Tomcat 运行时产生的临时文件。 webapps:存放 …

相机取图后将数据转换成对应的图像处理库图像文件

相机取图后将数据转换成对应的图像处理库图像文件 前言提要一、大华相机1.to HImage 总结 前言 不同相机取完图像后的图像数据包里包含的数据并不一定是相同的,而且相机取图后的图像数据第三方的视觉库(Halcon,visionpro等)也并不…

React diff 根据相对位置的 diff 算法

文章目录 diff 算法没有 key 时的diff通过 key 的 diff查找需要移动的节点移动节点添加新元素移除不存在的元素缺点 diff 算法 没有 key 时的diff 根据新旧列表的长度进行 diff 公共长度相同的部分直接patch新列表长度>旧列表长度则添加,否则删除 function pa…

Vue3_02 创建Vue3.0工程

1.使用 vue-cli 创建 ## 查看 vue/cli 版本,确保 vue/cli 版本在4.5.0以上 vue -V 或 vue --version## 安装或升级你的 vue/cli npm install -g vue/cli## 创建 vue create vue_test## 启动 cd vue-test npm run serve 2.使用 vite 创建 什么是vite?——新一代…

31.SpringMVC

SpringMVC MVC MVC是一种软件架构的思想,将软件按照模型、视图、控制器来划分 M:Model,模型层,指工程中的JavaBean,作用是处理数据 JavaBean分为两类: 一类称为实体类Bean:专门存储业务数据的…

RxJava 倒计时,轮询器

笔记 倒计时 /*** 短信倒计时** param s*/private Subscription subscription30;public void startCountdownFinishRx30(int s) {clearFinishSubscription30();subscription30 Observable.interval(0, 1, TimeUnit.SECONDS).take(s 1).map(new Func1<Long, Long>() {O…

Java设计模式---工厂方法(Factory Method)模式

说明 工厂方法&#xff08;Factory Method&#xff09;模式是一种工厂模式&#xff0c;也叫多态性工厂&#xff08;Poloymorphic Factory&#xff09;模式。 工厂方法模式涉及如下角色&#xff1a; 抽象工厂角色&#xff1a;给出具体工厂角色必须实现的接口。具体工厂角色&a…

图像 检测 - DETR: End-to-End Object Detection with Transformers (arXiv 2020)

图像 检测 - DETR: End-to-End Object Detection with Transformers - 端到端目标检测的Transformers&#xff08;arXiv 2020&#xff09; 摘要1. 引言2. 相关工作2.1 集预测2.2 Transformers和并行解码2.3 目标检测 3. DETR模型References 声明&#xff1a;此翻译仅为个人学习…

深度学习,计算机视觉任务

目录 计算机视觉任务 1.K近邻算法 2.得分函数 3.损失函数的作用 4.向前传播整体流程 5.反向传播计算方法 计算机视觉任务 机器学习的流程&#xff1a; 数据获取 特征工程 建立模型 评估与应用 计算机视觉&#xff1a; 图像表示&#xff1a;计算机眼中的图像&#…

万界星空科技/免费开源MES系统/免费仓库管理

仓库管理&#xff08;仓储管理&#xff09;&#xff0c;指对仓库及仓库内部的物资进行收发、结存等有效控制和管理&#xff0c;确保仓储货物的完好无损&#xff0c;保证生产经营活动的正常进行&#xff0c;在此基础上对货物进行分类记录&#xff0c;通过报表分析展示仓库状态、…

开源项目如何贡献代码

以腾讯犀牛鸟开源项目ncnn为例 目录 fork项目仓库 添加远程仓库 同步更新仓库 贡献代码提交新PR PR未merge更新PR fork项目仓库 只需要做一次 到仓库页面点击fork&#xff0c;然后create forkTencent/ncnn: ncnn is a high-performance neural network inference frame…